Timestamp Tutorials

Copyimport java.time.*;

// Current timestamp in milliseconds
long ms = Instant.now().toEpochMilli();

// Current timestamp in seconds
long sec = Instant.now().getEpochSecond();

// Convert millis back to Instant
Instant instant = Instant.ofEpochMilli(ms);

// Format as ISO 8601
String iso = instant.toString(); // "2026-03-16T10:30:00Z"

// Format with timezone
ZonedDateTime zdt = instant.atZone(ZoneId.of("America/New_York"));
String formatted = zdt.format(DateTimeFormatter.ISO_ZONED_DATE_TIME);

Copy// Measure elapsed time (correct)
long start = System.nanoTime();
doSomething();
long elapsed = System.nanoTime() - start;
System.out.printf("Took %.2f ms%n", elapsed / 1_000_000.0);

// Wall clock (correct)
long now = System.currentTimeMillis();

Copyconst now = new Date();
console.log(now.toUTCString());   // "Mon, 16 Mar 2026 10:30:00 GMT"
console.log(now.toISOString());  // "2026-03-16T10:30:00.000Z"
console.log(Date.now());         // ms since epoch (always UTC)

Copyfrom datetime import datetime, timezone

# UTC-aware datetime
now_utc = datetime.now(timezone.utc)
print(now_utc.isoformat())  # "2026-03-16T10:30:00+00:00"

# Unix timestamp (seconds)
import time
ts = time.time()  # float seconds

Copy// Safe: use Intl.DateTimeFormat with IANA timezone name
const now = new Date();
const fmt = new Intl.DateTimeFormat('en-US', {
  timeZone: 'America/New_York',
  dateStyle: 'full',
  timeStyle: 'long'
});
console.log(fmt.format(now));
// "Monday, March 16, 2026 at 6:30:00 AM EDT"

Copy// DANGER: Different parsing behavior!
new Date("2026-03-16").toISOString();
// "2026-03-16T00:00:00.000Z" — UTC midnight ✓

new Date("03/16/2026").toISOString();
// "2026-03-16T05:00:00.000Z" — local midnight in UTC-5 !

// SAFE: always append time and Z for UTC
new Date("2026-03-16T00:00:00Z").toISOString();
// "2026-03-16T00:00:00.000Z" ✓

Copy   2026  - 03  - 16  T  10 : 30 : 00 . 000  Z
   Year   Month  Day    Hr   Min  Sec  Ms   UTC

With offset:
   2026-03-16T10:30:00.000+07:00   (UTC+7)
   2026-03-16T10:30:00.000-05:00   (UTC-5)

Date only:
   2026-03-16

Week notation:
   2026-W12-1   (Year-Week-Weekday)

Copy// Julian Date from Unix milliseconds
julianDate = (unixMs / 86400000) + 2440587.5;

// Example: Jan 1, 1970 00:00:00 UTC
// (0 / 86400000) + 2440587.5 = 2440587.5

// JavaScript
const jd = (Date.now() / 86400000) + 2440587.5;

Copyconst now = Date.now(); // ms

// Constants (in milliseconds)
const SECOND = 1000;
const MINUTE = 60 * SECOND;
const HOUR   = 60 * MINUTE;
const DAY    = 24 * HOUR;
const WEEK   = 7  * DAY;

// Add 30 days
const in30Days = now + (30 * DAY);

// Subtract 2 hours
const twoHoursAgo = now - (2 * HOUR);

// Add 1 year (approximate — use date lib for exact)
const inOneYear = now + (365.25 * DAY);

Copyconst ts1 = 1700000000000;
const ts2 = 1773835800000;

// Is ts1 before ts2?
ts1 < ts2; // true

// Difference in days
const diffDays = (ts2 - ts1) / (1000 * 60 * 60 * 24);

// Is a timestamp in the past?
const isExpired = ts1 < Date.now();

// Sort array of timestamps (ascending)
const sorted = [ts2, ts1, 1000000000000].sort((a, b) => a - b);

Copy// Start of today (UTC midnight)
const now = new Date();
const startOfDay = new Date(
  Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate())
).getTime();

// Start of this month
const startOfMonth = new Date(
  Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1)
).getTime();

// End of today (last ms)
const endOfDay = startOfDay + (24 * 60 * 60 * 1000) - 1;

Copyfunction relativeTime(ms) {
  const diff = ms - Date.now();
  const abs  = Math.abs(diff);
  const rtf  = new Intl.RelativeTimeFormat('en', { numeric: 'auto' });

  if (abs < 60000)   return rtf.format(Math.round(diff/1000),   'second');
  if (abs < 3600000)  return rtf.format(Math.round(diff/60000),  'minute');
  if (abs < 86400000)  return rtf.format(Math.round(diff/3600000), 'hour');
  return rtf.format(Math.round(diff/86400000), 'day');
}

relativeTime(Date.now() - 7200000); // "2 hours ago"
relativeTime(Date.now() + 86400000); // "tomorrow"

Copyimport time
from datetime import datetime, timezone

# Milliseconds since epoch
ms = int(time.time() * 1000)
print(ms)  # e.g. 1773835800123

# Convert ms back to UTC datetime
dt = datetime.fromtimestamp(ms / 1000, tz=timezone.utc)
print(dt.isoformat())  # "2026-03-16T10:30:00.123000+00:00"

Copypackage main

import (
    "fmt"
    "time"
)

func main() {
    // Milliseconds (Go 1.17+)
    ms := time.Now().UnixMilli()
    fmt.Println(ms)

    // Convert back to time.Time
    t := time.UnixMilli(ms)
    fmt.Println(t.UTC().Format(time.RFC3339Nano))
}

Copyusing System;

// Milliseconds since epoch
long ms = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
Console.WriteLine(ms);

// Convert back to DateTimeOffset
var dt = DateTimeOffset.FromUnixTimeMilliseconds(ms);
Console.WriteLine(dt.ToString("o")); // ISO 8601

Copyuse std::time::{SystemTime, UNIX_EPOCH};

fn main() {
    let ms = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .expect("Time went backwards")
        .as_millis();

    println!("{}", ms);
}