Unix Timestamp Converter

KONVERTER-TOOL

Unix Timestamp Converter

Konvertiere Unix-Zeitstempel in lesbare Daten und zurück. Mit Live-Uhr, ISO 8601, RFC 2822, relativer Zeit und Batch-Konvertierung.

Bidirektional Live-Uhr ISO 8601 Relativ Batch

Hinweis: Die Unix-Zeit (Epoch) zählt Sekunden seit 1. Januar 1970, 00:00:00 UTC. Alle Berechnungen erfolgen lokal in deinem Browser mit der Zeitzone deines Systems.

Inhaltsverzeichnis

Schnellübersicht

  • Live-Uhr: Aktueller Unix-Timestamp in Echtzeit
  • Timestamp → Datum: Unix-Zeit in lesbares Datum konvertieren
  • Datum → Timestamp: Datum in Unix-Zeit umwandeln
  • Batch: Mehrere Timestamps auf einmal konvertieren
  • Formate: ISO 8601, RFC 2822, Lokale Zeit, UTC, Hex
  • Relativ: "vor 5 Minuten", "in 3 Tagen"
  • Theorie: Über Unix-Zeit und Epoch
  • FAQ: Häufige Fragen zu Unix-Zeit

1. Unix Timestamp Converter

Aktueller Unix-Timestamp
0
–
Sekunden seit 1.1.1970 (auch Millisekunden akzeptiert)
Aktueller Status
Alle Formate

2. Theorie – Unix-Zeit und Epoch

Verstehe die Grundlagen der Unix-Zeit und ihrer Darstellung.

Was ist Unix-Zeit?

Die Unix-Zeit (auch POSIX-Zeit oder Epoch) ist eine Zeitdarstellung:

  • Sekunden seit 1.1.1970 00:00:00 UTC
  • Kein Schaltsekunden-Zähler
  • Vorzeichenbehaftet (negative Werte möglich)
  • 32 oder 64 Bit Speichergröße
  • Zeitzonenunabhängig (immer UTC)
0 = 1. Januar 1970, 00:00:00 UTC

Warum Unix-Zeit?

Unix-Zeit hat viele Vorteile:

  • Einfach: Eine Zahl statt komplexes Format
  • Zeitzonenunabhängig: UTC als Basis
  • Berechenbar: Subtraktion ergibt Zeitdifferenz
  • Sortierbar: Als Zahl direkt sortierbar
  • Kompakt: Nur 4-8 Bytes
Differenz: ts2 - ts1 = Sekunden

Y2K38-Problem

Klassische 32-Bit-Timestamps laufen am 19. Januar 2038 über:

  • Maximum: 2.147.483.647 (19.1.2038, 03:14:07 UTC)
  • Danach: Überlauf zu negativen Zahlen (1901)
  • Betroffen: Alte 32-Bit-Systeme
  • Lösung: 64-Bit-Timestamps (Y2K38-safe)
  • 64 Bit: Reicht für ~292 Milliarden Jahre
Y2K38: 19. Januar 2038

Best Practices

  • UTC speichern: Immer als Unix-Timestamp
  • Lokal anzeigen: Nur für User konvertieren
  • 64 Bit nutzen: Für neue Systeme
  • ISO 8601: Für menschenlesbare APIs
  • Timezone: IANA-IDs (Europe/Berlin)
  • Millisekunden: JavaScript nutzt ms (×1000)
Immer UTC speichern, lokal anzeigen!

Wussten Sie schon?

Die Unix-Zeit wurde 1971 von Ken Thompson und Dennis Ritchie für das Unix-Betriebssystem eingeführt. Ursprünglich als 60-Hz-Ticker (jeder Tick = 1/60 Sekunde) gedacht, entschied man sich später für Sekunden. Der Wert 0 wurde willkürlich auf den 1. Januar 1970 gesetzt – das Jahr, in dem Unix entwickelt wurde. Heute nutzen fast alle Betriebssysteme und Programmiersprachen Unix-Timestamps.

3. Geschichte der Unix-Zeit

Von der Erfindung bis zum Y2K38-Problem.

1969

Unix entsteht

Ken Thompson und Dennis Ritchie entwickeln Unix bei Bell Labs. Erste Zeitfunktionen werden benötigt – aber noch ohne Standard.

1971

Unix-Zeit eingeführt

