Epoch & Unix Time Converter – Zeitstempel umrechnen

Inhaltsverzeichnis

             Schnellübersicht
            Live-Uhr: Aktueller Unix-Timestamp in Echtzeit
Epoch → Datum: Timestamp in alle Formate umwandeln
Datum → Epoch: Datum in Timestamp umwandeln
Formate: Sekunden, Millisekunden, Nanosekunden, ISO 8601, RFC 2822
Presets: Jetzt, Epoch, Y2K38, 1.1.2000
Theorie: Was ist Unix-Zeit? (Anfängerfreundlich)
Geschichte: Von Unix zu Y2K38
FAQ: Häufige Fragen zu Unix-Timestamps

        

1. Epoch & Unix Time Converter

Wähle einen Modus und gib deine Daten ein – die Umrechnung erfolgt sofort.

Unix-Zeitstempel Sekunden, Millisekunden oder Nanosekunden (automatische Erkennung)

Zeitzone

Umrechnungsergebnisse

Datum & Uhrzeit (lokal) Lokale Zeitzone deines Browsers

Einheit

Umrechnungsergebnisse

Wussten Sie schon?

Der Unix-Epoch beginnt am 1. Januar 1970 um 00:00:00 UTC.
Der 1. Januar 2000 ist Epoch 946684800 – die Y2K-Grenze!
Am 19. Januar 2038 um 03:14:07 UTC erreicht der 32-Bit-Timestamp seinen Maximalwert.
JavaScript verwendet standardmäßig Millisekunden (13 Stellen).
Linux-Kernel verwendet intern Nanosekunden (19 Stellen).

2. Theorie – Unix-Zeit einfach erklärt

Verstehe die Grundlagen der Unix-Zeit – ohne Vorkenntnisse.

Was ist die Unix-Zeit?

Die Unix-Zeit (oder Epoch-Zeit) zählt einfach Sekunden seit einem festen Startpunkt:

Startpunkt: 1. Januar 1970, 00:00:00 UTC
Zählweise: Jede Sekunde = +1
Format: Ganzzahl (int)
Zeitzone: Immer UTC

1700000000 = 14.11.2023 22:13:20 UTC

Warum Unix-Zeit?

Computer arbeiten lieber mit Zahlen als mit komplizierten Datumsformaten:

Eindeutig: Keine Zeitzonen-Verwirrung
Kompakt: Nur 4 oder 8 Bytes
Berechenbar: Einfache Arithmetik
Universell: Funktioniert überall

"Wie viel Zeit vergangen?" → Einfach subtrahieren!

Wo wird Unix-Zeit eingesetzt?

Unix-Timestamps begegnen dir überall:

Dateisysteme: Erstellt, geändert, zuletzt zugegriffen
Datenbanken: created_at, updated_at
Logs: Zeitstempel für jeden Eintrag
APIs: Zeitangaben in JSON
HTTP: Cache-Control, Expires
Blockchain: Bitcoin-Zeitstempel

ls -l zeigt Unix-Zeit für Dateien

Tipps für Anfänger

Sekunden: 10 Stellen (aktuell)
Millisekunden: 13 Stellen (JavaScript)
Mikrosekunden: 16 Stellen
Nanosekunden: 19 Stellen (Linux-Kernel)
Berechnung: Datum - Epoch = Timestamp

10 Stellen = Sekunden, 13 = ms

Wussten Sie schon? Die Unix-Zeit wurde 1970 von Ken Thompson und Dennis Ritchie bei Bell Labs eingeführt. Sie wählten den 1. Januar 1970 als Startpunkt – aus reiner Praktikabilität, nicht aus mathematischer Notwendigkeit. Der erste Computerfehler durch Unix-Zeit könnte 2038 passieren (Y2K38-Problem). Zum Vergleich: Der älteste bekannte Unix-Timestamp in Produktion war negativ – aus den 1960er Jahren. Und der größte Timestamp in JavaScript ist 9.007.199.254.740.991 (2⁵³ - 1) – danach verlieren JavaScript-Zahlen ihre Präzision!

3. Das Y2K38-Problem

Am 19. Januar 2038 läuft die Unix-Zeit für 32-Bit-Systeme ab:

Feld	Wert	Beschreibung
Maximalwert (32-Bit signed)	2147483647	2³¹ - 1
Datum	19. Januar 2038	03:14:07 UTC
Minuten nach Epoch	35791394	ca. 68 Jahre
Nächster Wert	-2147483648	13. Dezember 1901
Lösung	64-Bit Integer	Reicht bis Jahr 292 Milliarden

Was passiert am 19. Januar 2038?

32-Bit-Systeme: Überlauf zu negativen Werten → Datum springt auf 13.12.1901
Linux-Kernel: Neuere Versionen nutzen bereits 64-Bit (time_t)
Embedded-Systeme: Ältere Geräte sind besonders gefährdet
Datenbanken: MySQL DATETIME ist bis 2038 begrenzt
Lösung: Migration auf 64-Bit-Zeitstempel

4. Geschichte der Unix-Zeit

Von Unix 1.0 über Y2K bis Y2K38.

1969

Unix entsteht

