Guide

Was ist ein Unix-Zeitstempel? Vollständiger Leitfaden zur Epochenzeit

Was ist ein Unix-Zeitstempel?

Ein Unix-Zeitstempel (auch bekannt als Unix-Zeit, POSIX-Zeit oder Epochenzeit) ist ein System zur Zeiterfassung als einzelne Zahl. Sie stellt die Anzahl der Sekunden dar, die seit 00:00:00 UTC am 1. Januar 1970 vergangen sind, ohne Schaltsekunden. Dieser Zeitpunkt wird als Unix-Epoche bezeichnet.

Beispielsweise repräsentiert der Unix-Zeitstempel 1704067200 January 1, 2024, 00:00:00 UTC.

Hauptmerkmale

Einfach: Nur eine Zahl zur Darstellung eines beliebigen Zeitpunkts
Universal: Funktioniert in allen Zeitzonen und Systemen gleich
Effizient: Einfach zu speichern, zu vergleichen und zu berechnen
Standardisiert: Weit verbreitet in allen Programmiersprachen und Datenbanken

Warum beginnt der Unix-Zeitstempel am 1. Januar 1970?

Der Unix-Zeitstempel beginnt am 1. Januar 1970, da zu diesem Zeitpunkt das Unix-Betriebssystem entwickelt wurde. Die Entwickler brauchten einen Bezugspunkt für ihr Zeitsystem und wählten ein aktuelles, rundes Datum, das man sich leicht merken konnte.

Dieses Datum wird als Unix-Epoche oder Epochenzeit bezeichnet. Alle Unix-Zeitstempel werden als Anzahl der Sekunden seit diesem Zeitpunkt berechnet.

Historischer Kontext

1969-1970: Entwicklung des Unix-Betriebssystems bei Bell Labs
Bedürfnis nach Einfachheit: Entwickler wollten eine einfache Möglichkeit, die Zeit zu erfassen
32-Bit-Systeme: Ursprünglich für die Arbeit mit 32-Bit-Ganzzahlen konzipiert
Weite Verbreitung: Wurde zum Standard für die Computerzeitmessung

So funktioniert der Unix-Zeitstempel

Grundkonzept

Der Unix-Zeitstempel ist einfach ein Zähler, der jede Sekunde um 1 erhöht wird:

Unix Epoch (Start):  0          → January 1, 1970, 00:00:00 UTC
After 1 second:      1          → January 1, 1970, 00:00:01 UTC
After 1 hour:        3600       → January 1, 1970, 01:00:00 UTC
After 1 day:         86400      → January 2, 1970, 00:00:00 UTC
After 1 year:        31536000   → January 1, 1971, 00:00:00 UTC
Today (2025):        ~1735689600 → Current time

Präzisionsstufen

Unix-Zeitstempel können unterschiedliche Genauigkeitsstufen haben:

Präzision	Ziffern	Beispiel	Beschreibung
Sekunden	10	`1704067200`	Standard-Unix-Zeitstempel
Millisekunden	13	`1704067200000`	Wird in JavaScript, Java
Mikrosekunden	16	`1704067200000000`	Hochpräzise Systeme
Nanosekunden	19	`1704067200000000000`	Ultrapräzises Timing

Unix-Zeitstempel in verschiedenen Programmiersprachen

JavaScript / Node.js

// Get current Unix timestamp (milliseconds)
const timestamp = Date.now();
console.log(timestamp); // 1704067200000

// Get Unix timestamp in seconds
const timestampSeconds = Math.floor(Date.now() / 1000);
console.log(timestampSeconds); // 1704067200

// Convert Unix timestamp to Date
const date = new Date(1704067200000);
console.log(date); // 2024-01-01T00:00:00.000Z

// Convert Date to Unix timestamp
const timestamp2 = new Date('2024-01-01').getTime();
console.log(timestamp2); // 1704067200000

Python

import time
from datetime import datetime

# Get current Unix timestamp
timestamp = time.time()
print(timestamp)  # 1704067200.123456

# Get Unix timestamp (integer)
timestamp_int = int(time.time())
print(timestamp_int)  # 1704067200

# Convert Unix timestamp to datetime
dt = datetime.fromtimestamp(1704067200)
print(dt)  # 2024-01-01 00:00:00

# Convert datetime to Unix timestamp
timestamp2 = datetime(2024, 1, 1).timestamp()
print(timestamp2)  # 1704067200.0

PHP

<?php
// Get current Unix timestamp
$timestamp = time();
echo $timestamp; // 1704067200

// Convert Unix timestamp to date
$date = date('Y-m-d H:i:s', 1704067200);
echo $date; // 2024-01-01 00:00:00