Erste Version der Unix-Zeit. Ursprünglich als 60-Hz-Ticker (jeder Tick = 1/60 s), um die CPU-Uhr zu nutzen. Später auf Sekunden umgestellt.

1970

Epoch festgelegt

Der 1. Januar 1970, 00:00:00 UTC wird als Epoch definiert. Der Wert 0 entspricht diesem Zeitpunkt. Willkürliche Wahl, aber bis heute Standard.

1988

POSIX-Standard

Die POSIX-Norm (IEEE 1003.1) standardisiert die Unix-Zeit. time_t wird als Sekunden seit Epoch definiert. Meist als 32-Bit-Wert.

2001

1 Milliarde erreicht

Am 9. September 2001 um 01:46:40 UTC erreicht die Unix-Zeit 1.000.000.000. Wird weltweit gefeiert – auch wenn kurz nach 9/11.

2009

1.234.567.890

Am 13. Februar 2009 um 23:31:30 UTC erreicht die Unix-Zeit 1.234.567.890. Google und andere feiern mit Google Doodles.

2038

Y2K38-Problem

Am 19. Januar 2038, 03:14:07 UTC läuft die 32-Bit-Unix-Zeit über. Systeme mit 32-Bit-time_t zeigen dann 1901. Umstellung auf 64-Bit läuft seit Jahren.

Heute

64-Bit Standard

Moderne Systeme nutzen 64-Bit-Timestamps. JavaScript verwendet Millisekunden (Timestamp × 1000). Die Unix-Zeit bleibt der universelle Zeitstandard.

4. FAQ – Häufige Fragen

Häufige Fragen zur Unix-Zeit

Was ist die Unix-Zeit genau?

Die Unix-Zeit (auch Epoch-Zeit oder POSIX-Zeit) ist die Anzahl der Sekunden seit 1. Januar 1970, 00:00:00 UTC:

  • 0 = 1.1.1970, 00:00:00 UTC
  • 1000000000 = 9.9.2001, 01:46:40 UTC
  • 1700000000 = 14.11.2023, 22:13:20 UTC

Eigenschaften:

  • Zeitzonenunabhängig (immer UTC)
  • Kein Schaltsekunden-Zähler
  • Vorzeichenbehaftet (negative Werte vor 1970)
  • Kompakt (4 oder 8 Bytes)
Warum beginnt die Unix-Zeit 1970?

Die Wahl von 1. Januar 1970 war willkürlich, aber praktisch:

  • Unix-Entwicklung: 1969-1970 bei Bell Labs
  • Einfache Zahl: Passt in 32 Bit
  • Kein Sonderfall: Neuer Startpunkt
  • Ausreichend: 68 Jahre bis 2038

Alternative Vorschläge:

  • 1.1.1900 (zu weit zurück)
  • 1.1.2000 (zu weit voraus)
  • 1.1.1970 als Kompromiss

Interessant: Manche Systeme nutzen andere Epochen (z.B. Windows: 1601, macOS: 1904, NTP: 1900).

Was ist das Y2K38-Problem?

Y2K38 ist das Überlauf-Problem der 32-Bit-Unix-Zeit:

  • Maximum 32-Bit signed: 2.147.483.647
  • Zeitpunkt: 19. Januar 2038, 03:14:07 UTC
  • Danach: Überlauf zu negativen Zahlen (-2.147.483.648)
  • Ergebnis: Datum springt auf 13. Dezember 1901

Betroffene Systeme:

  • Alte 32-Bit-Linux-Systeme
  • Embedded-Geräte ohne Update
  • Legacy-Datenbanken
  • Alte Programmiersprachen

Lösung: 64-Bit-time_t:

  • Maximum: 9,2 Trillionen Sekunden
  • Reicht für: ~292 Milliarden Jahre
  • Standard: In modernen Systemen seit Jahren
Warum nutzt JavaScript Millisekunden?

JavaScript verwendet Millisekunden statt Sekunden:

  • Datum.now(): Millisekunden seit Epoch
  • Beispiel: 1700000000000 = 1700000000 s
  • Umrechnung: ms / 1000 = Sekunden
  • Umrechnung: s × 1000 = Millisekunden

Warum Millisekunden?

  • Genauer: 1000× feinere Auflösung
  • Web-Performance: Millisekunden sind relevant
  • Standard: Seit 1995 in JavaScript

