Unix-Zeitstempel in Daten umrechnen (und zurück)

Was ist ein Unix-Zeitstempel?

Ein Unix-Zeitstempel (auch Unix-Zeit, POSIX-Zeit oder Epochenzeit genannt) ist die Anzahl der Sekunden, die seit 00:00:00 UTC am 1. Januar 1970 vergangen sind, ohne Schaltsekunden. Dieser Moment wird als Unix-Epoche bezeichnet.

Zum Beispiel:

• 0 = 1970-01-01 00:00:00 UTC (die Epoche)
• 1.000.000.000 = 2001-09-09 01:46:40 UTC (das „Milliardenste")
• 1.234.567.890 = 2009-02-13 23:31:30 UTC
• 1.700.000.000 = 2023-11-14 22:13:20 UTC
• 2.000.000.000 = 2033-05-18 03:33:20 UTC

Unix-Zeitstempel sind überall in der Informatik:

• Datenbanken: PostgreSQL, MySQL und SQLite speichern die Zeit intern als Unix-Zeitstempel (oder mit Bezug darauf).
• Dateisysteme: ext4, NTFS und APFS speichern Datei-mtimes als Unix-Zeitstempel.
• APIs: JSON-APIs geben Zeitstempel häufig als Ganzzahlen zurück, z. B. `"created_at": 1700000000`.
• Logs: Die meisten Protokollierungssysteme geben Zeitstempel im Unix-Format aus.
• Programmiersprachen: PHP, Python, JavaScript, Go, Rust und Java haben alle eingebaute Unterstützung.

Der Grund, warum Unix-Zeitstempel beliebt sind: Sie sind einfache Ganzzahlen, leicht zu vergleichen, leicht zu sortieren, zeitzonenunabhängig (sie beziehen sich immer auf UTC) und trivial zu speichern. Sie machen auch Arithmetik einfach — um die Dauer zweier Ereignisse zu finden, subtrahieren Sie ihre Zeitstempel.

Wie man einen Unix-Zeitstempel liest

Das mentale Modell: Stellen Sie sich eine Uhr vor, die um Mitternacht UTC am 1. Januar 1970 zu ticken begann und seitdem Sekunden zählt. Der Unix-Zeitstempel ist die Anzeige dieser Uhr.

``` 1 Minute = 60 Sekunden 1 Stunde = 3.600 Sekunden 1 Tag = 86.400 Sekunden (24 × 60 × 60) 1 Woche = 604.800 Sekunden (7 × 86.400) 1 Jahr ≈ 31.536.000 Sekunden (365,25 × 86.400, Durchschnitt) 1 Jahrzehnt ≈ 315.360.000 Sekunden ```

Einige mentale Anker:

• 1.000.000.000 = 2001-09-09. Das Unix-Milliardenste — die erste Sekunde mit 10 Ziffern.
• 1.500.000.000 = 2017-07-14. Die „1,5-Milliarden"-Marke.
• 2.000.000.000 = 2033-05-18. Das erste 2-Milliarden-Sekunden-Datum.
• Das 2038-Problem: 32-Bit-Ganzzahlen mit Vorzeichen laufen bei 2.147.483.647 über, das ist 2038-01-19 03:14:07 UTC. Danach laufen 32-Bit-Unix-Zeitstempel zu negativen Werten über.

Die exakten Umrechnungsformeln

Zeitstempel zu menschlichem Datum

``` human_date = Epoche + Zeitstempel-Sekunden (UTC) local_date = human_date in lokale Zeitzone konvertiert ```

In den meisten Programmiersprachen:

```python import datetime ts = 1700000000 utc = datetime.datetime.fromtimestamp(ts, tz=datetime.timezone.utc) # 2023-11-14 22:13:20+00:00 local = datetime.datetime.fromtimestamp(ts) # hängt von Ihrer Systemzeitzone ab ```

```js const ts = 1700000000; const date = new Date(ts * 1000); // JS verwendet Millisekunden // 2023-11-14T22:13:20.000Z ```

Menschliches Datum zu Zeitstempel

``` timestamp = (date - Epoche) in Sekunden ```

```python import datetime d = datetime.datetime(2023, 11, 14, 22, 13, 20, tzinfo=datetime.timezone.utc) ts = int(d.timestamp()) # 1700000000 ```

```js const d = new Date("2023-11-14T22:13:20Z"); const ts = Math.floor(d.getTime() / 1000); // 1700000000 ```

Häufige Zeitzonen-Offsets (relativ zu UTC)

Wenn Sie mit Zeitstempeln arbeiten, müssen Sie oft in einer bestimmten Zeitzone anzeigen:

| Zeitzone | Abkürzung | Offset | Beispieldtädte | |----------------------------------|-----------|-----------------|------------------------------| | Koordinierte Weltzeit | UTC | 0 | London (Winter), Reykjavik | | Eastern Standard Time | EST | UTC−5 | New York (Winter) | | Eastern Daylight Time | EDT | UTC−4 | New York (Sommer) | | Pacific Standard Time | PST | UTC−8 | Los Angeles (Winter) | | Pacific Daylight Time | PDT | UTC−7 | Los Angeles (Sommer) | | Mitteleuropäische Zeit | CET | UTC+1 | Paris (Winter), Berlin | | Mitteleuropäische Sommerzeit | CEST | UTC+2 | Paris (Sommer), Berlin | | Japanische Standardzeit | JST | UTC+9 | Tokio | | Chinesische Standardzeit | CST | UTC+8 | Peking, Shanghai | | Indische Standardzeit | IST | UTC+5:30 | Mumbai, Delhi | | Australian Eastern Standard Time | AEST | UTC+10 | Sydney (Winter) | | Australian Eastern Daylight Time | AEDT | UTC+11 | Sydney (Sommer) |

Beachten Sie, dass einige Länder (Indien, China) einen ganzjährigen einzigen Offset ohne Sommerzeit beobachten.

Methode 1: Den Zeitumrechner von UtilBoxx verwenden (Empfohlen)

Der schnellste, privateste und genaueste Weg, Unix-Zeitstempel im Browser umzurechnen, ist der Zeitumrechner von UtilBoxx. Er unterstützt sowohl Sekunden als auch Millisekunden, zeigt in jeder Zeitzone an und zeigt das entsprechende ISO 8601-Datum, UTC und Ortszeit. Alles läuft in Ihrem Browser — kein Server, kein Upload, keine Logs.

So verwenden Sie ihn:

1. Gehen Sie zu utilboxx.com/de/tools/unit/time
2. Geben Sie einen Unix-Zeitstempel (in Sekunden) oder eine Datumszeichenfolge ein
3. Der umgerechnete Wert erscheint sofort
4. Wechseln Sie mit einem Klick zwischen Zeitzonen
5. Kopieren Sie das Ergebnis

Warum wir diese Methode empfehlen:

• 100 % kostenlos, keine Registrierung, keine E-Mail, keine Werbung
• Privatsphäre zuerst: Nichts verlässt Ihren Browser
• Bidirektional: Zeitstempel ↔ Datum in beide Richtungen
• Mehrere Zeitzonen: Sehen Sie Ihren Zeitstempel in UTC, Ihrer lokalen Zone oder einer beliebigen Zone
• Verarbeitet Millisekunden für Zeitstempel im JavaScript-Stil
• Funktioniert auf jedem Gerät mit Browser

Wenn Sie mit APIs, Logs oder Datenbanken arbeiten, die Zeit als Unix-Zeitstempel speichern, amortisiert sich dieses Werkzeug in der ersten Woche.

Methode 2: Python (datetime-Modul)

Pythons `datetime`-Modul ist das kanonische Werkzeug für Zeitstempelumrechnungen. Die zwei Schlüsselfunktionen sind `fromtimestamp()` und `timestamp()`.

```python import datetime from zoneinfo import ZoneInfo

# Zeitstempel in Datum umrechnen (UTC) ts = 1700000000 utc_date = datetime.datetime.fromtimestamp(ts, tz=datetime.timezone.utc) # 2023-11-14 22:13:20+00:00

# Zeitstempel in Datum in einer bestimmten Zeitzone umrechnen ny_tz = ZoneInfo("America/New_York") ny_date = datetime.datetime.fromtimestamp(ts, tz=ny_tz) # 2023-11-14 17:13:20-05:00

# Datum in Zeitstempel umrechnen d = datetime.datetime(2023, 11, 14, 22, 13, 20, tzinfo=datetime.timezone.utc) ts = int(d.timestamp()) # 1700000000

# Jetzt: aktueller Zeitstempel now_ts = int(datetime.datetime.now(tz=datetime.timezone.utc).timestamp())

# Datum als ISO 8601 formatieren print(utc_date.isoformat()) # 2023-11-14T22:13:20+00:00 ```

Python 3.9+ hat auch die einfachere Form `datetime.fromtimestamp(ts, tz=UTC)`, und das `zoneinfo`-Modul (das das ältere `pytz` ersetzt) macht die Zeitzonenbehandlung einfach.

Methode 3: Bash / Kommandozeile

Der `date`-Befehl unter macOS und Linux kann Unix-Zeitstempel sowohl analysieren als auch ausgeben.

```bash # Unix-Zeitstempel in lesbares Datum umrechnen (macOS / BSD) date -r 1700000000 # Tue Nov 14 22:13:20 UTC 2023

# Unix-Zeitstempel umrechnen (Linux / GNU date) date -d @1700000000 # Tue Nov 14 22:13:20 UTC 2023

# Aktuellen Unix-Zeitstempel abrufen date +%s # 1700000000 (oder was auch immer gerade aktuell ist)

# Datumszeichenfolge in Unix-Zeitstempel umrechnen (GNU) date -d "2023-11-14 22:13:20 UTC" +%s # 1700000000

# Datumszeichenfolge in Unix-Zeitstempel umrechnen (macOS) date -j -f "%Y-%m-%d %H:%M:%S" "2023-11-14 22:13:20" +%s # 1700000000

# In einer bestimmten Zeitzone anzeigen TZ="America/New_York" date -d @1700000000 # Tue Nov 14 17:13:20 EST 2023 ```

Die Syntax unterscheidet sich zwischen macOS und Linux. Unter macOS liest `-r` einen Zeitstempel; unter Linux liest `-d @...` einen Zeitstempel und `-d "..."` analysiert ein Datum. Zum Skripten ist die GNU-Form (Linux) freundlicher; die macOS-Form ist umständlicher, funktioniert aber.

Methode 4: JavaScript (im Browser oder Node.js)

JavaScript verwendet Millisekunden für Unix-Zeitstempel, nicht Sekunden. Multiplizieren Sie mit 1.000, wenn Sie von Sekunden zu Millisekunden gehen.

```js // Aktueller Zeitstempel in Millisekunden const now = Date.now(); // z. B. 1700000000000

// Sekunden in Millisekunden umrechnen und Date erstellen const ts = 1700000000; const date = new Date(ts * 1000); // 2023-11-14T22:13:20.000Z

// In einer bestimmten Zeitzone mit Intl anzeigen console.log(date.toLocaleString("en-US", { timeZone: "America/New_York" })); // 11/14/2023, 5:13:20 PM

// Als ISO 8601 anzeigen console.log(date.toISOString()); // 2023-11-14T22:13:20.000Z

// Datum in Zeitstempel (Sekunden) umrechnen const d = new Date("2023-11-14T22:13:20Z"); const ts2 = Math.floor(d.getTime() / 1000); // 1700000000

// Verschiedene Formate analysieren new Date("2023-11-14"); // Mitternacht UTC new Date("2023-11-14T22:13:20Z"); // 22:13:20 UTC new Date(1700000000 * 1000); // aus Millisekunden new Date("Nov 14, 2023 22:13:20");// Lokalabhängige Analyse (vermeiden!) ```

JavaScripts `Date`-Objekt ist berüchtigt eigenwillig. Für ernsthafte Arbeit verwenden Sie eine Bibliothek wie `date-fns`, `Luxon` oder `Day.js`. Für schnelle Umrechnungen ist das eingebaute `Date` in Ordnung.

Häufige Fragen

Warum ist die Unix-Epoche der 1. Januar 1970?

Es ist das Datum, an dem das Unix-Betriebssystem erstmals implementiert wurde. Ken Thompson und Dennis Ritchie wählten es willkürlich, als sie 1969-1970 Unix in den Bell Labs entwarfen. Es gibt keinen astronomischen oder mathematischen Grund; es war einfach der Beginn des Jahrzehnts, in dem sie arbeiteten. Mehrere andere Systeme haben unterschiedliche Epochen gewählt: Windows FILETIME verwendet den 1. Januar 1601; macOS HFS+ verwendete den 1. Januar 1904; GPS verwendet den 6. Januar 1980.

Was ist das 2038-Problem?

Das 2038-Problem (auch Y2K38 genannt) ist der 32-Bit-Ganzzahlüberlauf mit Vorzeichen, der am 19. Januar 2038 um 03:14:07 UTC auftritt. Eine vorzeichenbehaftete 32-Bit-Ganzzahl kann Werte bis 2.147.483.647 enthalten. Eine Sekunde später läuft sie zu −2.147.483.648 über, was als 1901-12-13 20:45:52 UTC interpretiert wird. Jedes System, das noch 32-Bit-Unix-Zeitstempel verwendet (hauptsächlich eingebettete Geräte, ältere Datenbanken und einige Dateisysteme), wird brechen, sofern es nicht aktualisiert wird.

Die Lösung ist einfach: Wechseln Sie zu 64-Bit-Ganzzahlen, die den Unix-Zeitstempelbereich um 290 Milliarden Jahre erweitern. Die meisten modernen Systeme haben dies bereits getan; das Problem betrifft hauptsächlich Legacy- und eingebettete Systeme.

Sind Unix-Zeitstempel in Sekunden oder Millisekunden?

Es hängt von der Sprache ab:

• Sekunden: C, Python, Go, Rust, Java (traditionell), Shell, SQL
• Millisekunden: JavaScript, Java (java.time.Instant), einige Datenbanken

JavaScript ist der große Ausreißer mit Millisekunden, was zu Fehlern führt, wenn JavaScript-Code mit Code aus anderen Sprachen gemischt wird. Klären Sie immer die Einheit. Der UtilBoxx-Umrechner behandelt beide mit einem einzigen Schalter.

Wie wirken sich Schaltsekunden auf Unix-Zeitstempel aus?

Streng genommen ignorieren Unix-Zeitstempel Schaltsekunden. Sie zählen jede Sekunde, als gäbe es genau 86.400 pro Tag. Das reale UTC hat gelegentliche Schaltsekunden (hinzugefügt, um die Atomzeit mit der Erdrotation in Einklang zu halten), aber die Unix-Zeit enthält sie nicht. Das bedeutet, dass die Unix-Zeit alle paar Jahre um einen Bruchteil einer Sekunde von UTC abdriftet.

In der Praxis spielt dies für Anwendungscode selten eine Rolle. NTP (Network Time Protocol) behandelt die Abweichung. Wenn Sie strikte TAI oder Atomzeit benötigen, sind Unix-Zeitstempel nicht das richtige Werkzeug.

Was ist „ISO 8601"?

ISO 8601 ist ein internationaler Standard für Datums- und Zeitformate, der darauf ausgelegt ist, eindeutig und maschinenlesbar zu sein. Beispiele:

• `2023-11-14` (nur Datum)
• `2023-11-14T22:13:20` (Datum und Uhrzeit, ohne Zeitzone)
• `2023-11-14T22:13:20Z` (UTC, „Z" = „Zulu time")
• `2023-11-14T22:13:20+05:00` (mit Zeitzonen-Offset)
• `2023-11-14T22:13:20.123Z` (mit Millisekunden)
• `20231114T221320Z` (kompakte Form, ohne Trennzeichen)

ISO 8601 ist das empfohlene Format zum Speichern und Austauschen von Datums-/Zeitwerten, da es lexikografisch sortiert und eindeutig analysiert wird. Die meisten APIs verwenden es.

Wie erhalte ich den aktuellen Unix-Zeitstempel?

In allen wichtigen Sprachen:

```bash # bash date +%s ```

```python import time time.time() # 1700000000.123 (float, mit Sekundenbruchteilen) int(time.time()) # 1700000000 (Ganzzahlsekunden) ```

```js Date.now() / 1000 // 1700000000.123 Math.floor(Date.now() / 1000) // 1700000000 ```

Fazit

Unix-Zeitstempel sind die universelle Sprache der Zeit in der Informatik. Sie sind einfache Ganzzahlen, leicht zu vergleichen, leicht zu speichern und zeitzonenunabhängig. Die Epoche ist der 1. Januar 1970, und Zeitstempel zählen Sekunden ab diesem Zeitpunkt.

Für gelegentliche Umrechnungen ist der Zeitumrechner von UtilBoxx privat, kostenlos und funktioniert offline, sobald er geladen ist. Für Stapel- oder Skriptarbeit bewältigen Pythons `datetime` oder der bash-`date`-Befehl jedes Datenvolumen, ohne das Terminal zu verlassen. Für interaktive Arbeit ist JavaScripts `Date` in jeden Browser integriert.

Die mentale Abkürzung: 1.000.000.000 = 2001 (Unix-Milliardenste), 1.500.000.000 = 2017, und 2.000.000.000 = 2033. Mit diesen Ankern können Sie das Jahr jedes 10-stelligen Zeitstempels im Kopf schätzen. Und denken Sie daran: In 12 Jahren kommt das 2038-Problem, also prüfen Sie jetzt Ihre 32-Bit-Zeitstempel.