Unix-tidsstempel til datokonverter: Støtte for 12/24-timers format
Konverter Unix-tidsstempler til menneskelig lesbare datoer og tider. Velg mellom 12-timers og 24-timers tidsformater med dette enkle, brukervennlige konverteringsverktøyet.
Unix Tidsstempel Konverter
Konvertert Dato & Tid
Dokumentasjon
Unix Tidsstempel Konverter
Introduksjon
Et Unix tidsstempel (også kjent som POSIX-tid eller Epoch-tid) er et system for å beskrive et tidspunkt. Det er antall sekunder som har gått siden 1. januar 1970 (midnatt UTC/GMT), uten å ta hensyn til skuddsekunder. Unix tidsstempler er mye brukt i datasystemer og programmeringsspråk, da de gir en kompakt, språk-uavhengig representasjon av et spesifikt øyeblikk i tid.
Denne konverteren lar deg transformere et Unix tidsstempel til et menneskelig lesbart dato- og tidsformat. Den støtter både 12-timers (AM/PM) og 24-timers tidsformater for å imøtekomme forskjellige regionale og personlige preferanser.
Hvordan Unix Tidsstempler Fungerer
Unix tidsstempler beregnes som antall sekunder siden Unix Epoch (1. januar 1970, 00:00:00 UTC). Dette gjør dem spesielt nyttige for å beregne tidsforskjeller og for å lagre datoer i et kompakt format.
Den matematiske konverteringen fra et Unix tidsstempel til en kalenderdato involverer flere trinn:
- Start med Unix Epoch (1. januar 1970, 00:00:00 UTC)
- Legg til antall sekunder i tidsstempelet
- Ta hensyn til skuddår, varierende månedslengder og andre kalenderkompleksiteter
- Bruk tidssonejusteringer om nødvendig
For eksempel representerer Unix tidsstempelet 1609459200 fredag 1. januar 2021, 00:00:00 UTC.
Konverteringsformelen kan uttrykkes som:
De fleste programmeringsspråk og operativsystemer har innebygde funksjoner for å håndtere denne konverteringen, og abstraherer bort de komplekse kalenderberegningene.
Tidsformatalternativer
Denne konverteren tilbyr to tidsformatalternativer:
-
24-timers format (noen ganger kalt "militærtid"): Timer varierer fra 0 til 23, og det er ingen AM/PM-betegnelse. For eksempel, 15:00 representeres som 15:00.
-
12-timers format: Timer varierer fra 1 til 12, med AM (ante meridiem) for tider fra midnatt til middag, og PM (post meridiem) for tider fra middag til midnatt. For eksempel, 15:00 i 24-timers format representeres som 3:00 PM.
Valget mellom disse formatene er stort sett et spørsmål om regional konvensjon og personlig preferanse:
- 24-timers format brukes vanligvis i de fleste av Europa, Latin-Amerika og Asia, samt i vitenskapelige, militære og medisinske sammenhenger over hele verden.
- 12-timers format er utbredt i USA, Canada, Australia og noen andre engelsktalende land for daglig bruk.
Grenseverdier og Begrensninger
Når man arbeider med Unix tidsstempler, er det viktig å være oppmerksom på flere grenseverdier og begrensninger:
-
Negative tidsstempler: Disse representerer datoer før Unix Epoch (1. januar 1970). Selv om de er matematiske gyldige, kan noen systemer håndtere negative tidsstempler feilaktig.
-
År 2038 Problemet: Unix tidsstempler lagres ofte som 32-bits signerte heltall, som vil overflyte 19. januar 2038. Etter dette punktet vil 32-bits systemer ikke kunne representere tid riktig med mindre de modifiseres for å bruke en større heltallstype.
-
Ekstremt store tidsstempler: Svært fjerne fremtidige datoer kan ikke være representerbare i noen systemer, eller kan håndteres inkonsekvent.
-
Skuddsekunder: Unix tid tar ikke hensyn til skuddsekunder, som noen ganger legges til UTC for å kompensere for Jordens uregelmessige rotasjon. Dette betyr at Unix tid ikke er presist synkronisert med astronomisk tid.
-
Tidssonehensyn: Unix tidsstempler representerer øyeblikk i UTC. Konvertering til lokal tid krever ytterligere tidssoneinformasjon.
-
Sommertid: Når man konverterer tidsstempler til lokal tid, må kompleksiteten ved overganger til sommertid vurderes.
Bruksområder
Unix tidsstempler brukes i mange applikasjoner innen databehandling og databehandling:
-
Databaseposter: Tidsstempler brukes ofte til å registrere når oppføringer ble opprettet eller endret.
-
Webutvikling: HTTP-hoder, informasjonskapsler og hurtigbuffer-mekanismer bruker ofte Unix tidsstempler.
-
Loggfiler: Systemlogger registrerer vanligvis hendelser med Unix tidsstempler for presis kronologisk rekkefølge.
-
Versjonskontrollsystemer: Git og andre VCS bruker tidsstempler for å registrere når forpliktelser ble gjort.
-
API-responser: Mange web-API-er inkluderer tidsstempler i sine svar for å indikere når data ble generert eller når ressurser sist ble endret.
-
Filsystemer: Filopprettings- og endringstider lagres ofte som Unix tidsstempler.
-
Sesjonsadministrasjon: Webapplikasjoner bruker tidsstempler for å bestemme når brukersesjoner skal utløpe.
-
Dataanalyse: Tidsstempler gir en standardisert måte å arbeide med tidsdata i analyseapplikasjoner.
Alternativer
Selv om Unix tidsstempler er mye brukt, finnes det alternative tidsrepresentasjonsformater som kan være mer passende i visse sammenhenger:
-
ISO 8601: Et standardisert strengformat (f.eks. "2021-01-01T00:00:00Z") som er menneskelig lesbart samtidig som det opprettholder sortering. Det er ofte foretrukket for datautveksling og brukerrettede applikasjoner.
-
RFC 3339: En profil av ISO 8601 brukt i internettprotokoller, med strengere formateringskrav.
-
Menneskelig lesbare formater: Lokaliserte datostrenger (f.eks. "1. januar 2021") er mer passende for direkte brukerinteraksjon, men er mindre egnet for beregning.
-
Microsoft FILETIME: En 64-bits verdi som representerer antall 100-nanosekundintervaller siden 1. januar 1601, brukt i Windows-systemer.
-
Julian Day Number: Brukt i astronomi og noen vitenskapelige applikasjoner, teller dager siden 1. januar 4713 f.Kr.
Valget av tidsformat avhenger av faktorer som:
- Nødvendig presisjon
- Behov for menneskelig lesbarhet
- Lagringsbegrensninger
- Kompatibilitet med eksisterende systemer
- Omfanget av datoer som må representeres
Historie
Konseptet med Unix tid oppstod med utviklingen av Unix-operativsystemet ved Bell Labs på slutten av 1960-tallet og tidlig på 1970-tallet. Beslutningen om å bruke 1. januar 1970 som epoke var noe vilkårlig, men praktisk for tiden – det var nylig nok til å minimere lagringsbehovene for datoer av interesse, men langt nok tilbake for å være nyttig for historiske data.
Den opprinnelige implementeringen brukte et 32-bits signert heltall for å lagre antall sekunder, noe som var tilstrekkelig for den forventede levetiden til Unix-systemer på den tiden. Imidlertid førte denne beslutningen til År 2038 Problemet (noen ganger kalt "Y2K38" eller "Unix Millennium Bug"), ettersom 32-bits signerte heltall bare kan representere datoer opp til 19. januar 2038 (03:14:07 UTC).
Etter hvert som Unix og Unix-liknende operativsystemer fikk popularitet, ble Unix tidsstempel en de facto standard for å representere tid i databehandling. Det ble vedtatt av mange programmeringsspråk, databaser og applikasjoner, og utvidet langt utover sitt opprinnelige Unix-miljø.
Moderne systemer bruker i økende grad 64-bits heltall for tidsstempler, noe som utvider den representerbare rekkevidden til omtrent 292 milliarder år i begge retninger fra epoken, noe som effektivt løser År 2038 Problemet. Imidlertid kan eldre systemer og applikasjoner fortsatt være sårbare.
Unix tidsstempelens enkelhet og nytte har sikret dens fortsatte relevans til tross for utviklingen av mer sofistikerte tidsrepresentasjonsformater. Det forblir et grunnleggende konsept innen databehandling, som ligger til grunn for mye av vår digitale infrastruktur.
Kodeeksempler
Her er eksempler på hvordan man kan konvertere Unix tidsstempler til menneskelig lesbare datoer i ulike programmeringsspråk:
1// JavaScript tidsstempel konvertering
2function convertUnixTimestamp(timestamp, use12Hour = false) {
3 // Opprett et nytt Date-objekt (JavaScript bruker millisekunder)
4 const date = new Date(timestamp * 1000);
5
6 // Formatalternativer
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 hjelp av lokal formatering
19 return date.toLocaleString(undefined, options);
20}
21
22// Eksempel på bruk
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 # Format 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å bruk
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 // Formatstreng
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å bruk
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, deretter til LocalDateTime
10 Instant instant = Instant.ofEpochSecond(timestamp);
11 LocalDateTime dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
12
13 // Opprett formatter basert 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 // Formatstreng basert på 12-timers eller 24-timers preferanse
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 formatert 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 # Format basert på 12-timers eller 24-timers preferanse
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å bruk
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 // Formatstreng basert på 12-timers eller 24-timers preferanse
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 formatert 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 // Opprett Date fra Unix tidsstempel
6 let date = Date(timeIntervalSince1970: TimeInterval(timestamp))
7
8 // Opprett DateFormatter
9 let formatter = DateFormatter()
10 formatter.dateStyle = .full
11
12 // Sett tidsstil basert på 12-timers eller 24-timers preferanse
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 formatert dato
23 return formatter.string(from: date)
24}
25
26// Eksempel på bruk
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 # Format basert på 12-timers eller 24-timers preferanse
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 formatert dato-streng
14 format(date_time, format_string)
15}
16
17# Eksempel på bruk
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 dager siden 1900-01-01, med 1 = 1900-01-01
5 % Unix tidsstempel er sekunder siden 1970-01-01
6
7 % Først konverter til Excel datoformat
8 % 25569 er antall dager mellom 1900-01-01 og 1970-01-01
9 excelDate = (timestamp / 86400) + 25569;
10
11 % Formatere dato basert på 12-timers eller 24-timers preferanse
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å bruk
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 dager siden 1900-01-01, med 1 = 1900-01-01
5 ' Unix tidsstempel er sekunder siden 1970-01-01
6
7 ' Først konverter til Excel datoformat
8 ' 25569 er antall dager mellom 1900-01-01 og 1970-01-01
9 Dim excelDate As Double
10 excelDate = (timestamp / 86400) + 25569
11
12 ' Formatere dato basert på 12-timers eller 24-timers preferanse
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' Bruk i et regneark:
21' =ConvertUnixTimestamp(1609459200, TRUE) ' 12-timers format
22' =ConvertUnixTimestamp(1609459200, FALSE) ' 24-timers format
23Håndtering av Grenseverdier
Når man arbeider med Unix tidsstempler, er det viktig å håndtere grenseverdier riktig. Her er eksempler på håndtering av noen vanlige grenseverdier:
1// JavaScript grenseverdi håndtering
2function safeConvertTimestamp(timestamp, use12Hour = false) {
3 // Sjekk om tidsstempelet er gyldig
4 if (timestamp === undefined || timestamp === null || isNaN(timestamp)) {
5 return "Ugyldig tidsstempel";
6 }
7
8 // Sjekk for negative tidsstempler (datoer før 1970)
9 if (timestamp < 0) {
10 // Noen nettlesere kan håndtere negative tidsstempler feilaktig
11 // Bruk en mer robust tilnærming for 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 // Sjekk for Y2K38-problemet (for 32-bits systemer)
19 const maxInt32 = 2147483647; // Maksimal verdi for 32-bits signert heltall
20 if (timestamp > maxInt32) {
21 // Vurder å bruke BigInt for svært store tidsstempler i moderne JavaScript
22 console.warn("Tidsstempelet overskrider 32-bits heltallsgrensen (Y2K38-problem)");
23 }
24
25 // Fortsett 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 "Feil ved konvertering av tidsstempel: " + error.message;
41 }
42}
43Referanser
-
"Unix Time." 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: Date and Time on the Internet: Timestamps." 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.
Tilbakemelding
Klikk på tilbakemeldings-toasten for å begynne å gi tilbakemelding om dette verktøyet
Relaterte verktøy
Oppdag flere verktøy som kan være nyttige for arbeidsflyten din