// Convert date to Unix timestamp
$timestamp2 = strtotime('2024-01-01');
echo $timestamp2; // 1704067200
?>

Java

import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneOffset;

// Get current Unix timestamp (seconds)
long timestamp = Instant.now().getEpochSecond();
System.out.println(timestamp); // 1704067200

// Get Unix timestamp (milliseconds)
long timestampMillis = System.currentTimeMillis();
System.out.println(timestampMillis); // 1704067200000

// Convert Unix timestamp to LocalDateTime
LocalDateTime dateTime = LocalDateTime.ofEpochSecond(
    1704067200, 0, ZoneOffset.UTC
);
System.out.println(dateTime); // 2024-01-01T00:00:00

// Convert LocalDateTime to Unix timestamp
long timestamp2 = dateTime.toEpochSecond(ZoneOffset.UTC);
System.out.println(timestamp2); // 1704067200

Gehen

package main

import (
    "fmt"
    "time"
)

func main() {
    // Get current Unix timestamp
    timestamp := time.Now().Unix()
    fmt.Println(timestamp) // 1704067200

    // Convert Unix timestamp to Time
    t := time.Unix(1704067200, 0)
    fmt.Println(t) // 2024-01-01 00:00:00 +0000 UTC

    // Convert Time to Unix timestamp
    timestamp2 := time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC).Unix()
    fmt.Println(timestamp2) // 1704067200
}

Vorteile des Unix-Zeitstempels

1. Einfachheit

Mit einer einzelnen Zahl lässt sich einfacher arbeiten als mit komplexen Datums-/Uhrzeitzeichenfolgen.

2. Zeitzonenunabhängigkeit

Unix-Zeitstempel werden immer in UTC angegeben, wodurch Zeitzonenverwechslungen vermieden werden.

3. Einfache Berechnungen

Berechnen Sie Zeitunterschiede durch einfache Subtraktion:

const start = 1704067200; // Jan 1, 2024
const end = 1704153600;   // Jan 2, 2024
const difference = end - start; // 86400 seconds = 1 day

4. Effiziente Lagerung

Das Speichern einer einzelnen Ganzzahl ist effizienter als das Speichern von Datumszeichenfolgen.

5. Sortieren und Vergleichen

Zeitstempel einfach sortieren und vergleichen:

const timestamps = [1704153600, 1704067200, 1704240000];
timestamps.sort((a, b) => a - b); // Chronological order

Einschränkungen des Unix-Zeitstempels

1. Jahr 2038 Problem

Auf 32-Bit-Systemen kommt es am 19. Januar 2038, 03:14:07 UTC zu einem Überlauf der Unix-Zeitstempel. Dies liegt daran, dass 32-Bit-Ganzzahlen mit Vorzeichen nur Werte bis zu 2.147.483.647 darstellen können.

Lösung: Verwenden Sie 64-Bit-Zeitstempel, die Daten darstellen können, die weit in der Zukunft liegen.

2. Schaltsekunden

Unix-Zeitstempel ignorieren Schaltsekunden, die gelegentlich zur UTC hinzugefügt werden, um die unregelmäßige Rotation der Erde zu berücksichtigen.

3. Präzisionsbeschränkungen

Standard-Unix-Zeitstempel (Sekunden) sind für einige Anwendungen möglicherweise nicht präzise genug. Verwenden Sie Millisekunden oder Mikrosekunden für eine höhere Präzision.

4. Menschliche Lesbarkeit

Unix-Zeitstempel sind nicht für Menschen lesbar. Sie müssen sie konvertieren, um aussagekräftige Daten anzuzeigen.

Häufige Anwendungsfälle

1. Datenbank-Zeitstempel

Speichern Sie die Erstellungs- und Änderungszeiten effizient:

CREATE TABLE users (
    id INT PRIMARY KEY,
    username VARCHAR(50),
    created_at BIGINT,
    updated_at BIGINT
);

2. API-Antworten

Fügen Sie Zeitstempel in API-Antworten ein:

{
  "id": 123,
  "message": "Hello World",
  "timestamp": 1704067200,
  "created_at": 1704067200
}

3. Protokolldateien

Verfolgen Sie, wann Ereignisse auftreten:

[1704067200] INFO: User logged in
[1704067205] WARNING: Failed login attempt
[1704067210] ERROR: Database connection failed

4. Caching und Ablauf

Legen Sie die Ablaufzeit des Caches fest:

const cacheExpiry = Date.now() / 1000 + 3600; // Expire in 1 hour

5. Sitzungsverwaltung

