Unix-Zeitstempel in Datumsumrechner: Unterstützung für 12/24-Stunden-Format
Konvertieren Sie Unix-Zeitstempel in menschenlesbare Daten und Zeiten. Wählen Sie zwischen 12-Stunden- und 24-Stunden-Zeitformaten mit diesem einfachen, benutzerfreundlichen Umrechnungswerkzeug.
Unix-Zeitstempel-Konverter
Konvertiertes Datum & Uhrzeit
Dokumentation
Unix-Zeitstempel-Konverter
Einführung
Ein Unix-Zeitstempel (auch bekannt als POSIX-Zeit oder Epoch-Zeit) ist ein System zur Beschreibung eines Zeitpunkts. Es ist die Anzahl der Sekunden, die seit dem 1. Januar 1970 (Mitternacht UTC/GMT) vergangen sind, ohne Schaltsekunden zu zählen. Unix-Zeitstempel werden in Computersystemen und Programmiersprachen weit verbreitet verwendet, da sie eine kompakte, sprachunabhängige Darstellung eines bestimmten Moments in der Zeit bieten.
Dieser Konverter ermöglicht es Ihnen, einen Unix-Zeitstempel in ein menschenlesbares Datums- und Zeitformat zu transformieren. Er unterstützt sowohl das 12-Stunden- (AM/PM) als auch das 24-Stunden-Zeitformat, um unterschiedlichen regionalen und persönlichen Vorlieben gerecht zu werden.
Wie Unix-Zeitstempel funktionieren
Unix-Zeitstempel werden als die Anzahl der Sekunden seit der Unix-Epoche (1. Januar 1970, 00:00:00 UTC) berechnet. Dies macht sie besonders nützlich für die Berechnung von Zeitdifferenzen und für die Speicherung von Daten in einem kompakten Format.
Die mathematische Umwandlung von einem Unix-Zeitstempel in ein Kalenderdatum umfasst mehrere Schritte:
- Beginnen Sie mit der Unix-Epoche (1. Januar 1970, 00:00:00 UTC)
- Fügen Sie die Anzahl der Sekunden im Zeitstempel hinzu
- Berücksichtigen Sie Schaltjahre, unterschiedliche Monatslängen und andere Kalenderkomplexitäten
- Wenden Sie gegebenenfalls Zeitzonenanpassungen an
Zum Beispiel repräsentiert der Unix-Zeitstempel 1609459200 Freitag, den 1. Januar 2021, 00:00:00 UTC.
Die Umrechnungsformel kann ausgedrückt werden als:
Die meisten Programmiersprachen und Betriebssysteme bieten integrierte Funktionen zur Handhabung dieser Umwandlung, die die komplexen Kalenderberechnungen abstrahieren.
Zeitformat-Optionen
Dieser Konverter bietet zwei Zeitformatoptionen:
-
24-Stunden-Format (manchmal als "militärische Zeit" bezeichnet): Die Stunden reichen von 0 bis 23, und es gibt keine AM/PM-Bezeichnung. Zum Beispiel wird 15:00 Uhr als 15:00 dargestellt.
-
12-Stunden-Format: Die Stunden reichen von 1 bis 12, mit AM (ante meridiem) für Zeiten von Mitternacht bis Mittag und PM (post meridiem) für Zeiten von Mittag bis Mitternacht. Zum Beispiel wird 15:00 Uhr im 24-Stunden-Format als 3:00 PM dargestellt.
Die Wahl zwischen diesen Formaten ist weitgehend eine Frage der regionalen Konvention und persönlichen Vorliebe:
- Das 24-Stunden-Format wird in den meisten Teilen Europas, Lateinamerikas und Asiens sowie in wissenschaftlichen, militärischen und medizinischen Kontexten weltweit häufig verwendet.
- Das 12-Stunden-Format ist in den Vereinigten Staaten, Kanada, Australien und einigen anderen englischsprachigen Ländern für den täglichen Gebrauch verbreitet.
Randfälle und Einschränkungen
Beim Arbeiten mit Unix-Zeitstempeln ist es wichtig, sich über mehrere Randfälle und Einschränkungen im Klaren zu sein:
-
Negative Zeitstempel: Diese repräsentieren Daten vor der Unix-Epoche (1. Januar 1970). Obwohl sie mathematisch gültig sind, können einige Systeme negative Zeitstempel möglicherweise nicht korrekt verarbeiten.
-
Das Jahr-2038-Problem: Unix-Zeitstempel werden häufig als 32-Bit-signierte Ganzzahlen gespeichert, die am 19. Januar 2038 überlaufen werden. Nach diesem Zeitpunkt werden 32-Bit-Systeme nicht mehr in der Lage sein, Zeiten korrekt darzustellen, es sei denn, sie werden geändert, um einen größeren Ganzzahltyp zu verwenden.
-
Extrem große Zeitstempel: Sehr weit in der Zukunft liegende Daten sind möglicherweise in einigen Systemen nicht darstellbar oder werden inkonsistent behandelt.
-
Schaltsekunden: Unix-Zeit berücksichtigt keine Schaltsekunden, die gelegentlich zu UTC hinzugefügt werden, um die unregelmäßige Rotation der Erde auszugleichen. Das bedeutet, dass die Unix-Zeit nicht präzise mit der astronomischen Zeit synchronisiert ist.
-
Zeitzonenüberlegungen: Unix-Zeitstempel repräsentieren Momente in UTC. Die Umwandlung in die lokale Zeit erfordert zusätzliche Zeitzoneninformationen.
-
Sommerzeit: Bei der Umwandlung von Zeitstempeln in die lokale Zeit müssen die Komplexitäten der Sommerzeitübergänge berücksichtigt werden.
Anwendungsfälle
Unix-Zeitstempel werden in zahlreichen Anwendungen in der Informatik und Datenverwaltung verwendet:
-
Datenbankeinträge: Zeitstempel werden häufig verwendet, um zu protokollieren, wann Einträge erstellt oder geändert wurden.
-
Webentwicklung: HTTP-Header, Cookies und Caching-Mechanismen verwenden häufig Unix-Zeitstempel.
-
Protokolldateien: Systemprotokolle zeichnen typischerweise Ereignisse mit Unix-Zeitstempeln auf, um eine präzise chronologische Reihenfolge zu gewährleisten.
-
Versionskontrollsysteme: Git und andere VCS verwenden Zeitstempel, um aufzuzeichnen, wann Commits vorgenommen wurden.
-
API-Antworten: Viele Web-APIs enthalten Zeitstempel in ihren Antworten, um anzugeben, wann Daten generiert oder Ressourcen zuletzt geändert wurden.
-
Dateisysteme: Die Erstellungs- und Änderungszeiten von Dateien werden häufig als Unix-Zeitstempel gespeichert.
-
Sitzungsverwaltung: Webanwendungen verwenden Zeitstempel, um zu bestimmen, wann Benutzersitzungen ablaufen sollen.
-
Datenanalyse: Zeitstempel bieten eine standardisierte Möglichkeit, mit zeitlichen Daten in Analyseanwendungen zu arbeiten.
Alternativen
Obwohl Unix-Zeitstempel weit verbreitet sind, gibt es alternative Zeitdarstellungsformate, die in bestimmten Kontexten geeigneter sein können:
-
ISO 8601: Ein standardisiertes Zeichenfolgenformat (z. B. "2021-01-01T00:00:00Z"), das menschenlesbar ist und gleichzeitig Sortierbarkeit gewährleistet. Es wird häufig für den Datenaustausch und benutzerorientierte Anwendungen bevorzugt.
-
RFC 3339: Ein Profil von ISO 8601, das in Internetprotokollen verwendet wird und strengere Formatierungsanforderungen hat.
-
Menschenlesbare Formate: Lokalisierte Datumszeichenfolgen (z. B. "1. Januar 2021") sind besser für die direkte Benutzerinteraktion geeignet, aber weniger geeignet für Berechnungen.
-
Microsoft FILETIME: Ein 64-Bit-Wert, der die Anzahl der 100-Nanosekunden-Intervalle seit dem 1. Januar 1601 darstellt und in Windows-Systemen verwendet wird.
-
Julianischer Tag: Wird in der Astronomie und einigen wissenschaftlichen Anwendungen verwendet und zählt die Tage seit dem 1. Januar 4713 v. Chr.
Die Wahl des Zeitformats hängt von Faktoren wie ab:
- Erforderliche Genauigkeit
- Bedürfnisse der menschlichen Lesbarkeit
- Speicherbeschränkungen
- Kompatibilität mit bestehenden Systemen
- Bereich der darzustellenden Daten
Geschichte
Das Konzept der Unix-Zeit stammt aus der Entwicklung des Unix-Betriebssystems bei Bell Labs in den späten 1960er und frühen 1970er Jahren. Die Entscheidung, den 1. Januar 1970 als Epoche zu verwenden, war etwas willkürlich, aber praktisch für die damalige Zeit – es war nah genug, um die Speicheranforderungen für relevante Daten zu minimieren, aber weit genug in der Vergangenheit, um nützlich für historische Daten zu sein.
Die ursprüngliche Implementierung verwendete eine 32-Bit-signierte Ganzzahl zur Speicherung der Anzahl der Sekunden, was für die erwartete Lebensdauer von Unix-Systemen zu diesem Zeitpunkt ausreichend war. Diese Entscheidung führte jedoch zum Jahr-2038-Problem (manchmal als "Y2K38" oder "Unix-Millennium-Bug" bezeichnet), da 32-Bit-signierte Ganzzahlen nur Daten bis zum 19. Januar 2038 (03:14:07 UTC) darstellen können.
Als Unix und Unix-ähnliche Betriebssysteme an Popularität gewannen, wurde der Unix-Zeitstempel zum de facto Standard für die Darstellung von Zeit in der Informatik. Er wurde von zahlreichen Programmiersprachen, Datenbanken und Anwendungen übernommen und erstreckt sich weit über seine ursprüngliche Unix-Umgebung hinaus.
Moderne Systeme verwenden zunehmend 64-Bit-Ganzzahlen für Zeitstempel, was den darstellbaren Bereich auf etwa 292 Milliarden Jahre in beide Richtungen von der Epoche ausdehnt und somit das Jahr-2038-Problem effektiv löst. Ältere Systeme und Anwendungen könnten jedoch weiterhin anfällig sein.
Die Einfachheit und Nützlichkeit des Unix-Zeitstempels haben sichergestellt, dass er trotz der Entwicklung komplexerer Zeitdarstellungsformate weiterhin relevant bleibt. Er bleibt ein grundlegendes Konzept in der Informatik, das einen Großteil unserer digitalen Infrastruktur untermauert.
Codebeispiele
Hier sind Beispiele, wie man Unix-Zeitstempel in verschiedenen Programmiersprachen in menschenlesbare Daten umwandelt:
1// JavaScript Zeitstempelkonvertierung
2function convertUnixTimestamp(timestamp, use12Hour = false) {
3 // Erstellen Sie ein neues Date-Objekt (JavaScript verwendet Millisekunden)
4 const date = new Date(timestamp * 1000);
5
6 // Formatoptionen
7 const options = {
8 year: 'numeric',
9 month: 'long',
10 day: 'numeric',
11 weekday: 'long',
12 hour: use12Hour ? 'numeric' : '2-digit',
13 minute: '2-digit',
14 second: '2-digit',
15 hour12: use12Hour
16 };
17
18 // Umwandlung in eine Zeichenfolge mit lokalisierter Formatierung
19 return date.toLocaleString(undefined, options);
20}
21
22// Beispielverwendung
23const timestamp = 1609459200; // 1. Januar 2021 00:00:00 UTC
24console.log(convertUnixTimestamp(timestamp, false)); // 24-Stunden-Format
25console.log(convertUnixTimestamp(timestamp, true)); // 12-Stunden-Format
261# Python Zeitstempelkonvertierung
2import datetime
3
4def convert_unix_timestamp(timestamp, use_12hour=False):
5 # Unix-Zeitstempel in ein datetime-Objekt umwandeln
6 date = datetime.datetime.fromtimestamp(timestamp)
7
8 # Format der Datumszeichenfolge
9 if use_12hour:
10 format_string = "%A, %B %d, %Y %I:%M:%S %p" # 12-Stunden-Format mit AM/PM
11 else:
12 format_string = "%A, %B %d, %Y %H:%M:%S" # 24-Stunden-Format
13
14 return date.strftime(format_string)
15
16# Beispielverwendung
17timestamp = 1609459200 # 1. Januar 2021 00:00:00 UTC
18print(convert_unix_timestamp(timestamp, False)) # 24-Stunden-Format
19print(convert_unix_timestamp(timestamp, True)) # 12-Stunden-Format
201<?php
2// PHP Zeitstempelkonvertierung
3function convertUnixTimestamp($timestamp, $use12Hour = false) {
4 // Formatzeichenfolge
5 $formatString = $use12Hour
6 ? 'l, F j, Y g:i:s A' // 12-Stunden-Format mit AM/PM
7 : 'l, F j, Y H:i:s'; // 24-Stunden-Format
8
9 // Umwandlung und Formatierung des Datums
10 return date($formatString, $timestamp);
11}
12
13// Beispielverwendung
14$timestamp = 1609459200; // 1. Januar 2021 00:00:00 UTC
15echo convertUnixTimestamp($timestamp, false) . "\n"; // 24-Stunden-Format
16echo convertUnixTimestamp($timestamp, true) . "\n"; // 12-Stunden-Format
17?>
181// Java Zeitstempelkonvertierung
2import java.time.Instant;
3import java.time.LocalDateTime;
4import java.time.ZoneId;
5import java.time.format.DateTimeFormatter;
6
7public class UnixTimestampConverter {
8 public static String convertUnixTimestamp(long timestamp, boolean use12Hour) {
9 // Unix-Zeitstempel in Instant umwandeln, dann in LocalDateTime
10 Instant instant = Instant.ofEpochSecond(timestamp);
11 LocalDateTime dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
12
13 // Erstellen Sie einen Formatter basierend auf dem gewünschten Format
14 DateTimeFormatter formatter = DateTimeFormatter.ofPattern(
15 use12Hour ? "EEEE, MMMM d, yyyy h:mm:ss a" : "EEEE, MMMM d, yyyy HH:mm:ss"
16 );
17
18 // Formatieren Sie das Datum
19 return dateTime.format(formatter);
20 }
21
22 public static void main(String[] args) {
23 long timestamp = 1609459200; // 1. Januar 2021 00:00:00 UTC
24 System.out.println(convertUnixTimestamp(timestamp, false)); // 24-Stunden-Format
25 System.out.println(convertUnixTimestamp(timestamp, true)); // 12-Stunden-Format
26 }
27}
281// C# Zeitstempelkonvertierung
2using System;
3
4class UnixTimestampConverter
5{
6 public static string ConvertUnixTimestamp(long timestamp, bool use12Hour)
7 {
8 // Unix-Zeitstempel in DateTime umwandeln
9 // Unix-Zeitstempel sind Sekunden seit 1970-01-01
10 DateTime dateTime = DateTimeOffset.FromUnixTimeSeconds(timestamp).DateTime;
11
12 // Formatzeichenfolge basierend auf 12-Stunden- oder 24-Stunden-Präferenz
13 string formatString = use12Hour
14 ? "dddd, MMMM d, yyyy h:mm:ss tt" // 12-Stunden-Format mit AM/PM
15 : "dddd, MMMM d, yyyy HH:mm:ss"; // 24-Stunden-Format
16
17 // Rückgabe der formatierten Datumszeichenfolge
18 return dateTime.ToString(formatString);
19 }
20
21 static void Main()
22 {
23 long timestamp = 1609459200; // 1. Januar 2021 00:00:00 UTC
24 Console.WriteLine(ConvertUnixTimestamp(timestamp, false)); // 24-Stunden-Format
25 Console.WriteLine(ConvertUnixTimestamp(timestamp, true)); // 12-Stunden-Format
26 }
27}
281# Ruby Zeitstempelkonvertierung
2require 'time'
3
4def convert_unix_timestamp(timestamp, use_12hour = false)
5 # Unix-Zeitstempel in Time-Objekt umwandeln
6 time = Time.at(timestamp)
7
8 # Format basierend auf 12-Stunden- oder 24-Stunden-Präferenz
9 if use_12hour
10 time.strftime("%A, %B %d, %Y %I:%M:%S %p") # 12-Stunden-Format mit AM/PM
11 else
12 time.strftime("%A, %B %d, %Y %H:%M:%S") # 24-Stunden-Format
13 end
14end
15
16# Beispielverwendung
17timestamp = 1609459200 # 1. Januar 2021 00:00:00 UTC
18puts convert_unix_timestamp(timestamp, false) # 24-Stunden-Format
19puts convert_unix_timestamp(timestamp, true) # 12-Stunden-Format
201// Go Zeitstempelkonvertierung
2package main
3
4import (
5 "fmt"
6 "time"
7)
8
9func convertUnixTimestamp(timestamp int64, use12Hour bool) string {
10 // Unix-Zeitstempel in Time umwandeln
11 t := time.Unix(timestamp, 0)
12
13 // Formatzeichenfolge basierend auf 12-Stunden- oder 24-Stunden-Präferenz
14 formatString := "Monday, January 2, 2006 "
15 if use12Hour {
16 formatString += "3:04:05 PM" // 12-Stunden-Format mit AM/PM
17 } else {
18 formatString += "15:04:05" // 24-Stunden-Format
19 }
20
21 // Rückgabe der formatierten Zeit
22 return t.Format(formatString)
23}
24
25func main() {
26 timestamp := int64(1609459200) // 1. Januar 2021 00:00:00 UTC
27 fmt.Println(convertUnixTimestamp(timestamp, false)) // 24-Stunden-Format
28 fmt.Println(convertUnixTimestamp(timestamp, true)) // 12-Stunden-Format
29}
301// Swift Zeitstempelkonvertierung
2import Foundation
3
4func convertUnixTimestamp(_ timestamp: Int, use12Hour: Bool) -> String {
5 // Erstellen Sie ein Datum aus dem Unix-Zeitstempel
6 let date = Date(timeIntervalSince1970: TimeInterval(timestamp))
7
8 // Erstellen Sie einen DateFormatter
9 let formatter = DateFormatter()
10 formatter.dateStyle = .full
11
12 // Setzen Sie den Zeitstil basierend auf der 12-Stunden- oder 24-Stunden-Präferenz
13 if use12Hour {
14 formatter.timeStyle = .medium
15 formatter.amSymbol = "AM"
16 formatter.pmSymbol = "PM"
17 } else {
18 formatter.timeStyle = .medium
19 formatter.dateFormat = formatter.dateFormat?.replacingOccurrences(of: "h:mm:ss a", with: "HH:mm:ss")
20 }
21
22 // Rückgabe des formatierten Datums
23 return formatter.string(from: date)
24}
25
26// Beispielverwendung
27let timestamp = 1609459200 // 1. Januar 2021 00:00:00 UTC
28print(convertUnixTimestamp(timestamp, use12Hour: false)) // 24-Stunden-Format
29print(convertUnixTimestamp(timestamp, use12Hour: true)) // 12-Stunden-Format
301# R Zeitstempelkonvertierung
2convert_unix_timestamp <- function(timestamp, use_12hour = FALSE) {
3 # Unix-Zeitstempel in POSIXct-Datum/Zeit umwandeln
4 date_time <- as.POSIXct(timestamp, origin = "1970-01-01", tz = "UTC")
5
6 # Format basierend auf 12-Stunden- oder 24-Stunden-Präferenz
7 if (use_12hour) {
8 format_string <- "%A, %B %d, %Y %I:%M:%S %p" # 12-Stunden-Format mit AM/PM
9 } else {
10 format_string <- "%A, %B %d, %Y %H:%M:%S" # 24-Stunden-Format
11 }
12
13 # Rückgabe der formatierten Datumszeichenfolge
14 format(date_time, format_string)
15}
16
17# Beispielverwendung
18timestamp <- 1609459200 # 1. Januar 2021 00:00:00 UTC
19cat(convert_unix_timestamp(timestamp, FALSE), "\n") # 24-Stunden-Format
20cat(convert_unix_timestamp(timestamp, TRUE), "\n") # 12-Stunden-Format
211% MATLAB Zeitstempelkonvertierung
2function formattedDate = convertUnixTimestamp(timestamp, use12Hour)
3 % Unix-Zeitstempel in MATLAB-Datum/Uhrzeit umwandeln
4 % MATLAB-Daten sind Tage seit 1900-01-01, wobei 1 = 1900-01-01
5 % Unix-Zeitstempel sind Sekunden seit 1970-01-01
6
7 % Zuerst in Excel-Datumsformat umwandeln
8 % 25569 ist die Anzahl der Tage zwischen 1900-01-01 und 1970-01-01
9 excelDate = (timestamp / 86400) + 25569;
10
11 % Format basierend auf 12-Stunden- oder 24-Stunden-Präferenz
12 if use12Hour
13 formattedDate = datestr(excelDate, 'dddd, mmmm dd, yyyy h:mm:ss AM/PM');
14 else
15 formattedDate = datestr(excelDate, 'dddd, mmmm dd, yyyy hh:mm:ss');
16 end
17end
18
19% Beispielverwendung
20timestamp = 1609459200; % 1. Januar 2021 00:00:00 UTC
21disp(convertUnixTimestamp(timestamp, false)) % 24-Stunden-Format
22disp(convertUnixTimestamp(timestamp, true)) % 12-Stunden-Format
231' Excel VBA Zeitstempelkonvertierung
2Function ConvertUnixTimestamp(timestamp As Long, Optional use12Hour As Boolean = False) As String
3 ' Unix-Zeitstempel in Excel-Datum/Uhrzeit umwandeln
4 ' Excel-Daten sind Tage seit 1900-01-01, wobei 1 = 1900-01-01
5 ' Unix-Zeitstempel sind Sekunden seit 1970-01-01
6
7 ' Zuerst in Excel-Datumsformat umwandeln
8 ' 25569 ist die Anzahl der Tage zwischen 1900-01-01 und 1970-01-01
9 Dim excelDate As Double
10 excelDate = (timestamp / 86400) + 25569
11
12 ' Format der Datumszeichenfolge basierend auf 12-Stunden- oder 24-Stunden-Präferenz
13 If use12Hour Then
14 ConvertUnixTimestamp = Format(excelDate, "dddd, mmmm d, yyyy h:mm:ss AM/PM")
15 Else
16 ConvertUnixTimestamp = Format(excelDate, "dddd, mmmm d, yyyy hh:mm:ss")
17 End If
18End Function
19
20' Verwendung in einem Arbeitsblatt:
21' =ConvertUnixTimestamp(1609459200, TRUE) ' 12-Stunden-Format
22' =ConvertUnixTimestamp(1609459200, FALSE) ' 24-Stunden-Format
23Umgang mit Randfällen
Beim Arbeiten mit Unix-Zeitstempeln ist es wichtig, Randfälle korrekt zu behandeln. Hier sind Beispiele für den Umgang mit einigen häufigen Randfällen:
1// JavaScript Randfallbehandlung
2function safeConvertTimestamp(timestamp, use12Hour = false) {
3 // Überprüfen, ob der Zeitstempel gültig ist
4 if (timestamp === undefined || timestamp === null || isNaN(timestamp)) {
5 return "Ungültiger Zeitstempel";
6 }
7
8 // Überprüfen auf negative Zeitstempel (Daten vor 1970)
9 if (timestamp < 0) {
10 // Einige Browser könnten negative Zeitstempel möglicherweise nicht korrekt verarbeiten
11 // Verwenden Sie einen robusteren Ansatz für Daten vor 1970
12 const date = new Date(timestamp * 1000);
13 if (isNaN(date.getTime())) {
14 return "Ungültiges Datum (vor 1970)";
15 }
16 }
17
18 // Überprüfen auf das Y2K38-Problem (für 32-Bit-Systeme)
19 const maxInt32 = 2147483647; // Maximalwert für 32-Bit-signierte Ganzzahl
20 if (timestamp > maxInt32) {
21 // Erwägen Sie die Verwendung von BigInt für sehr große Zeitstempel in modernem JavaScript
22 console.warn("Zeitstempel überschreitet das 32-Bit-Ganzzahl-Limit (Y2K38-Problem)");
23 }
24
25 // Fahren Sie mit der normalen Umwandlung fort
26 try {
27 const date = new Date(timestamp * 1000);
28 const options = {
29 year: 'numeric',
30 month: 'long',
31 day: 'numeric',
32 weekday: 'long',
33 hour: use12Hour ? 'numeric' : '2-digit',
34 minute: '2-digit',
35 second: '2-digit',
36 hour12: use12Hour
37 };
38 return date.toLocaleString(undefined, options);
39 } catch (error) {
40 return "Fehler bei der Umwandlung des Zeitstempels: " + error.message;
41 }
42}
43Referenzen
-
"Unix-Zeit." Wikipedia, Wikimedia Foundation, https://de.wikipedia.org/wiki/Unixzeit
-
"Jahr-2038-Problem." Wikipedia, Wikimedia Foundation, https://de.wikipedia.org/wiki/Jahr-2038-Problem
-
Olson, Arthur David. "Die Komplexitäten der kalendarischen Zeit." The Open Group, https://www.usenix.org/legacy/events/usenix01/full_papers/olson/olson.pdf
-
"ISO 8601." Wikipedia, Wikimedia Foundation, https://de.wikipedia.org/wiki/ISO_8601
-
"RFC 3339: Datum und Uhrzeit im Internet: Zeitstempel." Internet Engineering Task Force (IETF), https://tools.ietf.org/html/rfc3339
-
Kernighan, Brian W., und Dennis M. Ritchie. "Die C-Programmiersprache." Prentice Hall, 1988.
Feedback
Klicken Sie auf das Feedback-Toast, um Feedback zu diesem Tool zu geben
Verwandte Werkzeuge
Entdecken Sie weitere Werkzeuge, die für Ihren Arbeitsablauf nützlich sein könnten