Achtung bei APIs:

  • Unix/Linux: Sekunden (10 Stellen)
  • JavaScript: Millisekunden (13 Stellen)
  • Windows: 100-Nanosekunden seit 1601
Wie konvertiere ich Timestamps in anderen Sprachen?
SpracheBefehl
Pythonimport time; time.time()
JavaScriptDate.now() / 1000
PHPtime()
JavaSystem.currentTimeMillis() / 1000
Gotime.Now().Unix()
RustSystemTime::now().duration_since(UNIX_EPOCH).as_secs()
Bashdate +%s
SQLUNIX_TIMESTAMP()

Rückkonvertierung in Python:

  • import datetime
  • datetime.datetime.fromtimestamp(1700000000)
  • datetime.datetime.utcfromtimestamp(1700000000)
Was ist ISO 8601?

ISO 8601 ist ein internationaler Standard für Datums- und Zeitangaben:

Format:

  • YYYY-MM-DDTHH:MM:SSZ
  • Beispiel: 2023-11-14T22:13:20Z
  • Das "Z" steht für UTC (Zulu Time)

Mit Zeitzone:

  • 2023-11-14T22:13:20+01:00 (Berlin)
  • 2023-11-14T22:13:20-05:00 (New York)

Vorteile:

  • Eindeutig: Kein MM/DD vs DD/MM Problem
  • Sortierbar: Lexikografisch = chronologisch
  • Standard: Weltweit anerkannt
  • API-freundlich: Standard in JSON/REST
Was sind Schaltsekunden?

Schaltsekunden gleichen die Differenz zwischen Atomzeit und Erdrotation aus:

  • Erdrotation: Wird langsamer (Gezeiten, Erdbeben)
  • Atomzeit: Sehr präzise (Cäsium-Uhr)
  • Schaltsekunde: Wird eingefügt um zu synchronisieren
  • Seit 1972: 27 Schaltsekunden eingefügt

Problem für Unix-Zeit:

  • Unix-Zeit ignoriert Schaltsekunden
  • Jeder Tag hat exakt 86400 Sekunden
  • Dadurch kleine Abweichung zu UTC

Zukunft: Schaltsekunden sollen 2035 abgeschafft werden (CGPM-Beschluss 2022).

Wie speichere ich Timestamps richtig?

Best Practices:

  • UTC speichern: Immer als Unix-Timestamp oder UTC-ISO
  • Lokal anzeigen: Nur für User konvertieren
  • 64 Bit nutzen: Für neue Systeme (Y2K38-safe)
  • Zeitzone mitgeben: Bei ISO 8601 mit Offset
  • Datenbank: TIMESTAMP WITH TIME ZONE (PostgreSQL)

Häufige Fehler:

  • Lokale Zeit speichern (Zeitzonen-Chaos)
  • 32-Bit-Timestamps in neuen Systemen
  • Millisekunden vs Sekunden verwechseln
  • Zeitzonen-Offset nicht beachten

Beispiel (PostgreSQL):

  • SELECT EXTRACT(EPOCH FROM NOW());
  • SELECT TO_TIMESTAMP(1700000000);

Zusammenfassung

Die wichtigsten Punkte

  • Unix-Zeit: Sekunden seit 1.1.1970 00:00:00 UTC
  • Epoch: 0 = 1. Januar 1970
  • Zeitzonenunabhängig: Immer UTC-basiert
  • 32 Bit: Überlauf am 19.1.2038 (Y2K38)
  • 64 Bit: Standard in modernen Systemen
  • JavaScript: Millisekunden (×1000)
  • ISO 8601: Standard für menschenlesbare Daten
  • Keine Schaltsekunden: Unix-Zeit ignoriert sie
  • Best Practice: UTC speichern, lokal anzeigen
  • Unser Tool: Live-Uhr, Konverter und Batch-Verarbeitung

Weitere Tools

Epoch Unix Time Converter

Alternative Darstellung für Epoch-Zeit-Konvertierung.

Zum Tool
Timestamp Converter

Zusätzliche Zeitstempel-Konvertierung für verschiedene Formate.

Zum Tool
Cron Expression Generator

Cron-Ausdrücke für geplante Aufgaben erstellen.

Zum Tool
Zahlensystem-Konverter

Umrechnung zwischen Binär, Oktal, Dezimal und Hexadezimal.

Zum Tool