Epoch & Unix Timestamp Converter

Math.floor(Date.now() / 1000);

new Date(1800000000 * 1000).toLocaleString();
// or .toUTCString() for GMT

new Date("2024-01-15T10:30:00Z").getTime() / 1000;

import time
time.time()

import time
time.ctime(1800000000)

import calendar, time
calendar.timegm(time.strptime('2024-01-15 10:30:00', '%Y-%m-%d %H:%M:%S'))

long epoch = System.currentTimeMillis() / 1000;

String date = new java.text.SimpleDateFormat("MM/dd/yyyy HH:mm:ss")
  .format(new java.util.Date(1800000000 * 1000L));

long epoch = new java.text.SimpleDateFormat("MM/dd/yyyy HH:mm:ss")
  .parse("01/15/2024 10:30:00").getTime() / 1000;

DateTimeOffset.Now.ToUnixTimeSeconds();

new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)
  .AddSeconds(1800000000).ToShortDateString();

(DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).TotalSeconds;

time.Now().Unix()

time.Unix(1800000000, 0)

date, _ := time.Parse("2006-01-02", "2024-01-15")
epoch := date.Unix()

Time.now.to_i

Time.at(1800000000)

Time.local(2024, 1, 15, 10, 30, 0).to_i

SystemTime::now()
  .duration_since(SystemTime::UNIX_EPOCH)
  .unwrap().as_secs();

// Use chrono crate
use chrono::NaiveDateTime;
NaiveDateTime::from_timestamp_opt(1800000000, 0);

time();

date('r', 1800000000);

strtotime('2024-01-15 10:30:00');

time;

scalar localtime(1800000000);

use Time::Local;
timelocal(0, 30, 10, 15, 0, 124);

as.numeric(Sys.time())

as.POSIXct(1800000000, origin="1970-01-01", tz="GMT")

as.numeric(as.POSIXct("2024-01-15 10:30:00", tz="GMT", origin="1970-01-01"))

DateTime.now().millisecondsSinceEpoch ~/ 1000;

DateTime.fromMillisecondsSinceEpoch(1800000000 * 1000);

// C
#include <time.h>
time(NULL);

// C++
auto now = std::chrono::duration_cast<std::chrono::seconds>(
  std::chrono::system_clock::now().time_since_epoch()
).count();

// C
time_t epoch = 1800000000;
printf("%s", ctime(&epoch));

os.time()

os.date('%c', 1800000000)

DateTimeToUnix(Now, False);

DateTimeToStr(UnixToDateTime(1800000000));

SELECT UNIX_TIMESTAMP(NOW());

SELECT FROM_UNIXTIME(1800000000);

SELECT UNIX_TIMESTAMP('2024-01-15 10:30:00');

SELECT EXTRACT(EPOCH FROM now());

SELECT TO_TIMESTAMP(1800000000);

SELECT EXTRACT(EPOCH FROM date('2024-01-15 10:30'));

SELECT DATEDIFF(SECOND, '1970-01-01', GETUTCDATE());

SELECT DATEADD(SECOND, 1800000000, '1970-01-01');

SELECT unixepoch();

SELECT datetime(1800000000, 'unixepoch');

SELECT UNIX_SECONDS(CURRENT_TIMESTAMP());

SELECT TIMESTAMP_SECONDS(1800000000);

SELECT (CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE)
  - TO_DATE('01/01/1970','DD/MM/YYYY')) * 86400 FROM DUAL;

SELECT TO_DATE('01-JAN-1970','dd-mon-yyyy')
  + (1800000000/86400) FROM DUAL;

date +%s

date -d @1800000000

date +%s -d"Jan 15, 2024 10:30:00"

date +%s

date -j -r 1800000000

[DateTimeOffset]::Now.ToUnixTimeSeconds()

[DateTimeOffset]::FromUnixTimeSeconds(1800000000).LocalDateTime

N/A — use formulas below

=(A1 / 86400) + 25569
(Format cell as Date/Time. A1 = epoch in seconds. Result is GMT.)

=(A1 - 25569) * 86400
(A1 = date cell. Result is epoch in seconds.)

[[NSDate date] timeIntervalSince1970];

[NSDate dateWithTimeIntervalSince1970:1800000000];

System.currentTimeMillis() / 1000

import java.time.Instant
import java.time.ZoneId
import java.time.format.DateTimeFormatter

def formatter = DateTimeFormatter.ofPattern('dd-MM-yyyy HH:mm:ss')
  .withZone(ZoneId.of('UTC'))
println formatter.format(Instant.ofEpochSecond(1800000000))

erlang:system_time(seconds).

calendar:gregorian_seconds_to_datetime(
  1800000000 + 62167219200).

clock seconds

clock format 1800000000

posixtime(datetime('now','TimeZone','UTC'))

datestr(719529 + 1800000000/86400, 'dd-mmm-yyyy HH:MM:SS')