🕐
← Zurück zu Anleitungen

Mit Unix-Zeitstempeln in Programmiersprachen arbeiten

· Tags: javascript, python, php, golang, programming, unix-timestamp, epoch, database

Warum Unix-Zeitstempel in der Programmierung?

Unix-Zeitstempel sind die universelle Währung der Zeit in der Softwareentwicklung. Sie machen Datumsarithmetik trivial (einfach Sekunden addieren oder subtrahieren), beseitigen Zeitzonenverwirrung und serialisieren sauber nach JSON. Jede Programmiersprache bietet unkomplizierte Funktionen für die Arbeit mit ihnen, aber die APIs unterscheiden sich subtil. Dieser Leitfaden behandelt die gängigsten Sprachen und ihre Best Practices.

JavaScript (Browser und Node.js)

JavaScript verwendet Millisekunden für sein Date-Objekt, während die meisten anderen Systeme Sekunden verwenden. Dies ist die häufigste Fehlerquelle.

Den aktuellen Zeitstempel abrufen

// Milliseconds since epoch (standard JavaScript)
const nowMs = Date.now();         // 1785292800000

// Seconds since epoch (for compatibility)
const nowSec = Math.floor(Date.now() / 1000);  // 1785292800

// Node.js high-resolution timer (microseconds)
const hrTime = process.hrtime.bigint();

Konvertieren eines Zeitstempels in ein Datum

// From seconds (most APIs and databases)
const timestamp = 1785292800;
const date = new Date(timestamp * 1000);  // Multiply by 1000!

// From milliseconds (JavaScript native)
const dateFromMs = new Date(1785292800000);

// Format the result
console.log(date.toISOString());
// Output: 2026-07-19T00:00:00.000Z

console.log(date.toLocaleString("en-US", { timeZone: "America/New_York" }));
// Output: 7/18/2026, 8:00:00 PM

Parsen einer Datumszeichenfolge in einen Zeitstempel

// Using Date.parse() (returns milliseconds)
const ms = Date.parse("2026-07-19T00:00:00Z");
const sec = ms / 1000;  // 1785292800

// Using Date constructor
const ts = Math.floor(new Date("2026-07-19 UTC").getTime() / 1000);

Warnung: Das Verhalten von Date.parse() variiert je nach Browser bei nicht standardkonformen Datumszeichenfolgen. Die Verwendung des ISO-8601-Formats mit einem Zeitzonenkennzeichner (Z für UTC) ist am sichersten.

Mit Zeitzonen in JavaScript arbeiten

// Format in a specific timezone
const date = new Date(1785292800 * 1000);
const options = {
  timeZone: "Asia/Tokyo",
  year: "numeric", month: "2-digit", day: "2-digit",
  hour: "2-digit", minute: "2-digit", second: "2-digit",
};
console.log(date.toLocaleString("ja-JP", options));
// Output: 07/19/2026 09:00:00

Für fortgeschrittene Zeitzonenoperationen werden die Intl.DateTimeFormat-API oder Bibliotheken wie date-fns-tz und Luxon empfohlen.

Python

Python bietet sowohl Module auf niedriger (time) als auch auf hoher Ebene (datetime) für die Arbeit mit Zeitstempeln.

Den aktuellen Zeitstempel abrufen

import time

# Seconds as a float (including fractional milliseconds)
current = time.time()
# Example: 1785292800.123456

# As an integer
current_int = int(time.time())

Konvertieren eines Zeitstempels in ein Datetime

from datetime import datetime

# UTC datetime (Python 3.x)
dt_utc = datetime.utcfromtimestamp(1785292800)

# Timezone-aware datetime (Python 3.9+ with zoneinfo)
from zoneinfo import ZoneInfo
dt_tokyo = datetime.fromtimestamp(1785292800, tz=ZoneInfo("Asia/Tokyo"))

# Formatted string
print(dt_utc.strftime("%Y-%m-%d %H:%M:%S"))
# Output: 2026-07-19 00:00:00

Parsen einer Datumszeichenfolge in einen Zeitstempel

import time
from datetime import datetime

# From date string
dt = datetime.strptime("2026-07-19 00:00:00", "%Y-%m-%d %H:%M:%S")
timestamp = time.mktime(dt.timetuple())  # Treats as local time

# For UTC input
from datetime import timezone
timestamp_utc = dt.replace(tzinfo=timezone.utc).timestamp()

Mit Pandas arbeiten (Datenanalyse)

import pandas as pd

# Convert a column of Unix timestamps to datetime
df["timestamp"] = pd.to_datetime(df["unix_seconds"], unit="s")

# Convert to different units
df["datetime_ms"] = pd.to_datetime(df["unix_milliseconds"], unit="ms")

