Unix-Timestamp-Formate erklärt

Jedes Unix-Timestamp-Format auf einen Blick

Ein Unix-Timestamp ist nur eine Zahl, und sein Format ist eigentlich nur seine Einheit — wie fein er ab dem 1. Januar 1970 UTC zählt. Die Einheit ist fast immer an der Ziffernzahl ablesbar: 10 Ziffern sind Sekunden, 13 sind Millisekunden, 16 sind Mikrosekunden, 19 sind Nanosekunden. Die beiden String-Formate, ISO 8601 und RFC 2822, sind stattdessen selbstbeschreibend. Die Tabelle unten ist die gesamte Landschaft; die folgenden Abschnitte behandeln jedes Format und wie man sie unterscheidet.

Unix-Zeit in Sekunden — das universelle Format

Das häufigste Format: eine 32-Bit- oder 64-Bit-Ganzzahl, die die Anzahl ganzer Sekunden seit dem 1. Januar 1970 00:00:00 UTC zählt. Derzeit eine 10-stellige Zahl um 1,7 Milliarden.

• Beispiel: 1700000000 = 2023-11-15 06:13:20 UTC
• Verwendet von: Python time.time(), PHP time(), Go time.Now().Unix(), Ruby Time.now.to_i, C time(NULL)
• Gespeichert als: 32-Bit-int (alt, max. Jahr 2038), 64-Bit-int (modern, sicher für Milliarden Jahre)
• Datenbank: MySQL UNIX_TIMESTAMP(), PostgreSQL EXTRACT(EPOCH FROM NOW())::BIGINT

• The Open Group — Seconds Since the Epoch (POSIX)

Unix-Zeit in Millisekunden — JavaScripts Format

Millisekunden seit der Unix-Epoche: eine 13-stellige Ganzzahl mit Millisekunden-Präzision. Das ist das Format, das JavaScripts Date-Objekt intern verwendet.

• Beispiel: 1700000000000 = 2023-11-15 06:13:20.000 UTC
• Verwendet von: JavaScript Date.now(), Java System.currentTimeMillis(), .NET DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()
• Umrechnung in Sekunden: Math.floor(ms / 1000)
• Umrechnung aus Sekunden: seconds * 1000

• MDN — Date.now() und das Date-Objekt
• Millisekunden vs. Sekunden — wann was verwenden

ISO 8601 — der menschenlesbare Standard

ISO 8601 ist ein internationaler Standard zur Darstellung von Datum und Uhrzeit als Strings. Anders als Unix-Timestamps ist er selbstbeschreibend: das Format kodiert sowohl Datum/Uhrzeit als auch den Zeitzonen-Offset.

• 2023-11-15T06:13:20Z — UTC (das Z-Suffix bedeutet UTC)
• 2023-11-15T01:13:20-05:00 — mit explizitem UTC-Offset (EST)
• 2023-11-15T06:13:20.000Z — mit Millisekunden
• JavaScript: date.toISOString() liefert immer UTC mit Z-Suffix
• Python: datetime.isoformat(), Go: time.Format(time.RFC3339)

• ISO 8601 und RFC 3339 — der vollständige Formatleitfaden

RFC 2822 — E-Mail- und HTTP-Datumsformat

RFC 2822 (aktualisiert durch RFC 5322 für E-Mail und gespiegelt durch RFC 9110 für HTTP) ist das menschenlesbare Datumsformat in E-Mail-Headern und HTTP-Antworten. JavaScripts Date.toUTCString() liefert dieses Format.

• Beispiel: Wed, 15 Nov 2023 06:13:20 GMT
• Verwendet in: HTTP-Antwort-Headern (Last-Modified, Date, Expires), E-Mail-Headern (Date:)
• JavaScript: date.toUTCString()
• In modernen APIs seltener, aber in der Web-Infrastruktur noch weit verbreitet

• RFC 5322 — Internet Message Format (der Date-Header)

Wie man das Timestamp-Format erkennt

Wenn du einen unbekannten Timestamp-Wert erhältst, identifizieren diese Regeln sein Format. Die Ziffernzahl klärt jeden numerischen Fall; die beiden String-Formate sind auf den ersten Blick offensichtlich.

• Plausibilitätsprüfung: jeder numerische Wert sollte zu einem glaubwürdigen Datum der aktuellen Ära dekodieren (etwa 2001–2038 für 10-stellige Sekunden)
• Ein Datum nahe 1970 oder Tausende Jahre entfernt bedeutet, dass die Einheit falsch gelesen wurde

Mikrosekunden und Nanosekunden

Manche hochpräzisen Systeme verwenden Einheiten kleiner als Millisekunden. Diese sind in Anwendungscode selten, tauchen aber in Low-Level-Systemen, Datenbank-Internas und Observability-Tools auf.

• Mikrosekunden (µs): 16-stellige Ganzzahl — Rust SystemTime as_micros(), PostgreSQL clock_gettime()
• Nanosekunden (ns): 19-stellige Ganzzahl — Go time.Now().UnixNano(), Rust SystemTime as_nanos()
• PostgreSQL EXTRACT(EPOCH) liefert eine Gleitkommazahl mit Mikrosekunden als Nachkommateil
• Umrechnung von Nanosekunden in Sekunden: durch 1.000.000.000 (1e9) teilen

Auflösung und Sekundenbruchteil-Präzision

Jedes Format oben trägt eine andere Zeitauflösung. Ein Format zu wählen heißt zu wählen, wie fein du zwei Momente unterscheiden kannst — von einer Sekunde bis zu einer Nanosekunde.

• 1-Sekunden-Auflösung: Unix-Sekunden (10 Ziffern), traditionelles POSIX time_t
• 1-Millisekunde: JavaScript Date, MongoDB BSON Date, Java Instant.toEpochMilli()
• 1-Mikrosekunde: Chrome/WebKit-Timestamps, Python datetime.timestamp(), PostgreSQL timestamp precision 6
• 100-Nanosekunden: Windows FILETIME, .NET DateTime.Ticks
• 1-Nanosekunde: Java Instant (volle Präzision), Go time.UnixNano(), JS Temporal.Instant.epochNanoseconds (BigInt)
• Pikosekunde und darunter: PTP/IEEE-1588-Wire-Format (1/2^32 einer Sekunde), NTP-Fraction-Feld
• Wähle die gröbste Auflösung, die deine Anforderungen erfüllt — Subsekunden-Präzision geht oft bei JSON-Serialisierung oder String-Round-Trip verloren
• Beim Konvertieren zwischen Formaten über Unix-Millisekunden oder -Nanosekunden (via BigInt) gehen — das ist der kleinste gemeinsame Nenner, der die Präzision bewahrt

Timestamp-Format-Konverter

Konvertiere zwischen Unix-Zeit und den plattformspezifischen Timestamp-Formaten, denen du in freier Wildbahn begegnest:

• FILETIME-Konverter
• .NET-Ticks-Konverter
• WebKit/Chrome-Zeit
• Mac Absolute Time
• Core-Data-Timestamp
• Excel-Datums-Konverter
• NTP-Timestamp
• GPS-Zeit-Konverter
• Julianischer-Tag-Konverter