Ken Thompson und Dennis Ritchie entwickeln bei Bell Labs das erste Unix. Die Systemzeit wird als einfache Ganzzahl gespeichert – der Unix-Epoch ist geboren.

1970

Der Epoch beginnt

Der 1. Januar 1970, 00:00:00 UTC wird als Nullpunkt festgelegt. Alle Zeitstempel sind Sekunden seit diesem Datum – positiv für die Zukunft, negativ für die Vergangenheit.

1988

POSIX-Standard

Die Unix-Zeit wird im POSIX-Standard offiziell definiert. Sie wird zum universellen Standard für alle Unix-ähnlichen Systeme.

1995

JavaScript

JavaScript wird eingeführt und verwendet Millisekunden seit Epoch. Date.now() gibt 13-stellige Werte zurück – eine neue Ära beginnt.

1999

Y2K-Krise

Die Jahr-2000-Krise (Y2K) beschäftigt die IT-Welt. Milliarden werden investiert, um Datumsumstellungen zu bewältigen. Eine gute Vorbereitung auf Y2K38.

2004

Y2K38-Problem

Das Jahr-2038-Problem wird bekannt: 32-Bit-Systeme können Zeitstempel nach dem 19. Januar 2038, 03:14:07 UTC nicht mehr korrekt darstellen.

Heute

Globaler Standard

Unix-Zeitstempel sind aus der IT nicht wegzudenken: APIs, Datenbanken, Logs, Kubernetes, Cloud-Services. Über 64-Bit-Systeme sind bis ins Jahr 292 Milliarden sicher.

5. FAQ – Spannende Fragen & Antworten

Häufige Fragen zur Unix-Zeit

Was ist der Unterschied zwischen Unix Time und Epoch?

Die Begriffe werden oft synonym verwendet, aber es gibt einen feinen Unterschied:

Epoch: Der Zeitpunkt selbst (1. Januar 1970, 00:00:00 UTC)
Unix Time: Die Anzahl Sekunden seit diesem Epoch

Analogie:

Epoch = der Startpunkt eines Rennens
Unix Time = die gestoppte Zeit seit dem Start

Beispiel:

Epoch:     01.01.1970 00:00:00 UTC
Unix Time: 0 (am Epoch)
Unix Time: 1700000000 (14.11.2023)

Weitere Epochs: Windows verwendet 1601, Mac OS Classic 1904, NTP 1900. Die Unix-Zeit ist der Standard für Unix/Linux/macOS.

Wie erkenne ich, ob ein Timestamp in Sekunden oder Millisekunden ist?

Die Stellenanzahl verrät die Einheit:

Stellen	Einheit	Beispiel	Verwendung
10	Sekunden	1700000000	Unix, Linux, C
13	Millisekunden	1700000000000	JavaScript, Java, MongoDB
16	Mikrosekunden	1700000000000000	Hochpräzise Messungen
19	Nanosekunden	1700000000000000000	Linux-Kernel, Go

Faustregeln:

< 10 Mrd.: Wahrscheinlich Sekunden
> 10 Billionen: Wahrscheinlich Millisekunden
In JavaScript: Immer Millisekunden (13 Stellen)
In Python: Oft Sekunden (time.time())

Trick zum Merken:

10 Stellen → ca. 2001-2286 (Sekunden)
13 Stellen → ca. 2001-2286 (Millisekunden in Tausendstel)
Die Zahl ist immer ca. 1000× größer pro Einheit

Warum startet die Unix-Zeit ausgerechnet 1970?

Die Wahl des 1. Januar 1970 war eine pragmatische Entscheidung von Ken Thompson und Dennis Ritchie:

Die Gründe:

Runder Anfang: Beginn eines neuen Jahrzehnts
Praktisch: Keine Daten vor 1970 mussten gespeichert werden (Computer-Ära begann gerade)
Einfachheit: Kein Bedarf für negative Werte
Verfügbar: Einfache Umrechnung in Sekunden

Interessant: Andere Systeme wählten andere Epochs:

System	Epoch
Unix/Linux	01.01.1970
Windows	01.01.1601
Mac OS Classic	01.01.1904
NTP	01.01.1900
GPS	06.01.1980

Fazit: Der 01.01.1970 ist kein wissenschaftlich bedeutender Zeitpunkt – es war einfach eine praktische Wahl!

Was ist das Y2K38-Problem genau?

Das Jahr-2038-Problem (Y2K38) betrifft Systeme mit 32-Bit signed Integer für Zeitstempel:

Das Problem:

Maximalwert: 2.147.483.647 Sekunden
Datum: 19. Januar 2038, 03:14:07 UTC
Nächster Wert: -2.147.483.648 → 13. Dezember 1901!
Folge: Systeme springen 137 Jahre in die Vergangenheit

Betroffene Systeme:

Ältere Linux-Systeme: 32-Bit-Kernel
Embedded-Systeme: Router, IoT-Geräte
MySQL DATETIME: Bis 2038 begrenzt
Ältere C-Programme: time_t als 32-Bit

Lösung:

64-Bit time_t: Reicht bis ins Jahr 292 Milliarden
Migration: Software-Updates vor 2038
MySQL TIMESTAMP: Nutzt Unix-Zeit, aber DATETIME hat Grenze
Kubernetes: Nutzt bereits 64-Bit

Vergleich zu Y2K: Beim Y2K-Problem 1999/2000 hatten viele Systeme 2-stellige Jahreszahlen. Y2K38 ist ähnlich, aber besser vorhersehbar. Seit 2004 gibt es Vorbereitungen.

Wie lese ich Unix-Timestamps in verschiedenen Sprachen?

Jede Programmiersprache hat ihre eigenen Funktionen:

Python:

import time
from datetime import datetime

# Aktueller Timestamp
time.time()  # 1700000000.123

# Zu Datum
datetime.fromtimestamp(1700000000)

# Umgekehrt
int(datetime.now().timestamp())

JavaScript:

// Aktueller Timestamp (in Millisekunden!)
Date.now()  // 1700000000000

// Zu Datum
new Date(1700000000000)

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

Bash/Linux:

# Aktueller Timestamp
date +%s

# Zu Datum
date -d @1700000000

# Umgekehrt
date -d "2023-11-14 22:13:20" +%s

SQL (MySQL):

SELECT UNIX_TIMESTAMP();
SELECT FROM_UNIXTIME(1700000000);

PHP:

time();  // 1700000000
date('Y-m-d H:i:s', 1700000000);

Go:

time.Now().Unix()  // Sekunden
time.Now().UnixNano()  // Nanosekunden

Warum sind negative Timestamps möglich?

Negative Timestamps repräsentieren Daten vor dem 1. Januar 1970. Sie sind technisch möglich und werden in manchen Anwendungen genutzt:

Beispiele:

Timestamp	Datum
-1	31.12.1969, 23:59:59 UTC
-86400	31.12.1969 (1 Tag vorher)
-31536000	01.01.1969 (1 Jahr vorher)
-2208988800	01.01.1900
-62135596800	01.01.0001

Anwendungen für negative Timestamps:

Historische Daten: Geburtsdaten, historische Ereignisse
Astronomie: Beobachtungen vor 1970
Wissenschaft: Geologische Zeiträume
Tests: Edge-Cases in der Software-Entwicklung

Achtung:

Manche Systeme unterstützen keine negativen Timestamps korrekt
32-Bit-Systeme können auch negative Werte als Überlauf interpretieren
Datenbanken haben oft einen Mindestwert (z.B. MySQL 1970-01-01 00:00:01 UTC)

Interessant: Der älteste bekannte Unix-Timestamp in einer echten Datenbank war ein Geburtsdatum aus 1930 – als negativer Wert!

Was ist der "Unix Millennium Bug"?

Der Unix Millennium Bug ist ein anderer Name für das Y2K38-Problem. Es wird manchmal auch als "Millennium Bug 2.0" bezeichnet:

Warum "Millennium Bug"?

Y2K (2000): 2-stellige Jahreszahlen werden zu "00"
Y2K38 (2038): 32-Bit-Unix-Timestamp läuft über
Gemeinsamkeit: Beide entstehen durch begrenzte Speichergröße

Unterschiede zu Y2K:

Aspekt	Y2K (2000)	Y2K38 (2038)
Ursache	2-stellige Jahre	32-Bit Integer
Datum	01.01.2000	19.01.2038
Betroffene	COBOL, Mainframes	Unix, C, Embedded
Folgen	Datum falsch	Datum springt zurück
Lösung	4-stellige Jahre	64-Bit Integer

Warum ist Y2K38 weniger bekannt?

Es gibt noch 14+ Jahre Zeit (Stand 2024)
Moderne Systeme nutzen bereits 64-Bit
Betroffene Systeme sind meist alt oder embedded
Die Migration ist einfacher als bei Y2K

Vorbereitung: Wer heute noch 32-Bit-Systeme einsetzt, sollte bald migrieren. Der 19. Januar 2038 kommt näher als man denkt!

Zusammenfassung

Die wichtigsten Punkte

Unix-Zeit: Sekunden seit 01.01.1970 00:00:00 UTC
Epoch: Der Startpunkt selbst (1970)
Einheiten: Sekunden (10), Millisekunden (13), Nanosekunden (19)
ISO 8601: YYYY-MM-DDTHH:MM:SSZ – Standard für APIs
RFC 2822: E-Mail-Header-Format
Y2K38: 32-Bit-Überlauf am 19.01.2038
JavaScript: Nutzt Millisekunden (Date.now())
Best Practice: Immer in UTC speichern, lokal anzeigen
Unser Tool: Live-Umrechnung in alle Formate

Weitere Tools

Timestamp Converter

Unix-Zeitstempel in lesbare Daten umwandeln und umgekehrt.

Zum Tool

Binary to Text

Konvertiere Binärcode in Text und Text in Binärcode.

Zum Tool

ASCII-Tabelle

Vollständige ASCII-Tabelle mit Dezimal, Hex, Oktal und Binär.

Zum Tool

Zahlensystem-Konverter

Konvertiere Zahlen zwischen Binär, Oktal, Dezimal und Hex.

Zum Tool