Unix-tidsstämpel till datumkonverterare: Stöd för 12/24-timmarsformat
Konvertera Unix-tidsstämplar till mänskligt läsbara datum och tider. Välj mellan 12-timmars och 24-timmars tidsformat med detta enkla, användarvänliga konverteringsverktyg.
Unix Tidsstämpel Konverterare
Konverterad Datum & Tid
Dokumentation
Unix Timestamp Converter
Introduktion
En Unix-tidsstämpel (även känd som POSIX-tid eller Epoch-tid) är ett system för att beskriva en tidpunkt. Det är antalet sekunder som har förflutit sedan den 1 januari 1970 (midnatt UTC/GMT), utan att räkna med skottsekunder. Unix-tidsstämplar används i stor utsträckning i datorsystem och programmeringsspråk eftersom de ger en kompakt, språkoberoende representation av ett specifikt ögonblick i tiden.
Denna omvandlare gör det möjligt för dig att omvandla en Unix-tidsstämpel till ett människoläsbart datum- och tidsformat. Den stöder både 12-timmars (AM/PM) och 24-timmars tidsformat för att tillgodose olika regionala och personliga preferenser.
Hur Unix-tidsstämplar fungerar
Unix-tidsstämplar beräknas som antalet sekunder sedan Unix Epoch (1 januari 1970, 00:00:00 UTC). Detta gör dem särskilt användbara för att beräkna tidsdifferenser och för att lagra datum i ett kompakt format.
Den matematiska omvandlingen från en Unix-tidsstämpel till ett kalenderdatum involverar flera steg:
- Börja med Unix Epoch (1 januari 1970, 00:00:00 UTC)
- Lägg till antalet sekunder i tidsstämpeln
- Ta hänsyn till skottår, varierande månadslängder och andra kalenderkomplexiteter
- Tillämpa tidszonsjusteringar om det behövs
Till exempel representerar Unix-tidsstämpeln 1609459200 fredagen den 1 januari 2021, 00:00:00 UTC.
Omvandlingsformeln kan uttryckas som:
De flesta programmeringsspråk och operativsystem tillhandahåller inbyggda funktioner för att hantera denna omvandling, vilket döljer de komplexa kalenderberäkningarna.
Tidsformatalternativ
Denna omvandlare erbjuder två tidsformatalternativ:
-
24-timmarsformat (ibland kallat "militär tid"): Timmarna sträcker sig från 0 till 23, och det finns ingen AM/PM-beteckning. Till exempel representeras 15:00 som 15:00.
-
12-timmarsformat: Timmarna sträcker sig från 1 till 12, med AM (ante meridiem) för tider från midnatt till middag, och PM (post meridiem) för tider från middag till midnatt. Till exempel representeras 15:00 i 24-timmarsformat som 3:00 PM.
Valet mellan dessa format är i stor utsträckning en fråga om regional konvention och personlig preferens:
- 24-timmarsformatet används vanligtvis i de flesta av Europa, Latinamerika och Asien, samt i vetenskapliga, militära och medicinska sammanhang världen över.
- 12-timmarsformatet är utbrett i USA, Kanada, Australien och några andra engelsktalande länder för vardagligt bruk.
Gränsfall och begränsningar
När man arbetar med Unix-tidsstämplar är det viktigt att vara medveten om flera gränsfall och begränsningar:
-
Negativa tidsstämplar: Dessa representerar datum före Unix Epoch (1 januari 1970). Även om de är matematiskt giltiga, kanske vissa system inte hanterar negativa tidsstämplar korrekt.
-
År 2038-problemet: Unix-tidsstämplar lagras ofta som 32-bitars signerade heltal, vilket kommer att överflöda den 19 januari 2038. Efter denna tidpunkt kommer 32-bitars system att vara oförmögna att representera tider korrekt om de inte modifieras för att använda en större heltalstyp.
-
Extremt stora tidsstämplar: Mycket långt in i framtiden kan datum kanske inte representeras i vissa system, eller kan hanteras inkonsekvent.
-
Skottsekunder: Unix-tid tar inte hänsyn till skottsekunder, som ibland läggs till UTC för att kompensera för jordens oregelbundna rotation. Detta innebär att Unix-tid inte är exakt synkroniserad med astronomisk tid.
-
Tidszonsöverväganden: Unix-tidsstämplar representerar ögonblick i UTC. Omvandling till lokal tid kräver ytterligare tidszonsinformation.
-
Sommartid: Vid omvandling av tidsstämplar till lokal tid måste komplexiteten i övergångar till sommartid beaktas.
Användningsområden
Unix-tidsstämplar används i många applikationer inom databehandling och datamanagement:
-
Databasposter: Tidsstämplar används ofta för att registrera när poster skapades eller ändrades.
-
Webbutveckling: HTTP-huvuden, cookies och cache-mekanismer använder ofta Unix-tidsstämplar.
-
Loggfiler: Systemloggar registrerar vanligtvis händelser med Unix-tidsstämplar för exakt kronologisk ordning.
-
Versionshanteringssystem: Git och andra VCS använder tidsstämplar för att registrera när åtaganden gjordes.
-
API-svar: Många webb-API:er inkluderar tidsstämplar i sina svar för att ange när data genererades eller när resurser senast ändrades.
-
Filsystem: Filskapande och ändringstider lagras ofta som Unix-tidsstämplar.
-
Sessionshantering: Webbapplikationer använder tidsstämplar för att avgöra när användarsessioner ska löpa ut.
-
Dataanalys: Tidsstämplar ger ett standardiserat sätt att arbeta med tidsdata i analysapplikationer.
Alternativ
Även om Unix-tidsstämplar är allmänt använda, finns det alternativa tidsrepresentationsformat som kan vara mer lämpliga i vissa sammanhang:
-
ISO 8601: Ett standardiserat strängformat (t.ex. "2021-01-01T00:00:00Z") som är människoläsbart samtidigt som det bibehåller sorteringsbarhet. Det föredras ofta för datautbyte och användarorienterade applikationer.
-
RFC 3339: En profil av ISO 8601 som används i internetprotokoll, med strängare formateringskrav.
-
Människoläsbara format: Lokaliserade datumsträngar (t.ex. "1 januari 2021") är mer lämpliga för direkt användarinteraktion men är mindre lämpliga för beräkning.
-
Microsoft FILETIME: Ett 64-bitars värde som representerar antalet 100-nanosekundsintervall sedan den 1 januari 1601, som används i Windows-system.
-
Julianska dagnumret: Används inom astronomi och vissa vetenskapliga tillämpningar, räknar dagar sedan den 1 januari 4713 f.Kr.
Valet av tidsformat beror på faktorer som:
- Krävd precision
- Behov av människoläsbarhet
- Lagringsbegränsningar
- Kompatibilitet med befintliga system
- Omfånget av datum som behöver representeras
Historia
Konceptet med Unix-tid härstammar från utvecklingen av Unix-operativsystemet vid Bell Labs i slutet av 1960-talet och början av 1970-talet. Beslutet att använda den 1 januari 1970 som epoch var något godtyckligt men praktiskt för tiden—det var tillräckligt nära för att minimera lagringskraven för intressanta datum men tillräckligt långt tillbaka för att vara användbart för historiska data.
Den ursprungliga implementeringen använde ett 32-bitars signerade heltal för att lagra antalet sekunder, vilket var tillräckligt för den förväntade livslängden för Unix-system vid den tiden. Emellertid ledde detta beslut till År 2038-problemet (ibland kallat "Y2K38" eller "Unix Millennium Bug"), eftersom 32-bitars signerade heltal endast kan representera datum fram till den 19 januari 2038 (03:14:07 UTC).
När Unix och Unix-liknande operativsystem blev populära blev Unix-tidsstämpeln en de facto-standard för att representera tid inom databehandling. Den antogs av många programmeringsspråk, databaser och applikationer, vilket sträckte sig långt bortom dess ursprungliga Unix-miljö.
Moderna system använder alltmer 64-bitars heltal för tidsstämplar, vilket utökar det representerbara omfånget till cirka 292 miljarder år i båda riktningarna från epoch, vilket effektivt löser År 2038-problemet. Ändå kan äldre system och applikationer fortfarande vara sårbara.
Unix-tidsstämpelns enkelhet och nytta har säkerställt dess fortsatta relevans trots utvecklingen av mer sofistikerade tidsrepresentationsformat. Det förblir ett grundläggande koncept inom databehandling, som ligger till grund för mycket av vår digitala infrastruktur.
Kodexempel
Här är exempel på hur man konverterar Unix-tidsstämplar till människoläsbara datum i olika programmeringsspråk:
1// JavaScript tidsstämpelomvandling
2function convertUnixTimestamp(timestamp, use12Hour = false) {
3 // Skapa ett nytt Date-objekt (JavaScript använder millisekunder)
4 const date = new Date(timestamp * 1000);
5
6 // Formateringsalternativ
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 // Omvandla till sträng med hjälp av lokal formatering
19 return date.toLocaleString(undefined, options);
20}
21
22// Exempelanvändning
23const timestamp = 1609459200; // 1 januari 2021 00:00:00 UTC
24console.log(convertUnixTimestamp(timestamp, false)); // 24-timmarsformat
25console.log(convertUnixTimestamp(timestamp, true)); // 12-timmarsformat
261# Python tidsstämpelomvandling
2import datetime
3
4def convert_unix_timestamp(timestamp, use_12hour=False):
5 # Konvertera Unix-tidsstämpel till datetime-objekt
6 date = datetime.datetime.fromtimestamp(timestamp)
7
8 # Formatera datumsträngen
9 if use_12hour:
10 format_string = "%A, %B %d, %Y %I:%M:%S %p" # 12-timmarsformat med AM/PM
11 else:
12 format_string = "%A, %B %d, %Y %H:%M:%S" # 24-timmarsformat
13
14 return date.strftime(format_string)
15
16# Exempelanvändning
17timestamp = 1609459200 # 1 januari 2021 00:00:00 UTC
18print(convert_unix_timestamp(timestamp, False)) # 24-timmarsformat
19print(convert_unix_timestamp(timestamp, True)) # 12-timmarsformat
201<?php
2// PHP tidsstämpelomvandling
3function convertUnixTimestamp($timestamp, $use12Hour = false) {
4 // Formateringssträng
5 $formatString = $use12Hour
6 ? 'l, F j, Y g:i:s A' // 12-timmarsformat med AM/PM
7 : 'l, F j, Y H:i:s'; // 24-timmarsformat
8
9 // Konvertera och formatera datumet
10 return date($formatString, $timestamp);
11}
12
13// Exempelanvändning
14$timestamp = 1609459200; // 1 januari 2021 00:00:00 UTC
15echo convertUnixTimestamp($timestamp, false) . "\n"; // 24-timmarsformat
16echo convertUnixTimestamp($timestamp, true) . "\n"; // 12-timmarsformat
17?>
181// Java tidsstämpelomvandling
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 // Konvertera Unix-tidsstämpel till Instant, sedan till LocalDateTime
10 Instant instant = Instant.ofEpochSecond(timestamp);
11 LocalDateTime dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
12
13 // Skapa formatterare baserat på önskat 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 // Formatera datumet
19 return dateTime.format(formatter);
20 }
21
22 public static void main(String[] args) {
23 long timestamp = 1609459200; // 1 januari 2021 00:00:00 UTC
24 System.out.println(convertUnixTimestamp(timestamp, false)); // 24-timmarsformat
25 System.out.println(convertUnixTimestamp(timestamp, true)); // 12-timmarsformat
26 }
27}
281// C# tidsstämpelomvandling
2using System;
3
4class UnixTimestampConverter
5{
6 public static string ConvertUnixTimestamp(long timestamp, bool use12Hour)
7 {
8 // Konvertera Unix-tidsstämpel till DateTime
9 // Unix-tidsstämpel är sekunder sedan 1970-01-01
10 DateTime dateTime = DateTimeOffset.FromUnixTimeSeconds(timestamp).DateTime;
11
12 // Formateringssträng baserat på 12-timmars eller 24-timmars preferens
13 string formatString = use12Hour
14 ? "dddd, MMMM d, yyyy h:mm:ss tt" // 12-timmarsformat med AM/PM
15 : "dddd, MMMM d, yyyy HH:mm:ss"; // 24-timmarsformat
16
17 // Returnera formaterad datumsträng
18 return dateTime.ToString(formatString);
19 }
20
21 static void Main()
22 {
23 long timestamp = 1609459200; // 1 januari 2021 00:00:00 UTC
24 Console.WriteLine(ConvertUnixTimestamp(timestamp, false)); // 24-timmarsformat
25 Console.WriteLine(ConvertUnixTimestamp(timestamp, true)); // 12-timmarsformat
26 }
27}
281# Ruby tidsstämpelomvandling
2require 'time'
3
4def convert_unix_timestamp(timestamp, use_12hour = false)
5 # Konvertera Unix-tidsstämpel till Time-objekt
6 time = Time.at(timestamp)
7
8 # Formatera baserat på 12-timmars eller 24-timmars preferens
9 if use_12hour
10 time.strftime("%A, %B %d, %Y %I:%M:%S %p") # 12-timmarsformat med AM/PM
11 else
12 time.strftime("%A, %B %d, %Y %H:%M:%S") # 24-timmarsformat
13 end
14end
15
16# Exempelanvändning
17timestamp = 1609459200 # 1 januari 2021 00:00:00 UTC
18puts convert_unix_timestamp(timestamp, false) # 24-timmarsformat
19puts convert_unix_timestamp(timestamp, true) # 12-timmarsformat
201// Go tidsstämpelomvandling
2package main
3
4import (
5 "fmt"
6 "time"
7)
8
9func convertUnixTimestamp(timestamp int64, use12Hour bool) string {
10 // Konvertera Unix-tidsstämpel till Time
11 t := time.Unix(timestamp, 0)
12
13 // Formateringssträng baserat på 12-timmars eller 24-timmars preferens
14 formatString := "Monday, January 2, 2006 "
15 if use12Hour {
16 formatString += "3:04:05 PM" // 12-timmarsformat med AM/PM
17 } else {
18 formatString += "15:04:05" // 24-timmarsformat
19 }
20
21 // Returnera formaterad tid
22 return t.Format(formatString)
23}
24
25func main() {
26 timestamp := int64(1609459200) // 1 januari 2021 00:00:00 UTC
27 fmt.Println(convertUnixTimestamp(timestamp, false)) // 24-timmarsformat
28 fmt.Println(convertUnixTimestamp(timestamp, true)) // 12-timmarsformat
29}
301// Swift tidsstämpelomvandling
2import Foundation
3
4func convertUnixTimestamp(_ timestamp: Int, use12Hour: Bool) -> String {
5 // Skapa Date från Unix-tidsstämpel
6 let date = Date(timeIntervalSince1970: TimeInterval(timestamp))
7
8 // Skapa DateFormatter
9 let formatter = DateFormatter()
10 formatter.dateStyle = .full
11
12 // Ställ in tidsstil baserat på 12-timmars eller 24-timmars preferens
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 // Returnera formaterat datum
23 return formatter.string(from: date)
24}
25
26// Exempelanvändning
27let timestamp = 1609459200 // 1 januari 2021 00:00:00 UTC
28print(convertUnixTimestamp(timestamp, use12Hour: false)) // 24-timmarsformat
29print(convertUnixTimestamp(timestamp, use12Hour: true)) // 12-timmarsformat
301# R tidsstämpelomvandling
2convert_unix_timestamp <- function(timestamp, use_12hour = FALSE) {
3 # Konvertera Unix-tidsstämpel till POSIXct datetime
4 date_time <- as.POSIXct(timestamp, origin = "1970-01-01", tz = "UTC")
5
6 # Formatera baserat på 12-timmars eller 24-timmars preferens
7 if (use_12hour) {
8 format_string <- "%A, %B %d, %Y %I:%M:%S %p" # 12-timmarsformat med AM/PM
9 } else {
10 format_string <- "%A, %B %d, %Y %H:%M:%S" # 24-timmarsformat
11 }
12
13 # Returnera formaterad datumsträng
14 format(date_time, format_string)
15}
16
17# Exempelanvändning
18timestamp <- 1609459200 # 1 januari 2021 00:00:00 UTC
19cat(convert_unix_timestamp(timestamp, FALSE), "\n") # 24-timmarsformat
20cat(convert_unix_timestamp(timestamp, TRUE), "\n") # 12-timmarsformat
211% MATLAB tidsstämpelomvandling
2function formattedDate = convertUnixTimestamp(timestamp, use12Hour)
3 % Konvertera Unix-tidsstämpel till MATLAB datetime
4 % MATLAB-datum är dagar sedan 1900-01-01, med 1 = 1900-01-01
5 % Unix-tidsstämpel är sekunder sedan 1970-01-01
6
7 % Först konvertera till Excel datumformat
8 % 25569 är antalet dagar mellan 1900-01-01 och 1970-01-01
9 excelDate = (timestamp / 86400) + 25569;
10
11 % Formatera baserat på 12-timmars eller 24-timmars preferens
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% Exempelanvändning
20timestamp = 1609459200; % 1 januari 2021 00:00:00 UTC
21disp(convertUnixTimestamp(timestamp, false)) % 24-timmarsformat
22disp(convertUnixTimestamp(timestamp, true)) % 12-timmarsformat
231' Excel VBA tidsstämpelomvandling
2Function ConvertUnixTimestamp(timestamp As Long, Optional use12Hour As Boolean = False) As String
3 ' Konvertera Unix-tidsstämpel till Excel datum/tid
4 ' Excel-datum är dagar sedan 1900-01-01, med 1 = 1900-01-01
5 ' Unix-tidsstämpel är sekunder sedan 1970-01-01
6
7 ' Först konvertera till Excel datumformat
8 ' 25569 är antalet dagar mellan 1900-01-01 och 1970-01-01
9 Dim excelDate As Double
10 excelDate = (timestamp / 86400) + 25569
11
12 ' Formatera datum baserat på 12-timmars eller 24-timmars preferens
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' Användning i ett kalkylblad:
21' =ConvertUnixTimestamp(1609459200, TRUE) ' 12-timmarsformat
22' =ConvertUnixTimestamp(1609459200, FALSE) ' 24-timmarsformat
23Hantering av gränsfall
När man arbetar med Unix-tidsstämplar är det viktigt att hantera gränsfall korrekt. Här är exempel på hantering av några vanliga gränsfall:
1// JavaScript hantering av gränsfall
2function safeConvertTimestamp(timestamp, use12Hour = false) {
3 // Kontrollera om tidsstämpeln är giltig
4 if (timestamp === undefined || timestamp === null || isNaN(timestamp)) {
5 return "Ogiltig tidsstämpel";
6 }
7
8 // Kontrollera för negativa tidsstämplar (datum före 1970)
9 if (timestamp < 0) {
10 // Vissa webbläsare kanske inte hanterar negativa tidsstämplar korrekt
11 // Använd en mer robust metod för datum före 1970
12 const date = new Date(timestamp * 1000);
13 if (isNaN(date.getTime())) {
14 return "Ogiltigt datum (före 1970)";
15 }
16 }
17
18 // Kontrollera för Y2K38-problemet (för 32-bitars system)
19 const maxInt32 = 2147483647; // Maximalt värde för 32-bitars signerad heltal
20 if (timestamp > maxInt32) {
21 // Överväg att använda BigInt för mycket stora tidsstämplar i modern JavaScript
22 console.warn("Tidsstämpeln överskrider gränsen för 32-bitars heltal (Y2K38-problem)");
23 }
24
25 // Fortsätt med normal omvandling
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 "Fel vid omvandling av tidsstämpel: " + error.message;
41 }
42}
43Referenser
-
"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., och Dennis M. Ritchie. "The C Programming Language." Prentice Hall, 1988.
Återkoppling
Klicka på återkopplingsmeddelandet för att börja ge återkoppling om detta verktyg
Relaterade verktyg
Upptäck fler verktyg som kan vara användbara för ditt arbetsflöde