# Set a timezone
df["timestamp_ny"] = df["timestamp"].dt.tz_localize("UTC").dt.tz_convert("America/New_York")

PHP

PHP hat die einfachste API für Zeitstempeloperationen.

Den aktuellen Zeitstempel abrufen

<?php
$now = time();           // Integer: 1785292800
$nowMicro = microtime();  // String: "0.12345600 1785292800"
$nowFloat = microtime(true);  // Float: 1785292800.1235

Konvertieren eines Zeitstempels in ein Datum

<?php
echo date("Y-m-d H:i:s", 1785292800);
// Output: 2026-07-19 00:00:00

// With timezone
$tz = new DateTimeZone("Europe/London");
$dt = new DateTime("@1785292800");
$dt->setTimezone($tz);
echo $dt->format("Y-m-d H:i:s");

Go

Das time-Paket von Go ist gut gestaltet, erfordert aber ein explizites Verständnis der beteiligten Typen.

Den aktuellen Zeitstempel abrufen

package main

import (
    "fmt"
    "time"
)

func main() {
    now := time.Now()
    sec := now.Unix()            // int64 seconds
    milli := now.UnixMilli()     // int64 milliseconds
    nano := now.UnixNano()       // int64 nanoseconds
    fmt.Printf("Seconds: %d\n", sec)
}

Konvertieren eines Zeitstempels in ein Datum

t := time.Unix(1785292800, 0)
fmt.Println(t.UTC())
// Output: 2026-07-19 00:00:00 +0000 UTC

// Format as string
fmt.Println(t.Format("2006-01-02 15:04:05"))
// Output: 2026-07-19 00:00:00

// With timezone
loc, _ := time.LoadLocation("America/Chicago")
fmt.Println(t.In(loc))

Rust

use std::time::{SystemTime, UNIX_EPOCH};

// Current timestamp
let now = SystemTime::now()
    .duration_since(UNIX_EPOCH)
    .expect("Time went backwards");
println!("Seconds: {}", now.as_secs());

// Timestamp to date
let dt = chrono::NaiveDateTime::from_timestamp_opt(1785292800, 0).unwrap();
println!("{}", dt.format("%Y-%m-%d %H:%M:%S"));

Datenbankspeicherung: Best Practices

Den richtigen Spaltentyp wählen

| Datenbank | Empfohlener Typ | Hinweise | |----------|-----------------|-------| | PostgreSQL | TIMESTAMP WITH TIME ZONE oder BIGINT | Nativer Zeitstempeltyp wird bevorzugt | | MySQL / MariaDB | INT UNSIGNED (für Daten bis 2106) oder BIGINT | Vermeiden Sie den Typ TIMESTAMP (Bereich endet 2038) | | SQLite | INTEGER | SQLite hat keinen nativen Zeitstempeltyp | | MongoDB | Date-Objekt oder int64 | BSON Date ist intern ein 64-Bit-Zeitstempel |

PostgreSQL-Beispiel

-- Store as native timestamp
CREATE TABLE events (
    id SERIAL PRIMARY KEY,
    occurred_at TIMESTAMP WITH TIME ZONE NOT NULL,
    payload JSONB
);

-- Insert with current time
INSERT INTO events (occurred_at) VALUES (NOW());

-- Query as Unix timestamp
SELECT EXTRACT(EPOCH FROM occurred_at) AS unix_ts FROM events;

MySQL-Beispiel

-- Using BIGINT for future-proof storage
CREATE TABLE logs (
    id INT AUTO_INCREMENT PRIMARY KEY,
    event_time BIGINT NOT NULL,
    message TEXT
);

-- Insert current timestamp
INSERT INTO logs (event_time, message) VALUES (UNIX_TIMESTAMP(), 'Server started');

-- Query and convert
SELECT FROM_UNIXTIME(event_time) AS readable_time FROM logs;

Sprachvergleichstabelle

| Sprache | Aktueller Zeitstempel | Zeitstempel zu Datum | Datum zu Zeitstempel | Auflösung | |----------|-------------------|-------------------|-------------------|------------| | JavaScript | Date.now() | new Date(ts * 1000) | Date.parse(str) / 1000 | Millisekunden | | Python | time.time() | datetime.fromtimestamp(ts) | datetime.strptime(str).timestamp() | Float-Sekunden | | PHP | time() | date("Y-m-d", ts) | strtotime(str) | Sekunden | | Go | time.Now().Unix() | time.Unix(ts, 0) | time.Parse(layout, str).Unix() | Sekunden | | Rust | SystemTime::now() | NaiveDateTime::from_timestamp_opt() | — | Verschiedene |

Welche Sprache Sie auch verwenden, unser Unix-Zeitstempel-Konverter ist ein zuverlässiger Begleiter für schnelle Überprüfungen und Debugging.