Was genau ist Epoch Time?
Wenn du schon mal mit Datums- und Zeitangaben in der Programmierung gearbeitet hast, bist du wahrscheinlich auf Unix-Timestamps gestoßen. Aber was sind sie wirklich, und warum verwenden wir sie?
Unix Epoch Time (auch Unix Time, POSIX Time oder einfach "Epoch" genannt) stellt einen einzelnen Moment in der Zeit als die Anzahl der Sekunden dar, die seit dem 1. Januar 1970 um Mitternacht UTC (Universal Coordinated Time) vergangen sind. Dieser spezifische Moment ist als "Unix Epoch" oder "Epoch Zero" bekannt.
Warum der 1. Januar 1970?
Dieses Datum mag willkürlich erscheinen, aber es wurde gewählt, als Unix Anfang der 1970er Jahre in den Bell Labs entwickelt wurde. Die Entwickler brauchten einen konsistenten Ausgangspunkt für ihr Zeiterfassungssystem, und der 1. Januar 1970 lag nahe an dem Zeitpunkt, als sie an dem Projekt arbeiteten. Seitdem ist es zum universellen Standard geworden.
Das Format verstehen
Unix-Timestamps gibt es in verschiedenen Formaten, je nachdem, welche Präzision benötigt wird:
- Sekunden (10 Ziffern): Das Standardformat, wie
1728773400 - Millisekunden (13 Ziffern): Für mehr Präzision, wie
1728773400000 - Mikrosekunden (16 Ziffern): Für ultrapräzises Timing, wie
1728773400000000
Häufige Zeitintervalle in Sekunden
Das Verständnis dieser gängigen Intervalle kann dir helfen, intuitiver mit Timestamps zu arbeiten:
| Zeitraum | Sekunden | Schnelle Berechnung |
|---|---|---|
| 1 Stunde | 3.600 | 60 × 60 |
| 1 Tag | 86.400 | 24 × 3.600 |
| 1 Woche | 604.800 | 7 × 86.400 |
| 1 Monat (Durchschn.) | 2.629.743 | 30,44 × 86.400 |
| 1 Jahr (Durchschn.) | 31.556.926 | 365,24 × 86.400 |
Das Jahr-2038-Problem (Y2038)
Hier ist etwas Wichtiges: Viele Systeme speichern Unix-Timestamps als 32-Bit-Signed-Integer. Dies führt zu einem Problem, das dem Y2K-Bug ähnelt.
Ein 32-Bit-Signed-Integer kann nur bis 2.147.483.647 Sekunden zählen. Sobald wir den 19. Januar 2038 um 03:14:07 UTC erreichen, wird dieser Zähler überlaufen und sich in eine negative Zahl umwandeln, was potenziell zu Systemausfällen und Bugs führen kann.
Aktuelle Epoch Time abrufen
Jede Programmiersprache hat ihre eigene Methode, um den aktuellen Unix-Timestamp abzurufen. Hier sind die gängigsten Methoden:
Web-Entwicklung
JavaScript
// Timestamp in Millisekunden abrufen, durch 1000 teilen für Sekunden
const timestamp = Math.floor(Date.now() / 1000);
// Alternative Methode
const timestamp = Math.floor(new Date().getTime() / 1000);PHP
// Einfach und unkompliziert
$timestamp = time();
// Mit DateTime (flexibler)
$timestamp = (new DateTime())->getTimestamp();Backend-Sprachen
Python
import time
# Aktuellen Timestamp abrufen
timestamp = int(time.time())
# Mit datetime-Modul
from datetime import datetime
timestamp = int(datetime.now().timestamp())Java
// Gibt Millisekunden zurück, durch 1000 teilen für Sekunden
long timestamp = System.currentTimeMillis() / 1000;
// Mit Instant (Java 8+)
long timestamp = Instant.now().getEpochSecond();C#
// .NET Framework 4.6+ / .NET Core
long timestamp = DateTimeOffset.Now.ToUnixTimeSeconds();
// Ältere Versionen
var epoch = (DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).TotalSeconds;Ruby
# Aktuellen Timestamp abrufen
timestamp = Time.now.to_i
# Alternative
timestamp = Time.new.to_iGo
import "time"
// Aktuellen Unix-Timestamp abrufen
timestamp := time.Now().Unix()
// Für Millisekunden
milliseconds := time.Now().UnixMilli()Datenbank-Abfragen
MySQL
-- Aktuellen Timestamp abrufen
SELECT UNIX_TIMESTAMP();
-- Timestamp von einem bestimmten Datum abrufen
SELECT UNIX_TIMESTAMP('2025-10-12 14:30:00');PostgreSQL
-- Aktuellen Timestamp abrufen
SELECT EXTRACT(EPOCH FROM NOW());
-- Von einem bestimmten Datum
SELECT EXTRACT(EPOCH FROM TIMESTAMP '2025-10-12 14:30:00');SQLite
-- Aktuellen Timestamp abrufen
SELECT STRFTIME('%s', 'now');
-- Von einem bestimmten Datum
SELECT STRFTIME('%s', '2025-10-12 14:30:00');Kommandozeile
Unix/Linux Shell
# Aktuellen Timestamp abrufen
date +%s
# Bestimmtes Datum in Timestamp umwandeln
date +%s -d "2025-10-12 14:30:00"
# Für UTC/GMT-Zeit, verwende -ud statt -d
date +%s -ud "2025-10-12 14:30:00"PowerShell
# Aktuellen Timestamp abrufen
[int][double]::Parse((Get-Date (Get-Date).ToUniversalTime() -UFormat %s))Von Epoch zu lesbarem Datum konvertieren
Sobald du einen Unix-Timestamp hast, musst du ihn oft zurück in ein lesbares Datumsformat konvertieren:
JavaScript
// Timestamp in Date-Objekt umwandeln
const date = new Date(timestamp * 1000); // Mit 1000 multiplizieren für Millisekunden
// Formatieren
console.log(date.toLocaleString()); // Lokales Format
console.log(date.toISOString()); // ISO 8601 FormatPHP
// Timestamp formatieren
$date = date('Y-m-d H:i:s', $timestamp);
// RFC 2822 Format
$date = date('r', $timestamp);
// Mit DateTime
$date = (new DateTime())->setTimestamp($timestamp)->format('Y-m-d H:i:s');Python
from datetime import datetime
# In datetime-Objekt umwandeln
dt = datetime.fromtimestamp(timestamp)
# Formatieren
formatted = dt.strftime('%Y-%m-%d %H:%M:%S')
# Für UTC
dt_utc = datetime.utcfromtimestamp(timestamp)MySQL
-- Timestamp in datetime umwandeln
SELECT FROM_UNIXTIME(1728773400);
-- Mit benutzerdefiniertem Format
SELECT FROM_UNIXTIME(1728773400, '%Y-%m-%d %H:%i:%s');Von lesbarem Datum zu Epoch konvertieren
Die umgekehrte Operation ist ebenso wichtig:
JavaScript
// Datumsstring in Timestamp umwandeln
const timestamp = Math.floor(new Date('2025-10-12 14:30:00').getTime() / 1000);
// Mit Date.parse()
const timestamp = Math.floor(Date.parse('October 12, 2025') / 1000);PHP
// Die meisten englischen Datumstexte parsen
$timestamp = strtotime('15 November 2025');
$timestamp = strtotime('next Monday');
$timestamp = strtotime('+1 week');
// Mit DateTime
$timestamp = (new DateTime('2025-10-12 14:30:00'))->getTimestamp();Python
from datetime import datetime
import time
# Datumsstring parsen
dt = datetime.strptime('2025-10-12 14:30:00', '%Y-%m-%d %H:%M:%S')
timestamp = int(dt.timestamp())
# Für UTC
import calendar
timestamp = calendar.timegm(time.strptime('2025-10-12 14:30:00', '%Y-%m-%d %H:%M:%S'))Best Practices
Wenn du mit Unix-Timestamps in deinen Anwendungen arbeitest:
- Verwende immer 64-Bit-Integer, um das Y2038-Problem zu vermeiden
- Speichere Timestamps in UTC in deiner Datenbank, konvertiere nur für die Anzeige in Ortszeit
- Sei konsistent mit deiner Präzision (Sekunden vs. Millisekunden) in deiner gesamten Anwendung
- Dokumentiere dein Format – mache klar, ob du Sekunden oder Millisekunden verwendest
- Erwäge zeitzonenbewusste Bibliotheken für komplexe Datums-/Zeitoperationen
- Speichere niemals Ortszeit als Timestamp ohne Zeitzoneninformationen
Fazit
Unix-Timestamps sind ein grundlegendes Konzept in der Programmierung, das jeder Entwickler verstehen sollte. Sie bieten eine einfache, universelle Möglichkeit, Zeit darzustellen, die auf allen Systemen und Programmiersprachen funktioniert.
Egal, ob du eine Webanwendung entwickelst, mit Datenbanken arbeitest oder einfach nur Aufgaben planen musst – das Verständnis von Epoch Time wird dir das Leben erheblich erleichtern. Verwende unser Unix Timestamp Converter-Tool, um schnell zwischen Timestamps und lesbaren Daten zu konvertieren!