Pretvornik Unix časovnega žiga v datum: Podpora za 12/24-urni format
Pretvorite Unix časovne žige v datume in čase, ki jih je mogoče brati. Izberite med 12-urnim in 24-urnim časovnim formatom s tem preprostim, uporabniku prijaznim orodjem za pretvorbo.
Pretvornik Unix časovnega žiga
Pretvorjen datum in čas
Dokumentacija
Pretvornik Unix časovnega žiga
Uvod
Unix časovni žig (znan tudi kot POSIX čas ali Epoch čas) je sistem za opisovanje točke v času. To je število sekund, ki so minile od 1. januarja 1970 (polnoč UTC/GMT), brez upoštevanja prestopnih sekund. Unix časovni žigi se široko uporabljajo v računalniških sistemih in programskih jezikih, saj zagotavljajo kompaktno, jezikovno neodvisno predstavitev določenega trenutka v času.
Ta pretvornik vam omogoča, da spremenite Unix časovni žig v človeško berljivo obliko datuma in časa. Podpira tako 12-urni (AM/PM) kot 24-urni časovni format, da ustreza različnim regionalnim in osebnim preferencam.
Kako delujejo Unix časovni žigi
Unix časovni žigi se izračunajo kot število sekund od Unix Epoch (1. januar 1970, 00:00:00 UTC). To jih dela še posebej uporabne za izračun časovnih razlik in za shranjevanje datumov v kompaktni obliki.
Matematična pretvorba iz Unix časovnega žiga v koledarski datum vključuje več korakov:
- Začnite z Unix Epoch (1. januar 1970, 00:00:00 UTC)
- Dodajte število sekund v časovnem žigu
- Upoštevajte prestopne leta, različne dolžine mesecev in druge koledarske zapletenosti
- Uporabite prilagoditve časovnega pasu, če je potrebno
Na primer, Unix časovni žig 1609459200 predstavlja petek, 1. januar 2021, 00:00:00 UTC.
Pretvorbena formula se lahko izrazi kot:
Večina programskih jezikov in operacijskih sistemov ponuja vgrajene funkcije za obravnavo te pretvorbe, ki abstraktno obravnavajo kompleksne koledarske izračune.
Možnosti časovnega formata
Ta pretvornik ponuja dve možnosti časovnega formata:
-
24-urni format (včasih imenovan "vojaški čas"): Ure se gibljejo od 0 do 23, brez označbe AM/PM. Na primer, 15:00 je predstavljeno kot 15:00.
-
12-urni format: Ure se gibljejo od 1 do 12, z AM (ante meridiem) za čase od polnoči do poldneva, in PM (post meridiem) za čase od poldneva do polnoči. Na primer, 15:00 v 24-urnem formatu je predstavljeno kot 3:00 PM.
Izbira med tema formatoma je večinoma stvar regionalne konvencije in osebne preference:
- 24-urni format se pogosto uporablja v večini Evrope, Latinski Ameriki in Aziji, pa tudi v znanstvenih, vojaških in medicinskih kontekstih po vsem svetu.
- 12-urni format je razširjen v Združenih državah, Kanadi, Avstraliji in nekaterih drugih angleško govorečih državah za vsakodnevno uporabo.
Robne primere in omejitve
Pri delu z Unix časovnimi žigi je pomembno biti pozoren na več robnih primerov in omejitev:
-
Negativni časovni žigi: Ti predstavljajo datume pred Unix Epoch (1. januar 1970). Čeprav so matematično veljavni, nekateri sistemi morda ne obravnavajo negativnih časovnih žigov pravilno.
-
Problem leta 2038: Unix časovni žigi se pogosto shranjujejo kot 32-bitni celoštevilski podatki, kar bo povzročilo prelivanje 19. januarja 2038. Po tem datumu sistemi, ki uporabljajo 32-bitne podatke, ne bodo mogli pravilno predstavljati časov, razen če jih spremenijo, da uporabijo večjo celoštevilsko vrsto.
-
Zelo veliki časovni žigi: Zelo oddaljeni datumi morda ne bodo predstavljivi v nekaterih sistemih ali pa bodo obravnavani nekonsistentno.
-
Prestopne sekunde: Unix čas ne upošteva prestopnih sekund, ki se občasno dodajajo UTC, da bi nadomestile nepravilnosti v vrtenju Zemlje. To pomeni, da Unix čas ni natančno usklajen z astronomskim časom.
-
Upoštevanje časovnih pasov: Unix časovni žigi predstavljajo trenutke v UTC. Pretvorba v lokalni čas zahteva dodatne informacije o časovnem pasu.
-
Poletni čas: Pri pretvorbi časovnih žigov v lokalni čas je treba upoštevati kompleksnosti prehodov na poletni čas.
Uporabni primeri
Unix časovni žigi se uporabljajo v številnih aplikacijah v računalništvu in upravljanju podatkov:
-
Zapisniki podatkov: Časovni žigi se pogosto uporabljajo za beleženje, kdaj so bile vnose ustvarjene ali spremenjene.
-
Razvoj spletnih strani: HTTP glave, piškotki in mehanizmi predpomnjenja pogosto uporabljajo Unix časovne žige.
-
Dnevniški datoteke: Sistemski dnevniki običajno beležijo dogodke s časovnimi žigi Unix za natančno kronološko razvrščanje.
-
Sistemi za nadzor različic: Git in drugi VCS uporabljajo časovne žige za beleženje, kdaj so bile narejene zaveze.
-
Odgovori API-jev: Mnogi spletni API-ji vključujejo časovne žige v svojih odgovorih, da označijo, kdaj so bili podatki ustvarjeni ali kdaj so bile vire nazadnje spremenjene.
-
Datotečni sistemi: Časi ustvarjanja in sprememb datotek se pogosto shranjujejo kot Unix časovni žigi.
-
Upravljanje sej: Spletne aplikacije uporabljajo časovne žige za določitev, kdaj naj se uporabniške seje iztečejo.
-
Analiza podatkov: Časovni žigi zagotavljajo standardiziran način dela s časovnimi podatki v analitičnih aplikacijah.
Alternativen
Medtem ko so Unix časovni žigi široko uporabljeni, obstajajo alternativni formati predstavitve časa, ki so morda bolj primerni v določenih kontekstih:
-
ISO 8601: Standardizirana nizovna oblika (npr. "2021-01-01T00:00:00Z"), ki je človeško berljiva, hkrati pa ohranja možnost razvrščanja. Pogosto je prednostna za izmenjavo podatkov in uporabniške aplikacije.
-
RFC 3339: Profil ISO 8601, ki se uporablja v internetnih protokolih, z strožjimi zahtevami glede oblikovanja.
-
Človeško berljive oblike: Lokalizirani nizovi datumov (npr. "1. januar 2021") so bolj primerni za neposredno interakcijo z uporabniki, vendar so manj primerni za izračun.
-
Microsoft FILETIME: 64-bitna vrednost, ki predstavlja število 100-nanosekundnih intervalov od 1. januarja 1601, ki se uporablja v sistemih Windows.
-
Julijanski dan: Uporablja se v astronomiji in nekaterih znanstvenih aplikacijah, šteje dni od 1. januarja 4713 pr. n. št.
Izbira formata časa je odvisna od dejavnikov, kot so:
- Zahtevana natančnost
- Potrebe po človeški berljivosti
- Omejitve shranjevanja
- Združljivost z obstoječimi sistemi
- Obseg datumov, ki jih je treba predstaviti
Zgodovina
Koncept Unix časa se je pojavil z razvojem operacijskega sistema Unix v Bell Labs v poznih 1960-ih in zgodnjih 1970-ih. Odločitev za uporabo 1. januarja 1970 kot epohe je bila nekoliko naključna, vendar praktična za takrat - bila je dovolj nedavna, da bi zmanjšala potrebe po shranjevanju datumov, ki so bili zanimivi, vendar dovolj oddaljena v preteklosti, da bi bila uporabna za zgodovinske podatke.
Prvotna implementacija je uporabila 32-bitno celoštevilsko število za shranjevanje števila sekund, kar je bilo zadostno za pričakovano življenjsko dobo Unix sistemov tistega časa. Vendar je ta odločitev privedla do problema leta 2038 (včasih imenovanega "Y2K38" ali "Unix Millennium Bug"), saj 32-bitni celoštevilski podatki lahko predstavljajo le datume do 19. januarja 2038 (03:14:07 UTC).
Ko so Unix in Unix-podobni operacijski sistemi pridobili priljubljenost, je Unix časovni žig postal de facto standard za predstavitev časa v računalništvu. Sprejeli so ga številni programski jeziki, podatkovne baze in aplikacije, ki so se razširili daleč onkraj svojega prvotnega Unix okolja.
Sodobni sistemi vse bolj uporabljajo 64-bitne cele številke za časovne žige, kar podaljša predstavljivi obseg na približno 292 milijard let v obeh smereh od epohe, kar učinkovito rešuje problem leta 2038. Vendar so lahko dediščinski sistemi in aplikacije še vedno ranljive.
Enostavnost in uporabnost Unix časovnega žiga sta zagotovila njegovo nadaljnjo relevantnost kljub razvoju bolj sofisticiranih formatov predstavitve časa. Ostaja temeljni koncept v računalništvu, ki podpira veliko naše digitalne infrastrukture.
Kode Primeri
Tukaj so primeri, kako pretvoriti Unix časovne žige v človeško berljive datume v različnih programskih jezikih:
1// JavaScript pretvorba časovnega žiga
2function convertUnixTimestamp(timestamp, use12Hour = false) {
3 // Ustvari nov objekt Date (JavaScript uporablja milisekunde)
4 const date = new Date(timestamp * 1000);
5
6 // Možnosti oblikovanja
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 // Pretvori v niz z uporabo lokalnega oblikovanja
19 return date.toLocaleString(undefined, options);
20}
21
22// Primer uporabe
23const timestamp = 1609459200; // 1. januar 2021 00:00:00 UTC
24console.log(convertUnixTimestamp(timestamp, false)); // 24-urni format
25console.log(convertUnixTimestamp(timestamp, true)); // 12-urni format
261# Python pretvorba časovnega žiga
2import datetime
3
4def convert_unix_timestamp(timestamp, use_12hour=False):
5 # Pretvori Unix časovni žig v objekt datetime
6 date = datetime.datetime.fromtimestamp(timestamp)
7
8 # Oblikovanje niza datuma
9 if use_12hour:
10 format_string = "%A, %B %d, %Y %I:%M:%S %p" # 12-urni format z AM/PM
11 else:
12 format_string = "%A, %B %d, %Y %H:%M:%S" # 24-urni format
13
14 return date.strftime(format_string)
15
16# Primer uporabe
17timestamp = 1609459200 # 1. januar 2021 00:00:00 UTC
18print(convert_unix_timestamp(timestamp, False)) # 24-urni format
19print(convert_unix_timestamp(timestamp, True)) # 12-urni format
201<?php
2// PHP pretvorba časovnega žiga
3function convertUnixTimestamp($timestamp, $use12Hour = false) {
4 // Oblikovanje niza
5 $formatString = $use12Hour
6 ? 'l, F j, Y g:i:s A' // 12-urni format z AM/PM
7 : 'l, F j, Y H:i:s'; // 24-urni format
8
9 // Pretvori in oblikuj datum
10 return date($formatString, $timestamp);
11}
12
13// Primer uporabe
14$timestamp = 1609459200; // 1. januar 2021 00:00:00 UTC
15echo convertUnixTimestamp($timestamp, false) . "\n"; // 24-urni format
16echo convertUnixTimestamp($timestamp, true) . "\n"; // 12-urni format
17?>
181// Java pretvorba časovnega žiga
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 // Pretvori Unix časovni žig v Instant, nato v LocalDateTime
10 Instant instant = Instant.ofEpochSecond(timestamp);
11 LocalDateTime dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
12
13 // Ustvari oblikovalec na podlagi želenega formata
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 // Oblikuj 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-urni format
25 System.out.println(convertUnixTimestamp(timestamp, true)); // 12-urni format
26 }
27}
281// C# pretvorba časovnega žiga
2using System;
3
4class UnixTimestampConverter
5{
6 public static string ConvertUnixTimestamp(long timestamp, bool use12Hour)
7 {
8 // Pretvori Unix časovni žig v DateTime
9 // Unix časovni žig je sekunde od 1970-01-01
10 DateTime dateTime = DateTimeOffset.FromUnixTimeSeconds(timestamp).DateTime;
11
12 // Oblikovanje niza na podlagi 12-urnega ali 24-urnega preferenc
13 string formatString = use12Hour
14 ? "dddd, MMMM d, yyyy h:mm:ss tt" // 12-urni format z AM/PM
15 : "dddd, MMMM d, yyyy HH:mm:ss"; // 24-urni format
16
17 // Vrni oblikovan niz datuma
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-urni format
25 Console.WriteLine(ConvertUnixTimestamp(timestamp, true)); // 12-urni format
26 }
27}
281# Ruby pretvorba časovnega žiga
2require 'time'
3
4def convert_unix_timestamp(timestamp, use_12hour = false)
5 # Pretvori Unix časovni žig v objekt Time
6 time = Time.at(timestamp)
7
8 # Oblikovanje na podlagi 12-urnega ali 24-urnega preferenc
9 if use_12hour
10 time.strftime("%A, %B %d, %Y %I:%M:%S %p") # 12-urni format z AM/PM
11 else
12 time.strftime("%A, %B %d, %Y %H:%M:%S") # 24-urni format
13 end
14end
15
16# Primer uporabe
17timestamp = 1609459200 # 1. januar 2021 00:00:00 UTC
18puts convert_unix_timestamp(timestamp, false) # 24-urni format
19puts convert_unix_timestamp(timestamp, true) # 12-urni format
201// Go pretvorba časovnega žiga
2package main
3
4import (
5 "fmt"
6 "time"
7)
8
9func convertUnixTimestamp(timestamp int64, use12Hour bool) string {
10 // Pretvori Unix časovni žig v Time
11 t := time.Unix(timestamp, 0)
12
13 // Oblikovanje niza na podlagi 12-urnega ali 24-urnega preferenc
14 formatString := "Monday, January 2, 2006 "
15 if use12Hour {
16 formatString += "3:04:05 PM" // 12-urni format z AM/PM
17 } else {
18 formatString += "15:04:05" // 24-urni format
19 }
20
21 // Vrni oblikovan čas
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-urni format
28 fmt.Println(convertUnixTimestamp(timestamp, true)) // 12-urni format
29}
301// Swift pretvorba časovnega žiga
2import Foundation
3
4func convertUnixTimestamp(_ timestamp: Int, use12Hour: Bool) -> String {
5 // Ustvari Date iz Unix časovnega žiga
6 let date = Date(timeIntervalSince1970: TimeInterval(timestamp))
7
8 // Ustvari DateFormatter
9 let formatter = DateFormatter()
10 formatter.dateStyle = .full
11
12 // Nastavi časovni slog na podlagi 12-urnega ali 24-urnega preferenc
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 // Vrni oblikovan datum
23 return formatter.string(from: date)
24}
25
26// Primer uporabe
27let timestamp = 1609459200 // 1. januar 2021 00:00:00 UTC
28print(convertUnixTimestamp(timestamp, use12Hour: false)) // 24-urni format
29print(convertUnixTimestamp(timestamp, use12Hour: true)) // 12-urni format
301# R pretvorba časovnega žiga
2convert_unix_timestamp <- function(timestamp, use_12hour = FALSE) {
3 # Pretvori Unix časovni žig v POSIXct datetime
4 date_time <- as.POSIXct(timestamp, origin = "1970-01-01", tz = "UTC")
5
6 # Oblikovanje na podlagi 12-urnega ali 24-urnega preferenc
7 if (use_12hour) {
8 format_string <- "%A, %B %d, %Y %I:%M:%S %p" # 12-urni format z AM/PM
9 } else {
10 format_string <- "%A, %B %d, %Y %H:%M:%S" # 24-urni format
11 }
12
13 # Vrni oblikovan niz datuma
14 format(date_time, format_string)
15}
16
17# Primer uporabe
18timestamp <- 1609459200 # 1. januar 2021 00:00:00 UTC
19cat(convert_unix_timestamp(timestamp, FALSE), "\n") # 24-urni format
20cat(convert_unix_timestamp(timestamp, TRUE), "\n") # 12-urni format
211% MATLAB pretvorba časovnega žiga
2function formattedDate = convertUnixTimestamp(timestamp, use12Hour)
3 % Pretvori Unix časovni žig v MATLAB datetime
4 % MATLAB datumi so dnevi od 1900-01-01, pri čemer je 1 = 1900-01-01
5 % Unix časovni žigi so sekunde od 1970-01-01
6
7 % Najprej pretvori v Excel datumni format
8 % 25569 je število dni med 1900-01-01 in 1970-01-01
9 excelDate = (timestamp / 86400) + 25569;
10
11 % Oblikovanje na podlagi 12-urnega ali 24-urnega preferenc
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% Primer uporabe
20timestamp = 1609459200; % 1. januar 2021 00:00:00 UTC
21disp(convertUnixTimestamp(timestamp, false)) % 24-urni format
22disp(convertUnixTimestamp(timestamp, true)) % 12-urni format
231' Excel VBA pretvorba časovnega žiga
2Function ConvertUnixTimestamp(timestamp As Long, Optional use12Hour As Boolean = False) As String
3 ' Pretvori Unix časovni žig v Excel datum/čas
4 ' Excel datumi so dnevi od 1900-01-01, pri čemer je 1 = 1900-01-01
5 ' Unix časovni žigi so sekunde od 1970-01-01
6
7 ' Najprej pretvori v Excel datumni format
8 ' 25569 je število dni med 1900-01-01 in 1970-01-01
9 Dim excelDate As Double
10 excelDate = (timestamp / 86400) + 25569
11
12 ' Oblikovanje niza na podlagi 12-urnega ali 24-urnega preferenc
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' Uporaba v delovnem listu:
21' =ConvertUnixTimestamp(1609459200, TRUE) ' 12-urni format
22' =ConvertUnixTimestamp(1609459200, FALSE) ' 24-urni format
23Obvladovanje robnih primerov
Pri delu z Unix časovnimi žigi je pomembno pravilno obravnavati robne primere. Tukaj so primeri obravnave nekaterih pogostih robnih primerov:
1// JavaScript obravnava robnih primerov
2function safeConvertTimestamp(timestamp, use12Hour = false) {
3 // Preveri, ali je časovni žig veljaven
4 if (timestamp === undefined || timestamp === null || isNaN(timestamp)) {
5 return "Neveljaven časovni žig";
6 }
7
8 // Preveri za negativne časovne žige (datumi pred 1970)
9 if (timestamp < 0) {
10 // Nekateri brskalniki morda ne obravnavajo negativnih časovnih žigov pravilno
11 // Uporabi bolj robusten pristop za datume pred 1970
12 const date = new Date(timestamp * 1000);
13 if (isNaN(date.getTime())) {
14 return "Neveljavna datum (pred 1970)";
15 }
16 }
17
18 // Preveri za problem Y2K38 (za 32-bitne sisteme)
19 const maxInt32 = 2147483647; // Največja vrednost za 32-bitni celoštevilski podatek
20 if (timestamp > maxInt32) {
21 // Razmislite o uporabi BigInt za zelo velike časovne žige v modernem JavaScriptu
22 console.warn("Časovni žig presega omejitev 32-bitnega celega števila (problem Y2K38)");
23 }
24
25 // Nadaljuj s normalno pretvorbo
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 "Napaka pri pretvorbi časovnega žiga: " + error.message;
41 }
42}
43Reference
-
"Unix čas." Wikipedia, Wikimedia Foundation, https://en.wikipedia.org/wiki/Unix_time
-
"Problem leta 2038." Wikipedia, Wikimedia Foundation, https://en.wikipedia.org/wiki/Year_2038_problem
-
Olson, Arthur David. "Zapletenosti koledarskega časa." 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: Datum in čas na internetu: Časovni žigi." Internet Engineering Task Force (IETF), https://tools.ietf.org/html/rfc3339
-
Kernighan, Brian W., in Dennis M. Ritchie. "C programski jezik." Prentice Hall, 1988.
Povratne informacije
Kliknite na povratno informacijo, da začnete dajati povratne informacije o tem orodju
Povezana orodja
Odkrijte več orodij, ki bi lahko bila koristna za vaš delovni proces