Unix-tidsstempel til dato-konverter: 12/24 timers format understøttelse
Konverter Unix-tidsstempler til menneskelæselige datoer og tidspunkter. Vælg mellem 12-timers og 24-timers tidsformater med dette enkle, brugervenlige konverteringsværktøj.
Unix Tidsstempel Konverter
Konverteret Dato & Tid
Dokumentation
Unix Tidsstempel Konverter
Introduktion
Et Unix tidsstempel (også kendt som POSIX tid eller Epoch tid) er et system til at beskrive et tidspunkt. Det er antallet af sekunder, der er gået siden 1. januar 1970 (midnat UTC/GMT), uden at tælle skudsekunder. Unix tidsstempler er vidt brugt i computersystemer og programmeringssprog, da de giver en kompakt, sprog-uafhængig repræsentation af et bestemt øjeblik i tiden.
Denne konverter giver dig mulighed for at omdanne et Unix tidsstempel til et menneskeligt læsbart dato- og tidsformat. Den understøtter både 12-timers (AM/PM) og 24-timers tidsformater for at imødekomme forskellige regionale og personlige præferencer.
Hvordan Unix Tidsstempler Fungerer
Unix tidsstempler beregnes som antallet af sekunder siden Unix Epoch (1. januar 1970, 00:00:00 UTC). Dette gør dem særligt nyttige til at beregne tidsforskelle og til at gemme datoer i et kompakt format.
Den matematiske konvertering fra et Unix tidsstempel til en kalenderdato involverer flere trin:
- Start med Unix Epoch (1. januar 1970, 00:00:00 UTC)
- Læg antallet af sekunder i tidsstemplet til
- Tag højde for skudår, varierende månedslængder og andre kalenderkompleksiteter
- Anvend tidszonejusteringer, hvis nødvendigt
For eksempel repræsenterer Unix tidsstemplet 1609459200 fredag den 1. januar 2021, 00:00:00 UTC.
Konverteringsformlen kan udtrykkes som:
De fleste programmeringssprog og operativsystemer tilbyder indbyggede funktioner til at håndtere denne konvertering, hvilket abstraherer de komplekse kalenderberegninger.
Tidsformatmuligheder
Denne konverter tilbyder to tidsformatmuligheder:
-
24-timers format (nogle gange kaldet "militærtid"): Timerne spænder fra 0 til 23, og der er ingen AM/PM betegnelse. For eksempel repræsenteres kl. 15:00 som 15:00.
-
12-timers format: Timerne spænder fra 1 til 12, med AM (ante meridiem) for tider fra midnat til middag og PM (post meridiem) for tider fra middag til midnat. For eksempel repræsenteres 15:00 i 24-timers format som 3:00 PM.
Valget mellem disse formater er i høj grad et spørgsmål om regional konvention og personlig præference:
- 24-timers formatet er almindeligt anvendt i de fleste af Europa, Latinamerika og Asien, samt i videnskabelige, militære og medicinske sammenhænge verden over.
- 12-timers formatet er udbredt i USA, Canada, Australien og nogle andre engelsktalende lande til daglig brug.
Grænsetilfælde og Begrænsninger
Når man arbejder med Unix tidsstempler, er det vigtigt at være opmærksom på flere grænsetilfælde og begrænsninger:
-
Negative tidsstempler: Disse repræsenterer datoer før Unix Epoch (1. januar 1970). Selvom de er matematikmæssigt gyldige, håndterer nogle systemer muligvis ikke negative tidsstempler korrekt.
-
År 2038 Problemet: Unix tidsstempler gemmes ofte som 32-bit signerede heltal, som vil overflyde den 19. januar 2038. Efter dette tidspunkt vil 32-bit systemer ikke være i stand til at repræsentere tider korrekt, medmindre de ændres til at bruge en større heltalstype.
-
Ekstremt store tidsstempler: Meget fjerne fremtidige datoer kan muligvis ikke repræsenteres i nogle systemer eller kan håndteres inkonsekvent.
-
Skudsekunder: Unix tid tager ikke højde for skudsekunder, som lejlighedsvis tilføjes til UTC for at kompensere for Jordens uregelmæssige rotation. Dette betyder, at Unix tid ikke er præcist synkroniseret med astronomisk tid.
-
Tidszoneovervejelser: Unix tidsstempler repræsenterer øjeblikke i UTC. Konvertering til lokal tid kræver yderligere tidszoneinformation.
-
Sommertid: Når man konverterer tidsstempler til lokal tid, skal kompleksiteten ved sommertidsovergangene tages i betragtning.
Anvendelsesområder
Unix tidsstempler anvendes i mange applikationer på tværs af computing og datastyring:
-
Databaseposter: Tidsstempler bruges ofte til at registrere, hvornår poster blev oprettet eller ændret.
-
Webudvikling: HTTP-overskrifter, cookies og cache-mekanismer bruger ofte Unix tidsstempler.
-
Logfiler: Systemlogfiler registrerer typisk begivenheder med Unix tidsstempler for præcis kronologisk rækkefølge.
-
Versionskontrolsystemer: Git og andre VCS bruger tidsstempler til at registrere, hvornår commits blev foretaget.
-
API-svar: Mange web-API'er inkluderer tidsstempler i deres svar for at angive, hvornår data blev genereret, eller hvornår ressourcer sidst blev ændret.
-
Filsystemer: Filoprettelses- og ændringstider gemmes ofte som Unix tidsstempler.
-
Session Management: Webapplikationer bruger tidsstempler til at bestemme, hvornår brugersessioner skal udløbe.
-
Dataanalyse: Tidsstempler giver en standardiseret måde at arbejde med tidsdata i analyseapplikationer.
Alternativer
Selvom Unix tidsstempler er vidt brugt, er der alternative tidsrepræsentationsformater, der kan være mere passende i visse sammenhænge:
-
ISO 8601: Et standardiseret strengformat (f.eks. "2021-01-01T00:00:00Z"), der er menneskeligt læsbart, mens det opretholder sorteringsmuligheder. Det er ofte at foretrække til dataudveksling og brugerorienterede applikationer.
-
RFC 3339: En profil af ISO 8601, der anvendes i internetprotokoller, med strengere formateringskrav.
-
Menneskeligt læsbare formater: Lokaliserede datostreng (f.eks. "1. januar 2021") er mere passende til direkte brugerinteraktion, men er mindre egnede til beregning.
-
Microsoft FILETIME: En 64-bit værdi, der repræsenterer antallet af 100-nanosekunders intervaller siden 1. januar 1601, der bruges i Windows-systemer.
-
Juliansk Dagsnummer: Bruges i astronomi og nogle videnskabelige applikationer, der tæller dage siden 1. januar 4713 f.Kr.
Valget af tidsformat afhænger af faktorer som:
- Krævet præcision
- Behov for menneskelig læsbarhed
- Lagringsbegrænsninger
- Kompatibilitet med eksisterende systemer
- Omfanget af datoer, der skal repræsenteres
Historie
Konceptet med Unix tid opstod med udviklingen af Unix-operativsystemet ved Bell Labs i slutningen af 1960'erne og begyndelsen af 1970'erne. Beslutningen om at bruge 1. januar 1970 som epoch var noget vilkårlig, men praktisk for den tid—det var nyligt nok til at minimere lagerkravene for datoer af interesse, men langt nok tilbage i tiden til at være nyttigt for historiske data.
Den oprindelige implementering brugte et 32-bit signeret heltal til at gemme antallet af sekunder, hvilket var tilstrækkeligt til den forventede levetid for Unix-systemer på det tidspunkt. Imidlertid førte denne beslutning til År 2038 Problemet (nogle gange kaldet "Y2K38" eller "Unix Millennium Bug"), da 32-bit signerede heltal kun kan repræsentere datoer op til 19. januar 2038 (03:14:07 UTC).
Efterhånden som Unix og Unix-lignende operativsystemer vandt popularitet, blev Unix tidsstempel en de facto standard for at repræsentere tid i computing. Det blev vedtaget af adskillige programmeringssprog, databaser og applikationer, der strakte sig langt ud over det oprindelige Unix-miljø.
Moderne systemer bruger i stigende grad 64-bit heltal til tidsstempler, hvilket udvider det repræsentable område til cirka 292 milliarder år i begge retninger fra epoch, hvilket effektivt løser År 2038 Problemet. Dog kan ældre systemer og applikationer stadig være sårbare.
Unix tidsstempelens enkelhed og nytte har sikret, at det forbliver relevant på trods af udviklingen af mere sofistikerede tidsrepræsentationsformater. Det forbliver et grundlæggende koncept i computing, der understøtter meget af vores digitale infrastruktur.
Kodeeksempler
Her er eksempler på, hvordan man konverterer Unix tidsstempler til menneskeligt læsbare datoer i forskellige programmeringssprog:
1// JavaScript tidsstempel konvertering
2function convertUnixTimestamp(timestamp, use12Hour = false) {
3 // Opret et nyt Date objekt (JavaScript bruger millisekunder)
4 const date = new Date(timestamp * 1000);
5
6 // Formateringsmuligheder
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 // Konverter til streng ved hjælp af lokal formatering
19 return date.toLocaleString(undefined, options);
20}
21
22// Eksempel på brug
23const timestamp = 1609459200; // 1. januar 2021 00:00:00 UTC
24console.log(convertUnixTimestamp(timestamp, false)); // 24-timers format
25console.log(convertUnixTimestamp(timestamp, true)); // 12-timers format
261# Python tidsstempel konvertering
2import datetime
3
4def convert_unix_timestamp(timestamp, use_12hour=False):
5 # Konverter Unix tidsstempel til datetime objekt
6 date = datetime.datetime.fromtimestamp(timestamp)
7
8 # Formater dato strengen
9 if use_12hour:
10 format_string = "%A, %B %d, %Y %I:%M:%S %p" # 12-timers format med AM/PM
11 else:
12 format_string = "%A, %B %d, %Y %H:%M:%S" # 24-timers format
13
14 return date.strftime(format_string)
15
16# Eksempel på brug
17timestamp = 1609459200 # 1. januar 2021 00:00:00 UTC
18print(convert_unix_timestamp(timestamp, False)) # 24-timers format
19print(convert_unix_timestamp(timestamp, True)) # 12-timers format
201<?php
2// PHP tidsstempel konvertering
3function convertUnixTimestamp($timestamp, $use12Hour = false) {
4 // Formateringsstreng
5 $formatString = $use12Hour
6 ? 'l, F j, Y g:i:s A' // 12-timers format med AM/PM
7 : 'l, F j, Y H:i:s'; // 24-timers format
8
9 // Konverter og formater datoen
10 return date($formatString, $timestamp);
11}
12
13// Eksempel på brug
14$timestamp = 1609459200; // 1. januar 2021 00:00:00 UTC
15echo convertUnixTimestamp($timestamp, false) . "\n"; // 24-timers format
16echo convertUnixTimestamp($timestamp, true) . "\n"; // 12-timers format
17?>
181// Java tidsstempel konvertering
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 // Konverter Unix tidsstempel til Instant, derefter til LocalDateTime
10 Instant instant = Instant.ofEpochSecond(timestamp);
11 LocalDateTime dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
12
13 // Opret formatter baseret på ønsket 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 // Formater datoen
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-timers format
25 System.out.println(convertUnixTimestamp(timestamp, true)); // 12-timers format
26 }
27}
281// C# tidsstempel konvertering
2using System;
3
4class UnixTimestampConverter
5{
6 public static string ConvertUnixTimestamp(long timestamp, bool use12Hour)
7 {
8 // Konverter Unix tidsstempel til DateTime
9 // Unix tidsstempel er sekunder siden 1970-01-01
10 DateTime dateTime = DateTimeOffset.FromUnixTimeSeconds(timestamp).DateTime;
11
12 // Formateringsstreng baseret på 12-timers eller 24-timers præference
13 string formatString = use12Hour
14 ? "dddd, MMMM d, yyyy h:mm:ss tt" // 12-timers format med AM/PM
15 : "dddd, MMMM d, yyyy HH:mm:ss"; // 24-timers format
16
17 // Returner formateret dato streng
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-timers format
25 Console.WriteLine(ConvertUnixTimestamp(timestamp, true)); // 12-timers format
26 }
27}
281# Ruby tidsstempel konvertering
2require 'time'
3
4def convert_unix_timestamp(timestamp, use_12hour = false)
5 # Konverter Unix tidsstempel til Time objekt
6 time = Time.at(timestamp)
7
8 # Formater baseret på 12-timers eller 24-timers præference
9 if use_12hour
10 time.strftime("%A, %B %d, %Y %I:%M:%S %p") # 12-timers format med AM/PM
11 else
12 time.strftime("%A, %B %d, %Y %H:%M:%S") # 24-timers format
13 end
14end
15
16# Eksempel på brug
17timestamp = 1609459200 # 1. januar 2021 00:00:00 UTC
18puts convert_unix_timestamp(timestamp, false) # 24-timers format
19puts convert_unix_timestamp(timestamp, true) # 12-timers format
201// Go tidsstempel konvertering
2package main
3
4import (
5 "fmt"
6 "time"
7)
8
9func convertUnixTimestamp(timestamp int64, use12Hour bool) string {
10 // Konverter Unix tidsstempel til Time
11 t := time.Unix(timestamp, 0)
12
13 // Formateringsstreng baseret på 12-timers eller 24-timers præference
14 formatString := "Monday, January 2, 2006 "
15 if use12Hour {
16 formatString += "3:04:05 PM" // 12-timers format med AM/PM
17 } else {
18 formatString += "15:04:05" // 24-timers format
19 }
20
21 // Returner formateret tid
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-timers format
28 fmt.Println(convertUnixTimestamp(timestamp, true)) // 12-timers format
29}
301// Swift tidsstempel konvertering
2import Foundation
3
4func convertUnixTimestamp(_ timestamp: Int, use12Hour: Bool) -> String {
5 // Opret Date fra Unix tidsstempel
6 let date = Date(timeIntervalSince1970: TimeInterval(timestamp))
7
8 // Opret DateFormatter
9 let formatter = DateFormatter()
10 formatter.dateStyle = .full
11
12 // Indstil tidsstil baseret på 12-timers eller 24-timers præference
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 // Returner formateret dato
23 return formatter.string(from: date)
24}
25
26// Eksempel på brug
27let timestamp = 1609459200 // 1. januar 2021 00:00:00 UTC
28print(convertUnixTimestamp(timestamp, use12Hour: false)) // 24-timers format
29print(convertUnixTimestamp(timestamp, use12Hour: true)) // 12-timers format
301# R tidsstempel konvertering
2convert_unix_timestamp <- function(timestamp, use_12hour = FALSE) {
3 # Konverter Unix tidsstempel til POSIXct datetime
4 date_time <- as.POSIXct(timestamp, origin = "1970-01-01", tz = "UTC")
5
6 # Formater baseret på 12-timers eller 24-timers præference
7 if (use_12hour) {
8 format_string <- "%A, %B %d, %Y %I:%M:%S %p" # 12-timers format med AM/PM
9 } else {
10 format_string <- "%A, %B %d, %Y %H:%M:%S" # 24-timers format
11 }
12
13 # Returner formateret dato streng
14 format(date_time, format_string)
15}
16
17# Eksempel på brug
18timestamp <- 1609459200 # 1. januar 2021 00:00:00 UTC
19cat(convert_unix_timestamp(timestamp, FALSE), "\n") # 24-timers format
20cat(convert_unix_timestamp(timestamp, TRUE), "\n") # 12-timers format
211% MATLAB tidsstempel konvertering
2function formattedDate = convertUnixTimestamp(timestamp, use12Hour)
3 % Konverter Unix tidsstempel til MATLAB datetime
4 % MATLAB datoer er dage siden 1900-01-01, med 1 = 1900-01-01
5 % Unix tidsstempler er sekunder siden 1970-01-01
6
7 % Først konverter til Excel datoformat
8 % 25569 er antallet af dage mellem 1900-01-01 og 1970-01-01
9 excelDate = (timestamp / 86400) + 25569;
10
11 % Formater datoen baseret på 12-timers eller 24-timers præference
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% Eksempel på brug
20timestamp = 1609459200; % 1. januar 2021 00:00:00 UTC
21disp(convertUnixTimestamp(timestamp, false)) % 24-timers format
22disp(convertUnixTimestamp(timestamp, true)) % 12-timers format
231' Excel VBA tidsstempel konvertering
2Function ConvertUnixTimestamp(timestamp As Long, Optional use12Hour As Boolean = False) As String
3 ' Konverter Unix tidsstempel til Excel dato/tid
4 ' Excel datoer er dage siden 1900-01-01, med 1 = 1900-01-01
5 ' Unix tidsstempler er sekunder siden 1970-01-01
6
7 ' Først konverter til Excel dato format
8 ' 25569 er antallet af dage mellem 1900-01-01 og 1970-01-01
9 Dim excelDate As Double
10 excelDate = (timestamp / 86400) + 25569
11
12 ' Formater datoen baseret på 12-timers eller 24-timers præference
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' Brug i et regneark:
21' =ConvertUnixTimestamp(1609459200, TRUE) ' 12-timers format
22' =ConvertUnixTimestamp(1609459200, FALSE) ' 24-timers format
23Håndtering af Grænsetilfælde
Når man arbejder med Unix tidsstempler, er det vigtigt at håndtere grænsetilfælde korrekt. Her er eksempler på håndtering af nogle almindelige grænsetilfælde:
1// JavaScript grænsetilfælde håndtering
2function safeConvertTimestamp(timestamp, use12Hour = false) {
3 // Tjek om tidsstemplet er gyldigt
4 if (timestamp === undefined || timestamp === null || isNaN(timestamp)) {
5 return "Ugyldigt tidsstempel";
6 }
7
8 // Tjek for negative tidsstempler (datoer før 1970)
9 if (timestamp < 0) {
10 // Nogle browsere håndterer muligvis ikke negative tidsstempler korrekt
11 // Brug en mere robust tilgang til datoer før 1970
12 const date = new Date(timestamp * 1000);
13 if (isNaN(date.getTime())) {
14 return "Ugyldig dato (før 1970)";
15 }
16 }
17
18 // Tjek for Y2K38 problem (for 32-bit systemer)
19 const maxInt32 = 2147483647; // Maksimal værdi for 32-bit signeret heltal
20 if (timestamp > maxInt32) {
21 // Overvej at bruge BigInt til meget store tidsstempler i moderne JavaScript
22 console.warn("Tidsstempel overskrider 32-bit heltalsgrænsen (Y2K38 problem)");
23 }
24
25 // Fortsæt med normal konvertering
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 "Fejl ved konvertering af tidsstempel: " + error.message;
41 }
42}
43Referencer
-
"Unix Tid." Wikipedia, Wikimedia Foundation, https://en.wikipedia.org/wiki/Unix_time
-
"År 2038 Problemet." Wikipedia, Wikimedia Foundation, https://en.wikipedia.org/wiki/Year_2038_problem
-
Olson, Arthur David. "The Complexities of Calendrical Time." The Open Group, https://www.usenix.org/legacy/events/usenix01/full_papers/olson/olson.pdf
-
"ISO 8601." Wikipedia, Wikimedia Foundation, https://en.wikipedia.org/wiki/ISO_8601
-
"RFC 3339: Dato og Tid på Internettet: Tidsstempler." Internet Engineering Task Force (IETF), https://tools.ietf.org/html/rfc3339
-
Kernighan, Brian W., og Dennis M. Ritchie. "The C Programming Language." Prentice Hall, 1988.
Feedback
Klik på feedback-toasten for at begynde at give feedback om dette værktøj.
Relaterede Værktøjer
Opdag flere værktøjer, der måske kan være nyttige for din arbejdsgang.