Verfolgen Sie die Zeitstempel der Benutzersitzungen:

const sessionStart = Math.floor(Date.now() / 1000);
const sessionExpiry = sessionStart + 1800; // 30 minutes

Best Practices

1. Verwenden Sie immer UTC

Speichern Sie Unix-Zeitstempel in UTC, um Zeitzonenprobleme zu vermeiden.

2. Wählen Sie die richtige Präzision

Verwenden Sie für die meisten Anwendungen Sekunden
Verwenden Sie Millisekunden für Webanwendungen (JavaScript)
Verwenden Sie Mikrosekunden oder Nanosekunden für hochpräzises Timing

3. Verwenden Sie 64-Bit-Ganzzahlen

Vermeiden Sie das Jahr-2038-Problem, indem Sie 64-Bit-Zeitstempel verwenden.

4. Zeitstempel validieren

Überprüfen Sie, ob die Zeitstempel innerhalb angemessener Bereiche liegen:

function isValidTimestamp(timestamp) {
    const min = 0; // Unix epoch
    const max = 2147483647; // Year 2038 for 32-bit
    return timestamp >= min && timestamp <= max;
}

5. Dokumentpräzision

Dokumentieren Sie immer, ob Ihre Zeitstempel in Sekunden, Millisekunden oder anderen Einheiten vorliegen.

Konvertieren von Unix-Zeitstempeln

Online-Tools

Verwenden Sie MakeTimestamp.com, um Unix-Zeitstempel in für Menschen lesbare Daten zu konvertieren und umgekehrt.

Befehlszeile

Linux/Mac:

# Current Unix timestamp
date +%s

# Convert Unix timestamp to date
date -d @1704067200

# Convert date to Unix timestamp
date -d "2024-01-01" +%s

Windows PowerShell:

powershell
# Current Unix timestamp
[int][double]::Parse((Get-Date -UFormat %s))

# Convert Unix timestamp to date
[DateTimeOffset]::FromUnixTimeSeconds(1704067200).DateTime

Häufig gestellte Fragen

Was stellt der Unix-Zeitstempel 0 dar?

Der Unix-Zeitstempel 0 stellt die Unix-Epoche dar: 1. Januar 1970, 00:00:00 UTC.

Können Unix-Zeitstempel negativ sein?

Ja! Negative Unix-Zeitstempel stellen Daten vor dem 1. Januar 1970 dar. -86400 steht beispielsweise für den 31. Dezember 1969.

Warum haben manche Zeitstempel 13 Ziffern?

13-stellige Zeitstempel werden in Millisekunden angegeben (häufig in JavaScript verwendet), während 10-stellige Zeitstempel in Sekunden angegeben werden.

Wie rechne ich zwischen Sekunden und Millisekunden um?

Sekunden bis Millisekunden: Mit 1000 multiplizieren
Millisekunden in Sekunden: Durch 1000 dividieren

Was passiert nach dem Jahr 2038?

Auf 64-Bit-Systemen können Unix-Zeitstempel Daten bis zum Jahr 292.277.026.596 darstellen. Auf 32-Bit-Systemen müssen Sie ein Upgrade durchführen oder alternative Zeitdarstellungen verwenden.

Werden Unix-Zeitstempel von Zeitzonen beeinflusst?

NEIN! Unix-Zeitstempel werden immer in UTC angegeben. Zeitzonen werden nur angewendet, wenn der Zeitstempel als für Menschen lesbares Datum angezeigt wird.

Zusammenfassung

Der Unix-Zeitstempel ist eine einfache, effiziente und universelle Möglichkeit, Zeit als einzelne Zahl darzustellen. Es zählt die Sekunden seit dem 1. Januar 1970 (der Unix-Epoche) und wird häufig in der Programmierung, Datenbanken und APIs verwendet.

Wichtige Erkenntnisse:

Unix-Zeitstempel = Sekunden seit dem 1. Januar 1970, 00:00:00 UTC
Einfach, universell und effizient für die Zeiterfassung
Verfügbar in mehreren Präzisionsstufen (Sekunden, Millisekunden usw.)
Achten Sie auf das Jahr-2038-Problem auf 32-Bit-Systemen
Speichern Sie Zeitstempel immer in UTC

Sind Sie bereit, mit Unix-Zeitstempeln zu arbeiten? Probieren Sie unseren [Unix-Zeitstempelkonverter] (https://maketimestamp.com/unix-timestamp-converter) aus, um sofort zwischen Zeitstempeln und für Menschen lesbaren Daten zu konvertieren!

Was ist ein Unix-Zeitstempel? Vollständiger Leitfaden zur Epochenzeit