Konvertiere Epoch-Sekunden/Millisekunden in lesbare Datumsangaben und zurück. Datenschutzfreundlich (100 % clientseitig).
Uber UNIX / Epoch-Zeit
Ein UNIX-Zeitstempel (oft auch Epoch-Zeit) ist eine einzelne Zahl, die angibt, wie viel Zeit
seit der Unix-Epoch vergangen ist: 1970-01-01T00:00:00Z (UTC). Er wird häufig in Logs,
Datenbanken und APIs verwendet, weil er kompakt, sortierbar und zeitzonenunabhängig ist.
Kurzfakten
- Sekunden vs. Millisekunden vs. Nanosekunden:
- 10 Ziffern → Sekunden (z. B.
1700000000)
- 13 Ziffern → Millisekunden (z. B.
1700000000000)
- 16 Ziffern → Mikrosekunden (z. B.
1700000000000000)
- 19 Ziffern → Nanosekunden (häufig aus hochpräzisen Systemen)
- Zeitzonenunabhängig: die Zahl steht für einen absoluten Zeitpunkt; nur die Anzeige ändert sich durch Zeitzone/Sommerzeit.
- Negative Werte stehen für Daten vor 1970-01-01 (z. B.
-31536000 → 1969-01-01T00:00:00Z).
- Y2038-Grenze (32-Bit-Sekunden):
2147483647 → 2038-01-19T03:14:07Z. Moderne Systeme nutzen 64 Bit und haben diese Begrenzung nicht.
Haufige Beispiele
| Bedeutung | Sekunden | Millisekunden | UTC (ISO-8601) |
|---|
| Epoch-Start |
0 |
0 |
1970-01-01T00:00:00Z |
| Eine Milliarde Sekunden |
1000000000 |
1000000000000 |
2001-09-09T01:46:40Z |
| 2038-Grenze (32 Bit) |
2147483647 |
2147483647000 |
2038-01-19T03:14:07Z |
| Beispiel aus der Gegenwart |
1600000000 |
1600000000000 |
2020-09-13T12:26:40Z |
Zeitzonen und Sommerzeit
- Ein Zeitstempel wird in UTC gespeichert. Wenn du ihn in „Europe/London“ oder „America/New_York“ ansiehst, ändert sich nur die dargestellte Zeichenfolge.
- Sprünge durch Sommerzeit ändern nicht den zugrunde liegenden Zeitstempel, sondern nur die Anzeige der Ortszeit.
- Für eindeutige Angaben nutze bevorzugt ISO-8601 wie
2025-03-01T10:30:00Z oder mit Offset (z. B. +01:00).
Parsing-Tipps
- Browser interpretieren einen Datumsstring ohne Zeitzone in der lokalen Zeitzone des Nutzers:
2025-03-01 10:30:00 → Ortszeit2025-03-01T10:30:00Z → UTC (das nachgestellte Z bedeutet Zulu/UTC)2025-03-01T10:30:00+05:30 → UTC+5:30
- Wenn du eine 10-stellige Zahl (Sekunden) einfügst, aber Millisekunden erwartest, multipliziere mit 1000.
- Wenn du einen 19-stelligen Wert (Nanosekunden) einfügst, teile durch
1,000,000, um Millisekunden zu erhalten.
Wann verwende ich welche Einheit?
- Sekunden: viele Backend-APIs, Datenbanken, Shell-Tools.
- Millisekunden: JavaScript-
Date, Browser, die meisten Frontend-Anwendungen.
- Nanosekunden: hochpräzise Logs/Telemetrie; für JS-
Date in ms umrechnen.
Epoch-Zeit nach Sprache (Schnellrezepte)
Kopierfreundliche Codebeispiele für häufige Aufgaben: aktuelle Epoch-Zeit holen, ein lesbares Datum → Epoch konvertieren und Epoch → Datum konvertieren.
JavaScript (Browser & Node)
// current epoch
const s = Math.floor(Date.now() / 1000); // seconds
const ms = Date.now(); // milliseconds
// date → epoch
const dt = new Date("2025-03-01T10:30:00Z");
const epochSeconds = Math.floor(dt.getTime() / 1000);
// epoch → date
const d1 = new Date(1700000000 * 1000); // seconds → ms
const d2 = new Date(1700000000000); // ms
Python
import time, datetime, calendar
# current epoch
sec = time.time() # float seconds
ms = round(time.time()*1000)
# date → epoch (UTC)
dt = datetime.datetime(2025, 3, 1, 10, 30, tzinfo=datetime.timezone.utc)
epoch_seconds = int(dt.timestamp())
# epoch → date (UTC)
dt2 = datetime.datetime.fromtimestamp(1700000000, tz=datetime.timezone.utc)
Java
import java.time.*;
long sec = Instant.now().getEpochSecond(); // current epoch (s)
long ms = Instant.now().toEpochMilli(); // current epoch (ms)
// date → epoch
Instant ins = Instant.parse("2025-03-01T10:30:00Z");
long epochSeconds = ins.getEpochSecond();
// epoch → date
Instant ins2 = Instant.ofEpochSecond(1700000000);
ZonedDateTime zdt = ins2.atZone(ZoneId.of("UTC"));
C# (.NET)
using System;
long sec = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
long ms = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
// date → epoch
var dto = new DateTimeOffset(2025, 3, 1, 10, 30, 0, TimeSpan.Zero);
long epochSeconds = dto.ToUnixTimeSeconds();
// epoch → date
var dto2 = DateTimeOffset.FromUnixTimeSeconds(1700000000); // UTC
Go
package main
import ("fmt"; "time")
func main() {
sec := time.Now().Unix() // seconds
ms := time.Now().UnixMilli() // milliseconds
// date → epoch (UTC)
t, _ := time.Parse(time.RFC3339, "2025-03-01T10:30:00Z")
fmt.Println(t.Unix())
// epoch → date
t2 := time.Unix(1700000000, 0).UTC()
fmt.Println(t2.Format(time.RFC3339))
}
PHP
// current epoch
$sec = time(); // seconds
$ms = round(microtime(true)*1000);
// date → epoch (UTC recommended)
$dt = new DateTime("2025-03-01T10:30:00Z");
$epoch = $dt->getTimestamp();
// epoch → date
$dt2 = (new DateTime())->setTimestamp(1700000000)->setTimezone(new DateTimeZone("UTC"));
echo $dt2->format(DATE_RFC3339);
Ruby
# current epoch
s = Time.now.to_i # seconds
ms = (Time.now.to_f*1000).to_i
# date → epoch (UTC)
t = Time.utc(2025,3,1,10,30,0)
s2 = t.to_i
# epoch → date
t2 = Time.at(1700000000).utc
Rust
use std::time::{SystemTime, UNIX_EPOCH, Duration};
// current epoch
let now = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
let sec = now.as_secs();
let ms = now.as_millis();
// epoch → date (example with chrono)
use chrono::{DateTime, Utc, TimeZone};
let d: DateTime<Utc> = Utc.timestamp_opt(1_700_000_000, 0).unwrap();
Kotlin
import java.time.Instant
import java.time.ZoneId
val sec = Instant.now().epochSecond
val ms = Instant.now().toEpochMilli()
// date → epoch
val ins = Instant.parse("2025-03-01T10:30:00Z")
val epochSeconds = ins.epochSecond
// epoch → date
val zdt = Instant.ofEpochSecond(1700000000).atZone(ZoneId.of("UTC"))
Swift
import Foundation
let sec = Int(Date().timeIntervalSince1970) // seconds
let ms = Int(Date().timeIntervalSince1970 * 1000)
// date → epoch (ISO8601)
let iso = ISO8601DateFormatter().date(from: "2025-03-01T10:30:00Z")!
let epoch = Int(iso.timeIntervalSince1970)
// epoch → date
let d = Date(timeIntervalSince1970: 1700000000)
C++ (C++11+)
#include <chrono>
using namespace std::chrono;
// current epoch
auto now = system_clock::now();
auto sec = duration_cast<seconds>(now.time_since_epoch()).count();
auto ms = duration_cast<milliseconds>(now.time_since_epoch()).count();
// epoch → time_point
auto tp = system_clock::time_point{seconds{1700000000}};
Bash / Unix-Shell
# current epoch
date +%s # seconds
python3 - <<'PY'\nimport time; print(round(time.time()*1000))\nPY # ms fallback
# date → epoch (UTC)
date -u -d "2025-03-01 10:30:00" +%s
# epoch → date (local or -u for UTC)
date -d @1700000000
PowerShell
# current epoch
$sec = [int][double]::Parse((Get-Date (Get-Date).ToUniversalTime() -UFormat %s))
$ms = [int]([DateTimeOffset]::UtcNow.ToUnixTimeMilliseconds())
# epoch → date
[DateTimeOffset]::FromUnixTimeSeconds(1700000000).UtcDateTime
PostgreSQL
-- current epoch (seconds)
SELECT EXTRACT(EPOCH FROM NOW());
-- date → epoch (UTC)
SELECT EXTRACT(EPOCH FROM TIMESTAMP '2025-03-01 10:30:00+00');
-- epoch → timestamp
SELECT TO_TIMESTAMP(1700000000) AT TIME ZONE 'UTC';
MySQL / MariaDB
-- current epoch
SELECT UNIX_TIMESTAMP();
-- date → epoch (assumes UTC string if suffixed with 'Z')
SELECT UNIX_TIMESTAMP('2025-03-01 10:30:00');
-- epoch → datetime
SELECT FROM_UNIXTIME(1700000000);
Tipp: Bevorzuge ISO-8601-Zeichenfolgen (z. B. 2025-03-01T10:30:00Z) für eindeutige UTC-Werte. Wenn eine API Sekunden erwartet, du aber Millisekunden hast, teile durch 1000 (bzw. multipliziere für die Gegenrichtung).
