This comprehensive guide shows you how to get the current epoch time, convert between timestamps and dates, and work with week/day numbers across all major programming languages. Whether you're building web applications, processing log files, or working with APIs, understanding how to handle Unix timestamps (also known as epoch time) is essential.
Unix epoch time represents the number of seconds since January 1, 1970, 00:00:00 UTC - a universal standard for representing time in computer systems.
P.S. For improvements and suggestions on the table use the following: Pandas-Tutorials/cheatsheet/epoch_time_cheatsheet.csv
What is Unix Epoch Time?
Epoch time (or Unix time, POSIX time) is a system for tracking time as a running count of seconds. It started at the Unix Epoch: January 1, 1970, at 00:00:00 UTC. This standardized format makes it perfect for:
- Database timestamps and indexing
- API data exchange between systems
- Log file analysis and monitoring
- Time calculations without timezone complexity
- Cross-platform compatibility
Current Unix Timestamp: As of February 15, 2026, the epoch time is approximately 1,739,577,600 seconds.
Complete Epoch Time Operations by Language
This comprehensive table shows all common epoch time operations across programming languages, ordered by popularity:
| Language | Get Current Epoch Time | Human → Epoch | Epoch → Human | Week # | Day # | Since Year 0 |
|---|---|---|---|---|---|---|
| JavaScript | Math.floor(Date.now()/1000) |
Math.floor(new Date('2026-02-15').getTime()/1000) |
new Date(1739577600*1000).toISOString() |
Use date-fns lib |
Math.floor((new Date()-new Date(new Date().getFullYear(),0,0))/86400000) |
Math.floor(Date.now()/1000)+63839616000 |
| Python | int(time.time()) |
int(datetime(2026,2,15).timestamp()) |
datetime.fromtimestamp(1739577600) |
datetime.now().isocalendar()[1] |
datetime.now().timetuple().tm_yday |
int(time.time())+63839616000 |
| Bash/Shell | date +%s |
date -d "2026-02-15" +%s |
date -d @1739577600 |
date +%V |
date +%j |
echo $(($(date +%s)+63839616000)) |
| TypeScript | Math.floor(Date.now()/1000) |
Math.floor(new Date('2026-02-15').getTime()/1000) |
new Date(1739577600*1000).toISOString() |
Use date-fns lib |
Math.floor((new Date()-new Date(new Date().getFullYear(),0,0))/86400000) |
Math.floor(Date.now()/1000)+63839616000 |
| Java | Instant.now().getEpochSecond() |
LocalDateTime.of(2026,2,15,0,0).toEpochSecond(ZoneOffset.UTC) |
Instant.ofEpochSecond(1739577600) |
LocalDate.now().get(WeekFields.ISO.weekOfWeekBasedYear()) |
LocalDate.now().getDayOfYear() |
Instant.now().getEpochSecond()+63839616000L |
| C# | DateTimeOffset.UtcNow.ToUnixTimeSeconds() |
new DateTimeOffset(2026,2,15,0,0,0,TimeSpan.Zero).ToUnixTimeSeconds() |
DateTimeOffset.FromUnixTimeSeconds(1739577600) |
CultureInfo.CurrentCulture.Calendar.GetWeekOfYear(DateTime.Now,CalendarWeekRule.FirstFourDayWeek,DayOfWeek.Monday) |
DateTime.Now.DayOfYear |
DateTimeOffset.UtcNow.ToUnixTimeSeconds()+63839616000 |
| C++20 | std::chrono::system_clock::now().time_since_epoch().count()/1000000000 |
std::chrono::sys_days{2026y/February/15d}.time_since_epoch().count()/86400*86400 |
std::chrono::sys_seconds{std::chrono::seconds{1739577600}} |
Use date library |
Use date library |
std::chrono::system_clock::now().time_since_epoch().count()/1000000000+63839616000 |
| PowerShell | [DateTimeOffset]::UtcNow.ToUnixTimeSeconds() |
[DateTimeOffset]::new(2026,2,15,0,0,0,[TimeSpan]::Zero).ToUnixTimeSeconds() |
[DateTimeOffset]::FromUnixTimeSeconds(1739577600) |
(Get-Date).ToString('ww') |
(Get-Date).DayOfYear |
[DateTimeOffset]::UtcNow.ToUnixTimeSeconds()+63839616000 |
| PHP | time() |
strtotime('2026-02-15') |
date('Y-m-d H:i:s',1739577600) |
date('W') |
date('z')+1 |
time()+63839616000 |
| Go | time.Now().Unix() |
time.Date(2026,2,15,0,0,0,0,time.UTC).Unix() |
time.Unix(1739577600,0) |
_,week:=time.Now().ISOWeek();week |
time.Now().YearDay() |
time.Now().Unix()+63839616000 |
| Rust | SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs() |
chrono::NaiveDate::from_ymd_opt(2026,2,15).unwrap().and_hms_opt(0,0,0).unwrap().timestamp() |
chrono::NaiveDateTime::from_timestamp_opt(1739577600,0) |
Use chrono crate |
chrono::Local::now().ordinal() |
SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs()+63839616000 |
| Kotlin | Clock.System.now().epochSeconds |
LocalDateTime(2026,2,15,0,0).toInstant(TimeZone.UTC).epochSeconds |
Instant.fromEpochSeconds(1739577600) |
Clock.System.now().toLocalDateTime(TimeZone.UTC).weekOfYear |
Clock.System.now().toLocalDateTime(TimeZone.UTC).dayOfYear |
Clock.System.now().epochSeconds+63839616000 |
| Lua | os.time() |
os.time({year=2026,month=2,day=15}) |
os.date('%Y-%m-%d %H:%M:%S',1739577600) |
tonumber(os.date('%V')) |
tonumber(os.date('%j')) |
os.time()+63839616000 |
| Ruby | Time.now.to_i |
Time.new(2026,2,15).to_i |
Time.at(1739577600) |
Time.now.strftime('%V').to_i |
Time.now.yday |
Time.now.to_i+63839616000 |
| Dart | DateTime.now().millisecondsSinceEpoch~/1000 |
DateTime(2026,2,15).millisecondsSinceEpoch~/1000 |
DateTime.fromMillisecondsSinceEpoch(1739577600*1000) |
Use intl package |
DateTime.now().difference(DateTime(DateTime.now().year,1,1)).inDays+1 |
DateTime.now().millisecondsSinceEpoch~/1000+63839616000 |
| Swift | Int(Date().timeIntervalSince1970) |
Int(Calendar.current.date(from:DateComponents(year:2026,month:2,day:15))!.timeIntervalSince1970) |
Date(timeIntervalSince1970:1739577600) |
Calendar.current.component(.weekOfYear,from:Date()) |
Calendar.current.ordinality(of:.day,in:.year,for:Date())! |
Int(Date().timeIntervalSince1970)+63839616000 |
| R | as.numeric(Sys.time()) |
as.numeric(as.POSIXct('2026-02-15',tz='UTC')) |
as.POSIXct(1739577600,origin='1970-01-01') |
as.numeric(format(Sys.time(),'%V')) |
as.numeric(format(Sys.time(),'%j')) |
as.numeric(Sys.time())+63839616000 |
| VB.NET | DateTimeOffset.UtcNow.ToUnixTimeSeconds() |
New DateTimeOffset(2026,2,15,0,0,0,TimeSpan.Zero).ToUnixTimeSeconds() |
DateTimeOffset.FromUnixTimeSeconds(1739577600) |
CultureInfo.CurrentCulture.Calendar.GetWeekOfYear(DateTime.Now,CalendarWeekRule.FirstFourDayWeek,DayOfWeek.Monday) |
DateTime.Now.DayOfYear |
DateTimeOffset.UtcNow.ToUnixTimeSeconds()+63839616000 |
| VBA | DateDiff("s",#1/1/1970#,Now()) |
DateDiff("s",#1/1/1970#,DateSerial(2026,2,15)) |
DateAdd("s",1739577600,#1/1/1970#) |
Format(Now(),"ww") |
Format(Now(),"y") |
DateDiff("s",#1/1/1970#,Now())+63839616000 |
| Perl | time |
use Time::Local;timegm(0,0,0,15,1,2026) |
use POSIX;strftime('%Y-%m-%d',localtime(1739577600)) |
use POSIX;strftime('%V',localtime()) |
use POSIX;strftime('%j',localtime()) |
time+63839616000 |
| Delphi | DateTimeToUnix(Now) |
DateTimeToUnix(EncodeDate(2026,2,15)) |
UnixToDateTime(1739577600) |
WeekOf(Now) |
DayOfTheYear(Now) |
DateTimeToUnix(Now)+63839616000 |
| Elixir | :os.system_time(:second) |
`DateTime.new!(D[2026-02-15],T[00:00:00]) | >DateTime.to_unix()` | DateTime.from_unix!(1739577600) |
`Date.utc_today() | >Date.week_of_year()` |
| Scala | Instant.now().getEpochSecond |
LocalDateTime.of(2026,2,15,0,0).toEpochSecond(ZoneOffset.UTC) |
Instant.ofEpochSecond(1739577600) |
LocalDate.now().get(WeekFields.ISO.weekOfWeekBasedYear()) |
LocalDate.now().getDayOfYear |
Instant.now().getEpochSecond+63839616000L |
| Erlang | erlang:system_time(second) |
calendar:datetime_to_gregorian_seconds({{2026,2,15},{0,0,0}})-62167219200 |
calendar:gregorian_seconds_to_datetime(1739577600+62167219200) |
Use library | Use library | erlang:system_time(second)+63839616000 |
| F# | DateTimeOffset.UtcNow.ToUnixTimeSeconds() |
DateTimeOffset(2026,2,15,0,0,0,TimeSpan.Zero).ToUnixTimeSeconds() |
DateTimeOffset.FromUnixTimeSeconds(1739577600L) |
System.Globalization.CultureInfo.CurrentCulture.Calendar.GetWeekOfYear(DateTime.Now,CalendarWeekRule.FirstFourDayWeek,DayOfWeek.Monday) |
DateTime.Now.DayOfYear |
DateTimeOffset.UtcNow.ToUnixTimeSeconds()+63839616000L |
| MySQL | SELECT UNIX_TIMESTAMP() |
SELECT UNIX_TIMESTAMP('2026-02-15') |
SELECT FROM_UNIXTIME(1739577600) |
SELECT WEEK(NOW(),3) |
SELECT DAYOFYEAR(NOW()) |
SELECT UNIX_TIMESTAMP()+63839616000 |
| PostgreSQL | SELECT EXTRACT(EPOCH FROM NOW()) |
SELECT EXTRACT(EPOCH FROM '2026-02-15'::timestamp) |
SELECT TO_TIMESTAMP(1739577600) |
SELECT EXTRACT(WEEK FROM NOW()) |
SELECT EXTRACT(DOY FROM NOW()) |
SELECT EXTRACT(EPOCH FROM NOW())+63839616000 |
| SQLite | SELECT STRFTIME('%s','now') |
SELECT STRFTIME('%s','2026-02-15') |
SELECT DATETIME(1739577600,'unixepoch') |
SELECT STRFTIME('%W','now') |
SELECT STRFTIME('%j','now') |
SELECT STRFTIME('%s','now')+63839616000 |
| SQL Server | SELECT DATEDIFF(s,'1970-01-01',GETUTCDATE()) |
SELECT DATEDIFF(s,'1970-01-01','2026-02-15') |
SELECT DATEADD(s,1739577600,'1970-01-01') |
SELECT DATEPART(WEEK,GETDATE()) |
SELECT DATEPART(DAYOFYEAR,GETDATE()) |
SELECT DATEDIFF(s,'1970-01-01',GETUTCDATE())+63839616000 |
| Oracle | SELECT (CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE)-TO_DATE('01/01/1970','DD/MM/YYYY'))*86400 FROM DUAL |
SELECT (TO_DATE('15/02/2026','DD/MM/YYYY')-TO_DATE('01/01/1970','DD/MM/YYYY'))*86400 FROM DUAL |
SELECT TO_DATE('01/01/1970','DD/MM/YYYY')+1739577600/86400 FROM DUAL |
SELECT TO_CHAR(SYSDATE,'IW') FROM DUAL |
SELECT TO_CHAR(SYSDATE,'DDD') FROM DUAL |
SELECT (CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE)-TO_DATE('01/01/1970','DD/MM/YYYY'))*86400+63839616000 FROM DUAL |
Note on "Since Year 0": The value 63,839,616,000 represents approximate seconds from year 0 to Unix epoch (1970). This is calculated as 1970 years × 365.25 days/year × 86400 seconds/day ≈ 62,135,596,800 seconds, adjusted for calendar irregularities.
Quick Reference: Key Constants
- Seconds per day: 86,400
- Seconds per week: 604,800
- Seconds per year (avg): 31,557,600
- Milliseconds per second: 1,000
- Microseconds per second: 1,000,000
- Nanoseconds per second: 1,000,000,000
Common Use Cases
Database Timestamps: Store as epoch integers for efficient indexing and querying
API Integration: Exchange timestamps in epoch format for timezone-independent communication
Log Analysis: Parse and filter log entries by epoch timestamps
Time Calculations: Compute differences by simple subtraction (no timezone math)
Cache Expiry: Set TTL using epoch + seconds until expiration
How to Get Current Epoch Time in Every Programming Language
Get the current Unix timestamp (seconds since January 1, 1970) across all major programming languages. This is essential for logging, timestamping events, and database operations.
| Language | Get Current Epoch Time |
|---|---|
| JavaScript | Math.floor(Date.now()/1000) |
| Python | int(time.time()) |
| Bash/Shell | date +%s |
| TypeScript | Math.floor(Date.now()/1000) |
| Java | Instant.now().getEpochSecond() |
| C# | DateTimeOffset.UtcNow.ToUnixTimeSeconds() |
| C++20 | std::chrono::system_clock::now().time_since_epoch().count()/1000000000 |
| PowerShell | [DateTimeOffset]::UtcNow.ToUnixTimeSeconds() |
| PHP | time() |
| Go | time.Now().Unix() |
| Rust | SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs() |
| Kotlin | Clock.System.now().epochSeconds |
| Lua | os.time() |
| Ruby | Time.now.to_i |
| Dart | DateTime.now().millisecondsSinceEpoch~/1000 |
| Swift | Int(Date().timeIntervalSince1970) |
| R | as.numeric(Sys.time()) |
| VB.NET | DateTimeOffset.UtcNow.ToUnixTimeSeconds() |
| VBA | DateDiff("s",#1/1/1970#,Now()) |
| Perl | time |
| Delphi | DateTimeToUnix(Now) |
| Elixir | :os.system_time(:second) |
| Scala | Instant.now().getEpochSecond |
| Erlang | erlang:system_time(second) |
| F# | DateTimeOffset.UtcNow.ToUnixTimeSeconds() |
| MySQL | SELECT UNIX_TIMESTAMP() |
| PostgreSQL | SELECT EXTRACT(EPOCH FROM NOW()) |
| SQLite | SELECT STRFTIME('%s','now') |
| SQL Server | SELECT DATEDIFF(s,'1970-01-01',GETUTCDATE()) |
| Oracle | SELECT (CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE)-TO_DATE('01/01/1970','DD/MM/YYYY'))*86400 FROM DUAL |
Convert Human-Readable Date to Epoch Timestamp
Learn how to convert a specific date (like "2026-02-15") to a Unix timestamp for database storage, API calls, and time calculations.
| Language | Human → Epoch Conversion |
|---|---|
| JavaScript | Math.floor(new Date('2026-02-15').getTime()/1000) |
| Python | int(datetime(2026,2,15).timestamp()) |
| Bash/Shell | date -d "2026-02-15" +%s |
| TypeScript | Math.floor(new Date('2026-02-15').getTime()/1000) |
| Java | LocalDateTime.of(2026,2,15,0,0).toEpochSecond(ZoneOffset.UTC) |
| C# | new DateTimeOffset(2026,2,15,0,0,0,TimeSpan.Zero).ToUnixTimeSeconds() |
| C++20 | std::chrono::sys_days{2026y/February/15d}.time_since_epoch().count()/86400*86400 |
| PowerShell | [DateTimeOffset]::new(2026,2,15,0,0,0,[TimeSpan]::Zero).ToUnixTimeSeconds() |
| PHP | strtotime('2026-02-15') |
| Go | time.Date(2026,2,15,0,0,0,0,time.UTC).Unix() |
| Rust | chrono::NaiveDate::from_ymd_opt(2026,2,15).unwrap().and_hms_opt(0,0,0).unwrap().timestamp() |
| Kotlin | LocalDateTime(2026,2,15,0,0).toInstant(TimeZone.UTC).epochSeconds |
| Lua | os.time({year=2026,month=2,day=15}) |
| Ruby | Time.new(2026,2,15).to_i |
| Dart | DateTime(2026,2,15).millisecondsSinceEpoch~/1000 |
| Swift | Int(Calendar.current.date(from:DateComponents(year:2026,month:2,day:15))!.timeIntervalSince1970) |
| R | as.numeric(as.POSIXct('2026-02-15',tz='UTC')) |
| VB.NET | New DateTimeOffset(2026,2,15,0,0,0,TimeSpan.Zero).ToUnixTimeSeconds() |
| VBA | DateDiff("s",#1/1/1970#,DateSerial(2026,2,15)) |
| Perl | use Time::Local;timegm(0,0,0,15,1,2026) |
| Delphi | DateTimeToUnix(EncodeDate(2026,2,15)) |
| Elixir | DateTime.new!(~D[2026-02-15],~T[00:00:00])|>DateTime.to_unix() |
| Scala | LocalDateTime.of(2026,2,15,0,0).toEpochSecond(ZoneOffset.UTC) |
| Erlang | calendar:datetime_to_gregorian_seconds({{2026,2,15},{0,0,0}})-62167219200 |
| F# | DateTimeOffset(2026,2,15,0,0,0,TimeSpan.Zero).ToUnixTimeSeconds() |
| MySQL | SELECT UNIX_TIMESTAMP('2026-02-15') |
| PostgreSQL | SELECT EXTRACT(EPOCH FROM '2026-02-15'::timestamp) |
| SQLite | SELECT STRFTIME('%s','2026-02-15') |
| SQL Server | SELECT DATEDIFF(s,'1970-01-01','2026-02-15') |
| Oracle | SELECT (TO_DATE('15/02/2026','DD/MM/YYYY')-TO_DATE('01/01/1970','DD/MM/YYYY'))*86400 FROM DUAL |
Convert Epoch Timestamp to Human-Readable Date
Transform Unix timestamps back to readable dates for display in UIs, reports, and logs. Essential for making epoch times user-friendly.
| Language | Epoch → Human Conversion |
|---|---|
| JavaScript | new Date(1739577600*1000).toISOString() |
| Python | datetime.fromtimestamp(1739577600) |
| Bash/Shell | date -d @1739577600 |
| TypeScript | new Date(1739577600*1000).toISOString() |
| Java | Instant.ofEpochSecond(1739577600) |
| C# | DateTimeOffset.FromUnixTimeSeconds(1739577600) |
| C++20 | std::chrono::sys_seconds{std::chrono::seconds{1739577600}} |
| PowerShell | [DateTimeOffset]::FromUnixTimeSeconds(1739577600) |
| PHP | date('Y-m-d H:i:s',1739577600) |
| Go | time.Unix(1739577600,0) |
| Rust | chrono::NaiveDateTime::from_timestamp_opt(1739577600,0) |
| Kotlin | Instant.fromEpochSeconds(1739577600) |
| Lua | os.date('%Y-%m-%d %H:%M:%S',1739577600) |
| Ruby | Time.at(1739577600) |
| Dart | DateTime.fromMillisecondsSinceEpoch(1739577600*1000) |
| Swift | Date(timeIntervalSince1970:1739577600) |
| R | as.POSIXct(1739577600,origin='1970-01-01') |
| VB.NET | DateTimeOffset.FromUnixTimeSeconds(1739577600) |
| VBA | DateAdd("s",1739577600,#1/1/1970#) |
| Perl | use POSIX;strftime('%Y-%m-%d',localtime(1739577600)) |
| Delphi | UnixToDateTime(1739577600) |
| Elixir | DateTime.from_unix!(1739577600) |
| Scala | Instant.ofEpochSecond(1739577600) |
| Erlang | calendar:gregorian_seconds_to_datetime(1739577600+62167219200) |
| F# | DateTimeOffset.FromUnixTimeSeconds(1739577600L) |
| MySQL | SELECT FROM_UNIXTIME(1739577600) |
| PostgreSQL | SELECT TO_TIMESTAMP(1739577600) |
| SQLite | SELECT DATETIME(1739577600,'unixepoch') |
| SQL Server | SELECT DATEADD(s,1739577600,'1970-01-01') |
| Oracle | SELECT TO_DATE('01/01/1970','DD/MM/YYYY')+1739577600/86400 FROM DUAL |
Get Current Week Number (ISO 8601)
Calculate the current week number of the year (1-53) using ISO 8601 standard. Perfect for weekly reports, analytics dashboards, and calendar applications.
| Language | Get Current Week Number |
|---|---|
| JavaScript | Use date-fns library: getISOWeek(new Date()) |
| Python | datetime.now().isocalendar()[1] |
| Bash/Shell | date +%V |
| TypeScript | Use date-fns library: getISOWeek(new Date()) |
| Java | LocalDate.now().get(WeekFields.ISO.weekOfWeekBasedYear()) |
| C# | CultureInfo.CurrentCulture.Calendar.GetWeekOfYear(DateTime.Now,CalendarWeekRule.FirstFourDayWeek,DayOfWeek.Monday) |
| C++20 | Use Howard Hinnant's date library |
| PowerShell | (Get-Date).ToString('ww') |
| PHP | date('W') |
| Go | _,week:=time.Now().ISOWeek();week |
| Rust | Use chrono crate: Local::now().iso_week().week() |
| Kotlin | Clock.System.now().toLocalDateTime(TimeZone.UTC).weekOfYear |
| Lua | tonumber(os.date('%V')) |
| Ruby | Time.now.strftime('%V').to_i |
| Dart | Use intl package: weekNumber(DateTime.now()) |
| Swift | Calendar.current.component(.weekOfYear,from:Date()) |
| R | as.numeric(format(Sys.time(),'%V')) |
| VB.NET | CultureInfo.CurrentCulture.Calendar.GetWeekOfYear(DateTime.Now,CalendarWeekRule.FirstFourDayWeek,DayOfWeek.Monday) |
| VBA | Format(Now(),"ww") |
| Perl | use POSIX;strftime('%V',localtime()) |
| Delphi | WeekOf(Now) |
| Elixir | Date.utc_today()|>Date.week_of_year() |
| Scala | LocalDate.now().get(WeekFields.ISO.weekOfWeekBasedYear()) |
| Erlang | Use external library (e.g., calendar module extensions) |
| F# | System.Globalization.CultureInfo.CurrentCulture.Calendar.GetWeekOfYear(DateTime.Now,CalendarWeekRule.FirstFourDayWeek,DayOfWeek.Monday) |
| MySQL | SELECT WEEK(NOW(),3) |
| PostgreSQL | SELECT EXTRACT(WEEK FROM NOW()) |
| SQLite | SELECT STRFTIME('%W','now') |
| SQL Server | SELECT DATEPART(WEEK,GETDATE()) |
| Oracle | SELECT TO_CHAR(SYSDATE,'IW') FROM DUAL |
Get Current Day Number (Day of Year)
Find the day of the year (1-365 or 1-366 for leap years). Useful for Julian date calculations, seasonal analysis, and year-over-year comparisons.
| Language | Get Day of Year (1-366) |
|---|---|
| JavaScript | Math.floor((new Date()-new Date(new Date().getFullYear(),0,0))/86400000) |
| Python | datetime.now().timetuple().tm_yday |
| Bash/Shell | date +%j |
| TypeScript | Math.floor((new Date()-new Date(new Date().getFullYear(),0,0))/86400000) |
| Java | LocalDate.now().getDayOfYear() |
| C# | DateTime.Now.DayOfYear |
| C++20 | Use Howard Hinnant's date library |
| PowerShell | (Get-Date).DayOfYear |
| PHP | date('z')+1 |
| Go | time.Now().YearDay() |
| Rust | chrono::Local::now().ordinal() |
| Kotlin | Clock.System.now().toLocalDateTime(TimeZone.UTC).dayOfYear |
| Lua | tonumber(os.date('%j')) |
| Ruby | Time.now.yday |
| Dart | DateTime.now().difference(DateTime(DateTime.now().year,1,1)).inDays+1 |
| Swift | Calendar.current.ordinality(of:.day,in:.year,for:Date())! |
| R | as.numeric(format(Sys.time(),'%j')) |
| VB.NET | DateTime.Now.DayOfYear |
| VBA | Format(Now(),"y") |
| Perl | use POSIX;strftime('%j',localtime()) |
| Delphi | DayOfTheYear(Now) |
| Elixir | Date.utc_today()|>Date.day_of_year() |
| Scala | LocalDate.now().getDayOfYear |
| Erlang | Use external library or custom calculation |
| F# | DateTime.Now.DayOfYear |
| MySQL | SELECT DAYOFYEAR(NOW()) |
| PostgreSQL | SELECT EXTRACT(DOY FROM NOW()) |
| SQLite | SELECT STRFTIME('%j','now') |
| SQL Server | SELECT DATEPART(DAYOFYEAR,GETDATE()) |
| Oracle | SELECT TO_CHAR(SYSDATE,'DDD') FROM DUAL |
Calculate Seconds Since Year 0 (Gregorian Calendar)
Compute total seconds from the theoretical year 0 to now. Used in astronomical calculations, historical dating, and long-term time series. Base value: ~63,839,616,000 seconds from year 0 to Unix epoch (1970).
| Language | Seconds Since Year 0 |
|---|---|
| JavaScript | Math.floor(Date.now()/1000)+63839616000 |
| Python | int(time.time())+63839616000 |
| Bash/Shell | echo $(($(date +%s)+63839616000)) |
| TypeScript | Math.floor(Date.now()/1000)+63839616000 |
| Java | Instant.now().getEpochSecond()+63839616000L |
| C# | DateTimeOffset.UtcNow.ToUnixTimeSeconds()+63839616000 |
| C++20 | std::chrono::system_clock::now().time_since_epoch().count()/1000000000+63839616000 |
| PowerShell | [DateTimeOffset]::UtcNow.ToUnixTimeSeconds()+63839616000 |
| PHP | time()+63839616000 |
| Go | time.Now().Unix()+63839616000 |
| Rust | SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs()+63839616000 |
| Kotlin | Clock.System.now().epochSeconds+63839616000 |
| Lua | os.time()+63839616000 |
| Ruby | Time.now.to_i+63839616000 |
| Dart | DateTime.now().millisecondsSinceEpoch~/1000+63839616000 |
| Swift | Int(Date().timeIntervalSince1970)+63839616000 |
| R | as.numeric(Sys.time())+63839616000 |
| VB.NET | DateTimeOffset.UtcNow.ToUnixTimeSeconds()+63839616000 |
| VBA | DateDiff("s",#1/1/1970#,Now())+63839616000 |
| Perl | time+63839616000 |
| Delphi | DateTimeToUnix(Now)+63839616000 |
| Elixir | :os.system_time(:second)+63839616000 |
| Scala | Instant.now().getEpochSecond+63839616000L |
| Erlang | erlang:system_time(second)+63839616000 |
| F# | DateTimeOffset.UtcNow.ToUnixTimeSeconds()+63839616000L |
| MySQL | SELECT UNIX_TIMESTAMP()+63839616000 |
| PostgreSQL | SELECT EXTRACT(EPOCH FROM NOW())+63839616000 |
| SQLite | SELECT STRFTIME('%s','now')+63839616000 |
| SQL Server | SELECT DATEDIFF(s,'1970-01-01',GETUTCDATE())+63839616000 |
| Oracle | SELECT (CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE)-TO_DATE('01/01/1970','DD/MM/YYYY'))*86400+63839616000 FROM DUAL |