Prevádzač Unix časových pečiatok na dátum: Podpora 12/24 hodinového formátu
Preveďte unixové časové pečiatky na ľahko čitateľné dátumy a časy. Vyberte si medzi 12-hodinovým a 24-hodinovým formátom pomocou tohto jednoduchého, používateľsky prívetivého prevádzača.
Prevádzač Unixového časového razítka
Prevedený dátum a čas
Dokumentácia
Konvertor Unix časových pečiatok
Úvod
Unix časová pečiatka (známa aj ako POSIX čas alebo Epoch čas) je systém na opisovanie bodu v čase. Je to počet sekúnd, ktoré uplynuli od 1. januára 1970 (polnoc UTC/GMT), bez zohľadnenia prestupných sekúnd. Unix časové pečiatky sú široko používané v počítačových systémoch a programovacích jazykoch, pretože poskytujú kompaktné, jazykovo nezávislé zastúpenie konkrétneho okamihu v čase.
Tento konvertor vám umožňuje transformovať Unix časovú pečiatku na ľahko čitateľný formát dátumu a času. Podporuje formáty času 12-hodinový (AM/PM) a 24-hodinový, aby vyhovoval rôznym regionálnym a osobným preferenciám.
Ako fungujú Unix časové pečiatky
Unix časové pečiatky sa počítajú ako počet sekúnd od Unix Epoch (1. januára 1970, 00:00:00 UTC). To ich robí obzvlášť užitočnými na výpočet časových rozdielov a na ukladanie dátumov v kompaktnom formáte.
Matematická konverzia z Unix časovej pečiatky na kalendárny dátum zahŕňa niekoľko krokov:
- Začnite s Unix Epoch (1. januára 1970, 00:00:00 UTC)
- Pridajte počet sekúnd v časovej pečiatke
- Zohľadnite prestupné roky, rôznu dĺžku mesiacov a iné kalendárne zložitosti
- Ak je to potrebné, aplikujte úpravy časového pásma
Napríklad, Unix časová pečiatka 1609459200 predstavuje piatok, 1. januára 2021, 00:00:00 UTC.
Konverzný vzorec možno vyjadriť ako:
Väčšina programovacích jazykov a operačných systémov poskytuje vstavané funkcie na spracovanie tejto konverzie, čím abstrahuje zložitosti kalendára.
Možnosti formátu času
Tento konvertor ponúka dve možnosti formátu času:
-
24-hodinový formát (niekedy nazývaný "vojenský čas"): Hodiny sa pohybujú od 0 do 23 a neexistuje žiadne označenie AM/PM. Napríklad, 15:00 je reprezentované ako 15:00.
-
12-hodinový formát: Hodiny sa pohybujú od 1 do 12, s AM (ante meridiem) pre časy od polnoci do obeda a PM (post meridiem) pre časy od obeda do polnoci. Napríklad, 15:00 v 24-hodinovom formáte je reprezentované ako 3:00 PM.
Voľba medzi týmito formátmi je do značnej miery otázkou regionálnej konvencie a osobných preferencií:
- 24-hodinový formát sa bežne používa vo väčšine Európy, Latinskej Ameriky a Ázie, ako aj v vedeckých, vojenských a medicínskych kontextoch po celom svete.
- 12-hodinový formát je rozšírený v Spojených štátoch, Kanade, Austrálii a niektorých ďalších anglicky hovoriacich krajinách pre každodenné použitie.
Okrajové prípady a obmedzenia
Pri práci s Unix časovými pečiatkami je dôležité byť si vedomý niekoľkých okrajových prípadov a obmedzení:
-
Negatívne časové pečiatky: Tieto predstavujú dátumy pred Unix Epoch (1. januára 1970). Aj keď sú matematicky platné, niektoré systémy nemusia správne spracovávať negatívne časové pečiatky.
-
Problém roku 2038: Unix časové pečiatky sa často ukladajú ako 32-bitové celé čísla so znamienkom, ktoré sa pretečú 19. januára 2038. Po tomto bode nebudú 32-bitové systémy schopné správne reprezentovať časy, pokiaľ nebudú upravené na použitie väčšieho typu celého čísla.
-
Extrémne veľké časové pečiatky: Veľmi vzdialené budúce dátumy nemusia byť v niektorých systémoch reprezentovateľné alebo môžu byť spracovávané nekonzistentne.
-
Prestupné sekundy: Unix čas nezohľadňuje prestupné sekundy, ktoré sa občas pridávajú do UTC na kompenzáciu nepravidelného rotovania Zeme. To znamená, že Unix čas nie je presne synchronizovaný s astronomickým časom.
-
Zohľadnenie časových pásiem: Unix časové pečiatky predstavujú okamihy v UTC. Prevod na miestny čas si vyžaduje dodatočné informácie o časovom pásme.
-
Letný čas: Pri prevode časových pečiatok na miestny čas je potrebné zohľadniť zložitosti prechodu na letný čas.
Použitie
Unix časové pečiatky sa používajú v mnohých aplikáciách naprieč počítačovým a správcovským dátovým prostredím:
-
Záznamy databáz: Časové pečiatky sa bežne používajú na zaznamenávanie, kedy boli položky vytvorené alebo upravené.
-
Webový vývoj: HTTP hlavičky, cookies a mechanizmy cache často používajú Unix časové pečiatky.
-
Logovacie súbory: Systémové logy zvyčajne zaznamenávajú udalosti s Unix časovými pečiatkami pre presné chronologické usporiadanie.
-
Systémy správy verzií: Git a iné VCS používajú časové pečiatky na zaznamenávanie, kedy boli vykonané commity.
-
Odpovede API: Mnohé webové API obsahujú časové pečiatky vo svojich odpovediach, aby naznačili, kedy boli údaje vygenerované alebo kedy boli zdroje naposledy upravené.
-
Súborové systémy: Časy vytvorenia a úpravy súborov sa často ukladajú ako Unix časové pečiatky.
-
Správa relácií: Webové aplikácie používajú časové pečiatky na určenie, kedy by sa mali relácie používateľov ukončiť.
-
Analýza dát: Časové pečiatky poskytujú štandardizovaný spôsob práce s časovými údajmi v analytických aplikáciách.
Alternatívy
Aj keď sú Unix časové pečiatky široko používané, existujú alternatívne formáty reprezentácie času, ktoré môžu byť vhodnejšie v určitých kontextoch:
-
ISO 8601: Štandardizovaný reťazcový formát (napr. "2021-01-01T00:00:00Z"), ktorý je ľahko čitateľný a zároveň zachováva zoraditeľnosť. Často sa preferuje pre výmenu dát a používateľské aplikácie.
-
RFC 3339: Profil ISO 8601 používaný v internetových protokoloch, s prísnejšími požiadavkami na formátovanie.
-
Ľahko čitateľné formáty: Lokalizované reťazce dátumov (napr. "1. január 2021") sú vhodnejšie pre priamu interakciu s používateľom, ale sú menej vhodné na výpočty.
-
Microsoft FILETIME: 64-bitová hodnota predstavujúca počet 100-nanosekúnd od 1. januára 1601, používaná v systémoch Windows.
-
Julian Day Number: Používa sa v astronómii a niektorých vedeckých aplikáciách, počítajúc dni od 1. januára 4713 pred naším letopočtom.
Voľba formátu času závisí od faktorov, ako sú:
- Požadovaná presnosť
- Potreby ľudskej čitateľnosti
- Obmedzenia ukladania
- Kompatibilita s existujúcimi systémami
- Rozsah dátumov, ktoré je potrebné reprezentovať
História
Koncept Unix času vznikol s vývojom operačného systému Unix v Bell Labs na konci 60. a začiatku 70. rokov. Rozhodnutie použiť 1. január 1970 ako epochu bolo do istej miery náhodné, ale praktické pre daný čas—bolo to nedávno, aby sa minimalizovali požiadavky na ukladanie pre zaujímavé dátumy, ale dostatočne ďaleko v minulosti, aby bolo užitočné pre historické dáta.
Pôvodná implementácia používala 32-bitové celé číslo so znamienkom na uloženie počtu sekúnd, čo bolo dostatočné pre očakávanú životnosť Unix systémov v tom čase. Avšak toto rozhodnutie viedlo k problému roku 2038 (niekedy nazývanému "Y2K38" alebo "Unix Millennium Bug"), pretože 32-bitové celé čísla môžu reprezentovať iba dátumy do 19. januára 2038 (03:14:07 UTC).
Keď Unix a Unix-like operačné systémy získali popularitu, Unix časová pečiatka sa stala de facto štandardom pre reprezentáciu času v počítačoch. Bola prijatá mnohými programovacími jazykmi, databázami a aplikáciami, rozširujúc sa ďaleko za svoj pôvodný unixový prostredie.
Moderné systémy čoraz častejšie používajú 64-bitové celé čísla pre časové pečiatky, čo rozširuje reprezentovateľný rozsah na približne 292 miliárd rokov v oboch smeroch od epochy, čím sa efektívne rieši problém roku 2038. Avšak staršie systémy a aplikácie môžu byť stále zraniteľné.
Jednoduchosť a užitočnosť Unix časovej pečiatky zabezpečili jej pokračujúcu relevantnosť aj napriek vývoju sofistikovanejších formátov reprezentácie času. Zostáva základným konceptom v počítačoch, ktorý podporuje väčšinu našej digitálnej infraštruktúry.
Kódové príklady
Tu sú príklady, ako konvertovať Unix časové pečiatky na ľahko čitateľné dátumy v rôznych programovacích jazykoch:
1// JavaScript konverzia časovej pečiatky
2function convertUnixTimestamp(timestamp, use12Hour = false) {
3 // Vytvorte nový objekt Date (JavaScript používa milisekundy)
4 const date = new Date(timestamp * 1000);
5
6 // Možnosti formátovania
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 // Preveďte na reťazec pomocou formátovania lokality
19 return date.toLocaleString(undefined, options);
20}
21
22// Príklad použitia
23const timestamp = 1609459200; // 1. január 2021 00:00:00 UTC
24console.log(convertUnixTimestamp(timestamp, false)); // 24-hodinový formát
25console.log(convertUnixTimestamp(timestamp, true)); // 12-hodinový formát
261# Python konverzia časovej pečiatky
2import datetime
3
4def convert_unix_timestamp(timestamp, use_12hour=False):
5 # Preveďte Unix časovú pečiatku na objekt datetime
6 date = datetime.datetime.fromtimestamp(timestamp)
7
8 # Formát reťazca
9 if use_12hour:
10 format_string = "%A, %B %d, %Y %I:%M:%S %p" # 12-hodinový formát s AM/PM
11 else:
12 format_string = "%A, %B %d, %Y %H:%M:%S" # 24-hodinový formát
13
14 return date.strftime(format_string)
15
16# Príklad použitia
17timestamp = 1609459200 # 1. január 2021 00:00:00 UTC
18print(convert_unix_timestamp(timestamp, False)) # 24-hodinový formát
19print(convert_unix_timestamp(timestamp, True)) # 12-hodinový formát
201<?php
2// PHP konverzia časovej pečiatky
3function convertUnixTimestamp($timestamp, $use12Hour = false) {
4 // Formát reťazca
5 $formatString = $use12Hour
6 ? 'l, F j, Y g:i:s A' // 12-hodinový formát s AM/PM
7 : 'l, F j, Y H:i:s'; // 24-hodinový formát
8
9 // Preveďte a formátujte dátum
10 return date($formatString, $timestamp);
11}
12
13// Príklad použitia
14$timestamp = 1609459200; // 1. január 2021 00:00:00 UTC
15echo convertUnixTimestamp($timestamp, false) . "\n"; // 24-hodinový formát
16echo convertUnixTimestamp($timestamp, true) . "\n"; // 12-hodinový formát
17?>
181// Java konverzia časovej pečiatky
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 // Preveďte Unix časovú pečiatku na Instant, potom na LocalDateTime
10 Instant instant = Instant.ofEpochSecond(timestamp);
11 LocalDateTime dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
12
13 // Vytvorte formátovač na základe požadovaného formátu
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 // Formátujte dátum
19 return dateTime.format(formatter);
20 }
21
22 public static void main(String[] args) {
23 long timestamp = 1609459200; // 1. január 2021 00:00:00 UTC
24 System.out.println(convertUnixTimestamp(timestamp, false)); // 24-hodinový formát
25 System.out.println(convertUnixTimestamp(timestamp, true)); // 12-hodinový formát
26 }
27}
281// C# konverzia časovej pečiatky
2using System;
3
4class UnixTimestampConverter
5{
6 public static string ConvertUnixTimestamp(long timestamp, bool use12Hour)
7 {
8 // Preveďte Unix časovú pečiatku na DateTime
9 // Unix časové pečiatky sú sekundy od 1970-01-01
10 DateTime dateTime = DateTimeOffset.FromUnixTimeSeconds(timestamp).DateTime;
11
12 // Formát reťazca na základe preferencie 12-hodinového alebo 24-hodinového formátu
13 string formatString = use12Hour
14 ? "dddd, MMMM d, yyyy h:mm:ss tt" // 12-hodinový formát s AM/PM
15 : "dddd, MMMM d, yyyy HH:mm:ss"; // 24-hodinový formát
16
17 // Vráťte formátovaný reťazec dátumu
18 return dateTime.ToString(formatString);
19 }
20
21 static void Main()
22 {
23 long timestamp = 1609459200; // 1. január 2021 00:00:00 UTC
24 Console.WriteLine(ConvertUnixTimestamp(timestamp, false)); // 24-hodinový formát
25 Console.WriteLine(ConvertUnixTimestamp(timestamp, true)); // 12-hodinový formát
26 }
27}
281# Ruby konverzia časovej pečiatky
2require 'time'
3
4def convert_unix_timestamp(timestamp, use_12hour = false)
5 # Preveďte Unix časovú pečiatku na objekt Time
6 time = Time.at(timestamp)
7
8 # Formát na základe preferencie 12-hodinového alebo 24-hodinového formátu
9 if use_12hour
10 time.strftime("%A, %B %d, %Y %I:%M:%S %p") # 12-hodinový formát s AM/PM
11 else
12 time.strftime("%A, %B %d, %Y %H:%M:%S") # 24-hodinový formát
13 end
14end
15
16# Príklad použitia
17timestamp = 1609459200 # 1. január 2021 00:00:00 UTC
18puts convert_unix_timestamp(timestamp, false) # 24-hodinový formát
19puts convert_unix_timestamp(timestamp, true) # 12-hodinový formát
201// Go konverzia časovej pečiatky
2package main
3
4import (
5 "fmt"
6 "time"
7)
8
9func convertUnixTimestamp(timestamp int64, use12Hour bool) string {
10 // Preveďte Unix časovú pečiatku na Time
11 t := time.Unix(timestamp, 0)
12
13 // Formát reťazca na základe preferencie 12-hodinového alebo 24-hodinového formátu
14 formatString := "Monday, January 2, 2006 "
15 if use12Hour {
16 formatString += "3:04:05 PM" // 12-hodinový formát s AM/PM
17 } else {
18 formatString += "15:04:05" // 24-hodinový formát
19 }
20
21 // Vráťte formátovaný čas
22 return t.Format(formatString)
23}
24
25func main() {
26 timestamp := int64(1609459200) // 1. január 2021 00:00:00 UTC
27 fmt.Println(convertUnixTimestamp(timestamp, false)) // 24-hodinový formát
28 fmt.Println(convertUnixTimestamp(timestamp, true)) // 12-hodinový formát
29}
301// Swift konverzia časovej pečiatky
2import Foundation
3
4func convertUnixTimestamp(_ timestamp: Int, use12Hour: Bool) -> String {
5 // Vytvorte Date z Unix časovej pečiatky
6 let date = Date(timeIntervalSince1970: TimeInterval(timestamp))
7
8 // Vytvorte DateFormatter
9 let formatter = DateFormatter()
10 formatter.dateStyle = .full
11
12 // Nastavte časový štýl na základe preferencie 12-hodinového alebo 24-hodinového formátu
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 // Vráťte formátovaný dátum
23 return formatter.string(from: date)
24}
25
26// Príklad použitia
27let timestamp = 1609459200 // 1. január 2021 00:00:00 UTC
28print(convertUnixTimestamp(timestamp, use12Hour: false)) // 24-hodinový formát
29print(convertUnixTimestamp(timestamp, use12Hour: true)) // 12-hodinový formát
301# R konverzia časovej pečiatky
2convert_unix_timestamp <- function(timestamp, use_12hour = FALSE) {
3 # Preveďte Unix časovú pečiatku na POSIXct datetime
4 date_time <- as.POSIXct(timestamp, origin = "1970-01-01", tz = "UTC")
5
6 # Formát na základe preferencie 12-hodinového alebo 24-hodinového formátu
7 if (use_12hour) {
8 format_string <- "%A, %B %d, %Y %I:%M:%S %p" # 12-hodinový formát s AM/PM
9 } else {
10 format_string <- "%A, %B %d, %Y %H:%M:%S" # 24-hodinový formát
11 }
12
13 # Vráťte formátovaný reťazec dátumu
14 format(date_time, format_string)
15}
16
17# Príklad použitia
18timestamp <- 1609459200 # 1. január 2021 00:00:00 UTC
19cat(convert_unix_timestamp(timestamp, FALSE), "\n") # 24-hodinový formát
20cat(convert_unix_timestamp(timestamp, TRUE), "\n") # 12-hodinový formát
211% MATLAB konverzia časovej pečiatky
2function formattedDate = convertUnixTimestamp(timestamp, use12Hour)
3 % Preveďte Unix časovú pečiatku na MATLAB datetime
4 % MATLAB dátumy sú dni od 1900-01-01, s 1 = 1900-01-01
5 % Unix časové pečiatky sú sekundy od 1970-01-01
6
7 % Najprv prevedieme na Excel dátový formát
8 % 25569 je počet dní medzi 1900-01-01 a 1970-01-01
9 excelDate = (timestamp / 86400) + 25569;
10
11 % Formát na základe preferencie 12-hodinového alebo 24-hodinového formátu
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% Príklad použitia
20timestamp = 1609459200; % 1. január 2021 00:00:00 UTC
21disp(convertUnixTimestamp(timestamp, false)) % 24-hodinový formát
22disp(convertUnixTimestamp(timestamp, true)) % 12-hodinový formát
231' Excel VBA konverzia časovej pečiatky
2Function ConvertUnixTimestamp(timestamp As Long, Optional use12Hour As Boolean = False) As String
3 ' Preveďte Unix časovú pečiatku na Excel dátum/čas
4 ' Excel dátumy sú dni od 1900-01-01, s 1 = 1900-01-01
5 ' Unix časové pečiatky sú sekundy od 1970-01-01
6
7 ' Najprv prevedieme na Excel dátový formát
8 ' 25569 je počet dní medzi 1900-01-01 a 1970-01-01
9 Dim excelDate As Double
10 excelDate = (timestamp / 86400) + 25569
11
12 ' Formát reťazca na základe preferencie 12-hodinového alebo 24-hodinového formátu
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' Použitie v hárku:
21' =ConvertUnixTimestamp(1609459200, TRUE) ' 12-hodinový formát
22' =ConvertUnixTimestamp(1609459200, FALSE) ' 24-hodinový formát
23Riešenie okrajových prípadov
Pri práci s Unix časovými pečiatkami je dôležité správne riešiť okrajové prípady. Tu sú príklady riešenia niektorých bežných okrajových prípadov:
1// JavaScript riešenie okrajových prípadov
2function safeConvertTimestamp(timestamp, use12Hour = false) {
3 // Skontrolujte, či je časová pečiatka platná
4 if (timestamp === undefined || timestamp === null || isNaN(timestamp)) {
5 return "Neplatná časová pečiatka";
6 }
7
8 // Skontrolujte negatívne časové pečiatky (dátumy pred 1970)
9 if (timestamp < 0) {
10 // Niektoré prehliadače nemusia správne spracovávať negatívne časové pečiatky
11 // Použite robustnejší prístup pre dátumy pred 1970
12 const date = new Date(timestamp * 1000);
13 if (isNaN(date.getTime())) {
14 return "Neplatný dátum (pred 1970)";
15 }
16 }
17
18 // Skontrolujte problém Y2K38 (pre 32-bitové systémy)
19 const maxInt32 = 2147483647; // Maximálna hodnota pre 32-bitové celé číslo
20 if (timestamp > maxInt32) {
21 // Zvážte použitie BigInt pre veľmi veľké časové pečiatky v modernej JavaScripte
22 console.warn("Časová pečiatka presahuje limit 32-bitového celého čísla (problém Y2K38)");
23 }
24
25 // Pokračujte s normálnou konverziou
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 "Chyba pri konverzii časovej pečiatky: " + error.message;
41 }
42}
43Odkazy
-
"Unix Time." Wikipedia, Wikimedia Foundation, https://en.wikipedia.org/wiki/Unix_time
-
"Problém roku 2038." Wikipedia, Wikimedia Foundation, https://en.wikipedia.org/wiki/Year_2038_problem
-
Olson, Arthur David. "Zložitosti kalendárneho času." 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: Dátum a čas na internete: Časové pečiatky." Internet Engineering Task Force (IETF), https://tools.ietf.org/html/rfc3339
-
Kernighan, Brian W., a Dennis M. Ritchie. "Programovací jazyk C." Prentice Hall, 1988.
Spätná väzba
Kliknite na toast so spätnou väzbou, aby ste začali dávať spätnú väzbu o tomto nástroji
Súvisiace nástroje
Objavte ďalšie nástroje, ktoré by mohli byť užitočné pre váš pracovný tok