Unix Timestamp Converter

Úvod

Unixový časový údaj (známý také jako POSIX čas nebo Epoch čas) je systém pro popis časového okamžiku. Je to počet sekund, které uplynuly od 1. ledna 1970 (půlnoc UTC/GMT), bez započítání přestupných sekund. Unixové časové údaje se široce používají v počítačových systémech a programovacích jazycích, protože poskytují kompaktní, jazykově nezávislé zastoupení konkrétního okamžiku v čase.

Tento konvertor časových údajů na datum automaticky detekuje a zpracovává časové údaje různých délek, včetně mikrosekundové přesnosti (16 číslic), milisekundové přesnosti (13 číslic) a standardních unixových časových údajů (10 číslic). Nástroj identifikuje formát časového údaje na základě délky vstupu, převádí ho na čitelné datum a čas a zobrazuje výsledek, aniž by uživatelé museli specifikovat typ časového údaje. Podporuje jak 12hodinový (AM/PM), tak 24hodinový formát času, aby vyhověl různým regionálním a osobním preferencím.

Jak fungují Unixové časové údaje

Unixové časové údaje se počítají jako počet sekund od Unixové Epochy (1. ledna 1970, 00:00:00 UTC). To je činí zvlášť užitečnými pro výpočty časových rozdílů a pro ukládání dat v kompaktním formátu.

Matematická konverze z unixového časového údaje na kalendářní datum zahrnuje několik kroků:

1. Začněte s Unixovou Epochou (1. ledna 1970, 00:00:00 UTC)
2. Přidejte počet sekund v časovém údaji
3. Zohledněte přestupné roky, různou délku měsíců a další složitosti kalendáře
4. Aplikujte úpravy časového pásma, pokud je to potřeba

Například unixový časový údaj 1609459200 představuje pátek, 1. ledna 2021, 00:00:00 UTC.

Konverzní vzorec lze vyjádřit jako:

$\text{Datum} = \text{Unixová Epoch} + \text{Časový údaj (v sekundách)}$

Většina programovacích jazyků a operačních systémů poskytuje vestavěné funkce pro zpracování této konverze, čímž abstrahuje složité kalendářní výpočty.

Formáty časových údajů a automatická detekce

Náš konvertor podporuje tři běžné formáty časových údajů, které jsou automaticky detekovány na základě počtu číslic:

1. Standardní Unixový časový údaj (10 číslic): Představuje sekundy od Unixové Epochy. Příklad: 1609459200 (1. ledna 2021, 00:00:00 UTC)

2. Milisekundová přesnost (13 číslic): Představuje milisekundy od Unixové Epochy. Příklad: 1609459200000 (1. ledna 2021, 00:00:00 UTC)

3. Mikrosekundová přesnost (16 číslic): Představuje mikrosekundy od Unixové Epochy. Příklad: 1609459200000000 (1. ledna 2021, 00:00:00 UTC)

Automatická detekce funguje analýzou délky vstupu:

• Pokud vstup obsahuje 10 číslic, je považován za standardní unixový časový údaj (sekundy)
• Pokud vstup obsahuje 13 číslic, je považován za milisekundový časový údaj
• Pokud vstup obsahuje 16 číslic, je považován za mikrosekundový časový údaj

Tato automatická detekce eliminuje potřebu, aby uživatelé specifikovali typ časového údaje, což činí nástroj uživatelsky přívětivějším a efektivnějším.

Možnosti formátu času

Tento konvertor nabízí dvě možnosti formátu času:

1. 24hodinový formát (někdy nazývaný "vojenský čas"): Hodiny se pohybují od 0 do 23 a neexistuje žádné označení AM/PM. Například 15:00 je reprezentováno jako 15:00.

2. 12hodinový formát: Hodiny se pohybují od 1 do 12, s AM (ante meridiem) pro časy od půlnoci do poledne a PM (post meridiem) pro časy od poledne do půlnoci. Například 15:00 v 24hodinovém formátu je reprezentováno jako 3:00 PM.

Volba mezi těmito formáty je převážně otázkou regionální konvence a osobních preferencí:

• 24hodinový formát se běžně používá ve většině Evropy, Latinské Ameriky a Asie, stejně jako v vědeckých, vojenských a lékařských kontextech po celém světě.
• 12hodinový formát je rozšířený ve Spojených státech, Kanadě, Austrálii a některých dalších anglicky mluvících zemích pro každodenní použití.

Okrajové případy a omezení

Při práci s unixovými časovými údaji různých přesností je důležité být si vědom několika okrajových případů a omezení:

1. Negativní časové údaje: Tyto představují data před Unixovou Epochou (1. ledna 1970). Ačkoli jsou matematicky platné, některé systémy nemusí správně zpracovávat negativní časové údaje. To platí pro všechny tři formáty časových údajů.

2. Problém roku 2038: Standardní unixové časové údaje (10 číslic) jsou často ukládány jako 32bitové podepsané celá čísla, která se přetečou 19. ledna 2038. Po tomto datu nebudou 32bitové systémy schopny správně reprezentovat časy, pokud nebudou upraveny k použití většího typu celého čísla.

3. Úvahy o přesnosti:

   • Standardní časové údaje (10 číslic) mají přesnost na úrovni sekund, což je dostatečné pro většinu každodenních aplikací.
   • Milisekundové časové údaje (13 číslic) poskytují 1000x větší přesnost, což je užitečné pro aplikace vyžadující přesnější měření času.
   • Mikrosekundové časové údaje (16 číslic) nabízejí ještě jemnější granularitu (1/1 000 000 sekundy), což je nezbytné pro vysoce výkonné počítačové aplikace, vědecké aplikace a určité finanční transakce.

4. Extrémně velké časové údaje: Velmi vzdálená budoucí data nemusí být reprezentovatelná v některých systémech nebo mohou být zpracovávána nekonzistentně. To je obzvlášť relevantní pro milisekundové a mikrosekundové časové údaje, které používají větší číselné hodnoty.

5. Přestupné sekundy: Unixový čas nezohledňuje přestupné sekundy, které jsou občas přidávány do UTC, aby kompenzovaly nepravidelnou rotaci Země. To znamená, že unixový čas není přesně synchronizován s astronomickým časem.

6. Úvahy o časových pásmech: Unixové časové údaje představují okamžiky v UTC. Převod na místní čas vyžaduje dodatečné informace o časovém pásmu.

7. Letní čas: Při převodu časových údajů na místní čas musí být zohledněny složitosti přechodů na letní čas.

8. Zmatek s formátem časového údaje: Bez správné detekce může být 13 číslicový milisekundový časový údaj mylně interpretován jako velmi vzdálené budoucí datum, pokud je zpracován jako časový údaj na základě sekund. Náš konvertor tomu zabraňuje automatickou detekcí formátu na základě délky číslic.

Případové studie

Unixové časové údaje různých přesností se používají v mnoha aplikacích napříč počítačovým a datovým managementem:

1. Databázové záznamy: Časové údaje se běžně používají k zaznamenání, kdy byly položky vytvořeny nebo upraveny.

   • Standardní časové údaje (10 číslic) jsou často dostatečné pro běžné databázové aplikace.
   • Milisekundové časové údaje (13 číslic) se používají, když je vyžadováno přesnější řazení událostí.

2. Webový vývoj: HTTP hlavičky, cookies a mechanismy cachování často používají unixové časové údaje.

   • JavaScriptova funkce Date.now() vrací milisekundové časové údaje (13 číslic).

3. Logovací soubory: Systémové logy obvykle zaznamenávají události s unixovými časovými údaji pro přesné chronologické řazení.

   • Systémy s vysokou frekvencí logování mohou používat milisekundovou nebo mikrosekundovou přesnost.

4. Systémy správy verzí: Git a další VCS používají časové údaje k zaznamenání, kdy byly provedeny commity.

5. API odpovědi: Mnoho webových API zahrnuje časové údaje ve svých odpovědích, aby indikovala, kdy byla data vygenerována nebo kdy byly zdroje naposledy upraveny.

   • REST API často používají milisekundové časové údaje.

6. Soubory systému: Časy vytvoření a úpravy souborů se často ukládají jako unixové časové údaje.

7. Správa relací: Webové aplikace používají časové údaje k určení, kdy by měly relace uživatelů vypršet.

8. Analýza dat: Časové údaje poskytují standardizovaný způsob práce s časovými daty v analytických aplikacích.

9. Vysoce frekvenční obchodování: Finanční systémy často vyžadují mikrosekundovou přesnost (16 číslic) pro přesné sekvenování transakcí.

10. Vědecká měření: Výzkumné zařízení může zaznamenávat pozorování s mikrosekundovou přesností pro přesnou časovou analýzu.

Alternativy

Ačkoli jsou unixové časové údaje široce používány, existují alternativní formáty reprezentace času, které mohou být v některých kontextech vhodnější:

1. ISO 8601: Standardizovaný řetězcový formát (např. "2021-01-01T00:00:00Z"), který je čitelný pro lidi a zároveň zachovává možnost řazení. Často se preferuje pro výměnu dat a uživatelské aplikace.

2. RFC 3339: Profil ISO 8601 používaný v internetových protokolech, se přísnějšími požadavky na formátování.

3. Formáty čitelné pro lidi: Lokalizované datumní řetězce (např. "1. ledna 2021") jsou vhodnější pro přímou interakci s uživateli, ale méně vhodné pro výpočty.

4. Microsoft FILETIME: 64bitová hodnota představující počet intervalů 100 nanosekund od 1. ledna 1601, používaná v systémech Windows.

5. Julian Day Number: Používá se v astronomii a některých vědeckých aplikacích, počítající dny od 1. ledna 4713 př. n. l.

Volba formátu času závisí na faktorech, jako jsou:

• Požadovaná přesnost
• Potřeby čitelnosti pro lidi
• Omezující podmínky pro ukládání
• Kompatibilita se stávajícími systémy
• Rozsah dat, která je třeba reprezentovat

Historie

Koncept unixového času vznikl s vývojem operačního systému Unix v Bell Labs na konci 60. a začátku 70. let. Rozhodnutí použít 1. ledna 1970 jako epochu bylo poněkud arbitrární, ale praktické pro tu dobu – bylo dost nedávné, aby se minimalizovaly požadavky na úložiště pro zajímavá data, ale dost daleko v minulosti, aby byla užitečná pro historická data.

Původní implementace používala 32bitové podepsané celé číslo k uložení počtu sekund, což bylo dostatečné pro očekávanou životnost unixových systémů v té době. Toto rozhodnutí však vedlo k problému roku 2038 (někdy nazývanému "Y2K38" nebo "Unix Millennium Bug"), protože 32bitová podepsaná celá čísla mohou reprezentovat pouze data do 19. ledna 2038 (03:14:07 UTC).

Jak se výpočetní potřeby vyvíjely, stala se vyšší přesnost časových údajů nezbytnou:

• Milisekundová přesnost (13 číslic) se stala běžnou s nástupem interaktivního počítačového zpracování a potřebou měřit reakční dobu uživatelského rozhraní.

• Mikrosekundová přesnost (16 číslic) se objevila s aplikacemi vysoce výkonného počítačového zpracování a systémy vyžadujícími extrémně přesné časování.

Jak unixové a unixové systémy získaly popularitu, unixový časový údaj se stal de facto standardem pro reprezentaci času v počítačích. Byl přijat mnoha programovacími jazyky, databázemi a aplikacemi, čímž překročil původní prostředí Unix.

Moderní systémy stále častěji používají 64bitová celá čísla pro časové údaje, což prodlužuje reprezentovatelný rozsah na přibližně 292 miliard let v obou směrech od epochy, což efektivně řeší problém roku 2038. Nicméně, starší systémy a aplikace mohou být stále zranitelné.

Jednoduchost a užitečnost unixového časového údaje zajistily jeho pokračující relevanci navzdory vývoji sofistikovanějších formátů reprezentace času. Zůstává základním konceptem v počítačích, na kterém spočívá velká část naší digitální infrastruktury.

Příklady kódu

Zde jsou příklady, jak převést unixové časové údaje různých přesností na čitelná data v různých programovacích jazycích:

1// JavaScript převod časového údaje s automatickou detekcí formátu
2function convertTimestamp(timestamp, use12Hour = false) {
3  // Převést řetězec na číslo, pokud je to potřeba
4  const numericTimestamp = Number(timestamp);
5  
6  // Detekovat formát časového údaje na základě délky číslic
7  let date;
8  if (timestamp.length === 16) {
9    // Mikrosekundová přesnost (dělit 1 000 000, abychom získali sekundy)
10    date = new Date(numericTimestamp / 1000);
11    console.log("Detekováno: Mikrosekundová přesnost časového údaje");
12  } else if (timestamp.length === 13) {
13    // Milisekundová přesnost
14    date = new Date(numericTimestamp);
15    console.log("Detekováno: Milisekundová přesnost časového údaje");
16  } else if (timestamp.length === 10) {
17    // Standardní unixový časový údaj (sekundy)
18    date = new Date(numericTimestamp * 1000);
19    console.log("Detekováno: Standardní unixový časový údaj (sekundy)");
20  } else {
21    throw new Error("Neplatný formát časového údaje. Očekáváno 10, 13 nebo 16 číslic.");
22  }
23  
24  // Možnosti formátování
25  const options = {
26    year: 'numeric',
27    month: 'long',
28    day: 'numeric',
29    weekday: 'long',
30    hour: use12Hour ? 'numeric' : '2-digit',
31    minute: '2-digit',
32    second: '2-digit',
33    hour12: use12Hour
34  };
35  
36  // Převést na řetězec pomocí formátování podle místního nastavení
37  return date.toLocaleString(undefined, options);
38}
39
40// Příklad použití
41try {
42  // Standardní unixový časový údaj (10 číslic)
43  console.log(convertTimestamp("1609459200", false)); 
44  
45  // Milisekundová přesnost (13 číslic)
46  console.log(convertTimestamp("1609459200000", false)); 
47  
48  // Mikrosekundová přesnost (16 číslic)
49  console.log(convertTimestamp("1609459200000000", true)); 
50} catch (error) {
51  console.error(error.message);
52}
53

1# Python převod časového údaje s automatickou detekcí formátu
2import datetime
3
4def convert_timestamp(timestamp, use_12hour=False):
5    # Převést na celé číslo
6    timestamp = str(timestamp).strip()
7    numeric_timestamp = int(timestamp)
8    
9    # Detekovat formát časového údaje na základě délky číslic
10    if len(timestamp) == 16:
11        # Mikrosekundová přesnost (dělit 1 000 000, abychom získali sekundy)
12        date = datetime.datetime.fromtimestamp(numeric_timestamp / 1000000)
13        print("Detekováno: Mikrosekundová přesnost časového údaje")
14    elif len(timestamp) == 13:
15        # Milisekundová přesnost (dělit 1 000, abychom získali sekundy)
16        date = datetime.datetime.fromtimestamp(numeric_timestamp / 1000)
17        print("Detekováno: Milisekundová přesnost časového údaje")
18    elif len(timestamp) == 10:
19        # Standardní unixový časový údaj (sekundy)
20        date = datetime.datetime.fromtimestamp(numeric_timestamp)
21        print("Detekováno: Standardní unixový časový údaj (sekundy)")
22    else:
23        raise ValueError("Neplatný formát časového údaje. Očekáváno 10, 13 nebo 16 číslic.")
24    
25    # Formátování řetězce
26    if use_12hour:
27        format_string = "%A, %B %d, %Y %I:%M:%S %p"  # 12hodinový formát s AM/PM
28    else:
29        format_string = "%A, %B %d, %Y %H:%M:%S"     # 24hodinový formát
30    
31    return date.strftime(format_string)
32
33# Příklad použití
34try:
35    # Standardní unixový časový údaj (10 číslic)
36    print(convert_timestamp("1609459200", False))
37    
38    # Milisekundová přesnost (13 číslic)
39    print(convert_timestamp("1609459200000", False))
40    
41    # Mikrosekundová přesnost (16 číslic)
42    print(convert_timestamp("1609459200000000", True))
43except ValueError as e:
44    print(e)
45

1<?php
2// PHP převod časového údaje s automatickou detekcí formátu
3function convertTimestamp($timestamp, $use12Hour = false) {
4    // Zajistit, aby časový údaj byl řetězec pro kontrolu délky
5    $timestamp = trim((string)$timestamp);
6    
7    // Detekovat formát časového údaje na základě délky číslic
8    if (strlen($timestamp) === 16) {
9        // Mikrosekundová přesnost (dělit 1 000 000, abychom získali sekundy)
10        $seconds = (float)$timestamp / 1000000;
11        echo "Detekováno: Mikrosekundová přesnost časového údaje\n";
12    } elseif (strlen($timestamp) === 13) {
13        // Milisekundová přesnost
14        $seconds = (float)$timestamp / 1000;
15        echo "Detekováno: Milisekundová přesnost časového údaje\n";
16    } elseif (strlen($timestamp) === 10) {
17        // Standardní unixový časový údaj (sekundy)
18        $seconds = (float)$timestamp;
19        echo "Detekováno: Standardní unixový časový údaj (sekundy)\n";
20    } else {
21        throw new Exception("Neplatný formát časového údaje. Očekáváno 10, 13 nebo 16 číslic.");
22    }
23    
24    // Formátovací řetězec
25    $formatString = $use12Hour 
26        ? 'l, F j, Y g:i:s A'  // 12hodinový formát s AM/PM
27        : 'l, F j, Y H:i:s';   // 24hodinový formát
28    
29    // Převést a formátovat datum
30    return date($formatString, $seconds);
31}
32
33// Příklad použití
34try {
35    // Standardní unixový časový údaj (10 číslic)
36    echo convertTimestamp("1609459200", false) . "\n";
37    
38    // Milisekundová přesnost (13 číslic)
39    echo convertTimestamp("1609459200000", false) . "\n";
40    
41    // Mikrosekundová přesnost (16 číslic)
42    echo convertTimestamp("1609459200000000", true) . "\n";
43} catch (Exception $e) {
44    echo $e->getMessage() . "\n";
45}
46?>
47

1// Java převod časového údaje s automatickou detekcí formátu
2import java.time.Instant;
3import java.time.LocalDateTime;
4import java.time.ZoneId;
5import java.time.format.DateTimeFormatter;
6
7public class TimestampConverter {
8    public static String convertTimestamp(String timestamp, boolean use12Hour) {
9        // Trim vstupu
10        timestamp = timestamp.trim();
11        
12        // Detekovat formát časového údaje na základě délky číslic
13        LocalDateTime dateTime;
14        if (timestamp.length() == 16) {
15            // Mikrosekundová přesnost (dělit 1 000 000, abychom získali sekundy)
16            long microseconds = Long.parseLong(timestamp);
17            Instant instant = Instant.ofEpochSecond(0, microseconds * 1000); // Převést na nanosekundy
18            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
19            System.out.println("Detekováno: Mikrosekundová přesnost časového údaje");
20        } else if (timestamp.length() == 13) {
21            // Milisekundová přesnost
22            long milliseconds = Long.parseLong(timestamp);
23            Instant instant = Instant.ofEpochMilli(milliseconds);
24            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
25            System.out.println("Detekováno: Milisekundová přesnost časového údaje");
26        } else if (timestamp.length() == 10) {
27            // Standardní unixový časový údaj (sekundy)
28            long seconds = Long.parseLong(timestamp);
29            Instant instant = Instant.ofEpochSecond(seconds);
30            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
31            System.out.println("Detekováno: Standardní unixový časový údaj (sekundy)");
32        } else {
33            throw new IllegalArgumentException("Neplatný formát časového údaje. Očekáváno 10, 13 nebo 16 číslic.");
34        }
35        
36        // Vytvořit formátovač na základě požadovaného formátu
37        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(
38            use12Hour ? "EEEE, MMMM d, yyyy h:mm:ss a" : "EEEE, MMMM d, yyyy HH:mm:ss"
39        );
40        
41        // Formátovat datum
42        return dateTime.format(formatter);
43    }
44    
45    public static void main(String[] args) {
46        try {
47            // Standardní unixový časový údaj (10 číslic)
48            System.out.println(convertTimestamp("1609459200", false));
49            
50            // Milisekundová přesnost (13 číslic)
51            System.out.println(convertTimestamp("1609459200000", false));
52            
53            // Mikrosekundová přesnost (16 číslic)
54            System.out.println(convertTimestamp("1609459200000000", true));
55        } catch (IllegalArgumentException e) {
56            System.err.println(e.getMessage());
57        }
58    }
59}
60

1// C# převod časového údaje s automatickou detekcí formátu
2using System;
3
4class TimestampConverter
5{
6    public static string ConvertTimestamp(string timestamp, bool use12Hour)
7    {
8        // Trim vstupu
9        timestamp = timestamp.Trim();
10        
11        // Detekovat formát časového údaje na základě délky číslic
12        DateTime dateTime;
13        if (timestamp.Length == 16)
14        {
15            // Mikrosekundová přesnost (dělit 1 000 000, abychom získali sekundy)
16            if (!double.TryParse(timestamp, out double microseconds))
17                throw new ArgumentException("Neplatný formát časového údaje");
18                
19            // Převést mikrosekundy na DateTime
20            dateTime = DateTimeOffset.FromUnixTimeSeconds(0).DateTime.AddSeconds(microseconds / 1000000);
21            Console.WriteLine("Detekováno: Mikrosekundová přesnost časového údaje");
22        }
23        else if (timestamp.Length == 13)
24        {
25            // Milisekundová přesnost
26            if (!long.TryParse(timestamp, out long milliseconds))
27                throw new ArgumentException("Neplatný formát časového údaje");
28                
29            dateTime = DateTimeOffset.FromUnixTimeMilliseconds(milliseconds).DateTime;
30            Console.WriteLine("Detekováno: Milisekundová přesnost časového údaje");
31        }
32        else if (timestamp.Length == 10)
33        {
34            // Standardní unixový časový údaj (sekundy)
35            if (!long.TryParse(timestamp, out long seconds))
36                throw new ArgumentException("Neplatný formát časového údaje");
37                
38            dateTime = DateTimeOffset.FromUnixTimeSeconds(seconds).DateTime;
39            Console.WriteLine("Detekováno: Standardní unixový časový údaj (sekundy)");
40        }
41        else
42        {
43            throw new ArgumentException("Neplatný formát časového údaje. Očekáváno 10, 13 nebo 16 číslic.");
44        }
45        
46        // Formátovací řetězec na základě preference 12hodinového nebo 24hodinového
47        string formatString = use12Hour 
48            ? "dddd, MMMM d, yyyy h:mm:ss tt"  // 12hodinový formát s AM/PM
49            : "dddd, MMMM d, yyyy HH:mm:ss";   // 24hodinový formát
50        
51        // Vrátit formátovaný řetězec data
52        return dateTime.ToString(formatString);
53    }
54    
55    static void Main()
56    {
57        try
58        {
59            // Standardní unixový časový údaj (10 číslic)
60            Console.WriteLine(ConvertTimestamp("1609459200", false));
61            
62            // Milisekundová přesnost (13 číslic)
63            Console.WriteLine(ConvertTimestamp("1609459200000", false));
64            
65            // Mikrosekundová přesnost (16 číslic)
66            Console.WriteLine(ConvertTimestamp("1609459200000000", true));
67        }
68        catch (ArgumentException e)
69        {
70            Console.WriteLine(e.Message);
71        }
72    }
73}
74

Řešení okrajových případů

Při práci s unixovými časovými údaji různých přesností je důležité správně zpracovávat okrajové případy. Zde je příklad, který demonstruje komplexní zpracování okrajových případů:

1// JavaScript komplexní zpracování okrajových případů pro více formátů časového údaje
2function safeConvertTimestamp(timestamp, use12Hour = false) {
3  // Validace vstupu
4  if (timestamp === undefined || timestamp === null || timestamp === '') {
5    return "Chyba: Prázdný nebo nedefinovaný časový údaj";
6  }
7  
8  // Zajistit, aby časový údaj byl řetězec pro kontrolu délky
9  const timestampStr = String(timestamp).trim();
10  
11  // Zkontrolovat, zda časový údaj obsahuje pouze číslice
12  if (!/^\d+$/.test(timestampStr)) {
13    return "Chyba: Časový údaj musí obsahovat pouze číslice";
14  }
15  
16  // Detekovat formát na základě délky
17  let date;
18  try {
19    if (timestampStr.length === 16) {
20      // Mikrosekundová přesnost
21      const microseconds = Number(timestampStr);
22      date = new Date(microseconds / 1000); // Převést na milisekundy
23      console.log("Zpracovává se mikrosekundový časový údaj (16 číslic)");
24      
25      // Zkontrolovat neplatné datum
26      if (isNaN(date.getTime())) {
27        return "Chyba: Neplatný mikrosekundový časový údaj";
28      }
29    } else if (timestampStr.length === 13) {
30      // Milisekundová přesnost
31      const milliseconds = Number(timestampStr);
32      date = new Date(milliseconds);
33      console.log("Zpracovává se milisekundový časový údaj (13 číslic)");
34      
35      // Zkontrolovat neplatné datum
36      if (isNaN(date.getTime())) {
37        return "Chyba: Neplatný milisekundový časový údaj";
38      }
39    } else if (timestampStr.length === 10) {
40      // Standardní unixový časový údaj (sekundy)
41      const seconds = Number(timestampStr);
42      date = new Date(seconds * 1000);
43      console.log("Zpracovává se standardní časový údaj (10 číslic)");
44      
45      // Zkontrolovat neplatné datum
46      if (isNaN(date.getTime())) {
47        return "Chyba: Neplatný standardní časový údaj";
48      }
49      
50      // Zkontrolovat problém s Y2K38 (pro 32bitové systémy)
51      const maxInt32 = 2147483647; // Maximální hodnota pro 32bitové podepsané celé číslo
52      if (seconds > maxInt32) {
53        console.warn("Upozornění: Časový údaj překračuje limit 32bitového celého čísla (problém Y2K38)");
54      }
55    } else {
56      return "Chyba: Neplatná délka časového údaje. Očekáváno 10, 13 nebo 16 číslic.";
57    }
58    
59    // Formátovat datum
60    const options = {
61      year: 'numeric',
62      month: 'long',
63      day: 'numeric',
64      weekday: 'long',
65      hour: use12Hour ? 'numeric' : '2-digit',
66      minute: '2-digit',
67      second: '2-digit',
68      hour12: use12Hour
69    };
70    
71    return date.toLocaleString(undefined, options);
72  } catch (error) {
73    return "Chyba při převodu časového údaje: " + error.message;
74  }
75}
76
77// Test s různými okrajovými případy
78console.log(safeConvertTimestamp("1609459200"));      // Standardní (10 číslic)
79console.log(safeConvertTimestamp("1609459200000"));   // Milisekundy (13 číslic)
80console.log(safeConvertTimestamp("1609459200000000")); // Mikrosekundy (16 číslic)
81console.log(safeConvertTimestamp("abc123"));          // Nečíselný
82console.log(safeConvertTimestamp("12345"));           // Neplatná délka
83console.log(safeConvertTimestamp("9999999999999999")); // Velmi velký mikrosekundový časový údaj
84console.log(safeConvertTimestamp(""));                // Prázdný řetězec
85

Často kladené otázky

Co je unixový časový údaj?

Unixový časový údaj je počet sekund, které uplynuly od 1. ledna 1970 (půlnoc UTC/GMT), bez započítání přestupných sekund. Poskytuje kompaktní, jazykově nezávislý způsob reprezentace konkrétního okamžiku v čase.

Jak funguje automatická detekce formátu časového údaje?

Konvertor automaticky detekuje formát časového údaje na základě počtu číslic:

• 10 číslic: Standardní unixový časový údaj (sekundy od epochy)
• 13 číslic: Milisekundový časový údaj
• 16 číslic: Mikrosekundový časový údaj

Proč bych potřeboval milisekundovou nebo mikrosekundovou přesnost?

Milisekundová přesnost (13 číslic) je užitečná pro aplikace vyžadující přesnější měření času, jako je sledování výkonu, sledování interakcí uživatelů a určité finanční aplikace. Mikrosekundová přesnost (16 číslic) je nezbytná pro vysoce výkonné počítačové aplikace, vědecké aplikace a systémy vysokofrekvenčního obchodování, kde je kritické extrémně přesné časování.

Mohu převádět data před rokem 1970 pomocí unixových časových údajů?

Ano, data před 1. lednem 1970 jsou reprezentována pomocí negativních časových údajů. Nicméně, některé systémy nemusí správně zpracovávat negativní časové údaje, takže je důležité otestovat tuto funkčnost, pokud potřebujete pracovat s historickými daty.

Co je problém roku 2038?

Problém roku 2038 nastává, protože mnoho systémů ukládá unixové časové údaje jako 32bitová podepsaná celá čísla, která mohou reprezentovat pouze data do 19. ledna 2038 (03:14:07 UTC). Po tomto datu se celé číslo přeteče, což může potenciálně způsobit selhání systému. Moderní systémy stále častěji používají 64bitová celá čísla, aby se tomuto problému vyhnuly.

Jak mohu zpracovat převody časových pásem s unixovými časovými údaji?

Unixové časové údaje jsou vždy v UTC (Coordinated Universal Time). Pro převod na konkrétní časové pásmo je třeba po převodu časového údaje na datum aplikovat příslušný posun. Většina programovacích jazyků poskytuje vestavěné funkce pro zpracování převodů časových pásem.

Jaká je přesnost unixových časových údajů?

Standardní unixové časové údaje mají přesnost na úrovni sekund. Pro aplikace vyžadující větší přesnost poskytují milisekundové časové údaje (13 číslic) přesnost na úrovni 1/1000 sekundy a mikrosekundové časové údaje (16 číslic) poskytují přesnost na úrovni 1/1 000 000 sekundy.

Zohledňují unixové časové údaje přestupné sekundy?

Ne, unixový čas je definován jako počet sekund od epochy, bez započítání přestupných sekund. To znamená, že během přestupné sekundy se unixový čas nezvyšuje. To může způsobit problémy v aplikacích vyžadujících přesný astronomický čas.

Mohu používat unixové časové údaje pro plánování budoucích událostí?

Ano, unixové časové údaje se široce používají pro plánování. Nicméně, pro velmi vzdálená budoucí data buďte si vědomi potenciálních omezení, jako je problém roku 2038 pro 32bitové systémy a zpracování změn časových pásem a přechodů na letní čas.

Odkazy

1. "Unix Time." Wikipedia, Wikimedia Foundation, https://en.wikipedia.org/wiki/Unix_time

2. "Problém roku 2038." Wikipedia, Wikimedia Foundation, https://en.wikipedia.org/wiki/Year_2038_problem

3. Olson, Arthur David. "Složitosti kalendářního času." The Open Group, https://www.usenix.org/legacy/events/usenix01/full_papers/olson/olson.pdf

4. "ISO 8601." Wikipedia, Wikimedia Foundation, https://en.wikipedia.org/wiki/ISO_8601

5. "RFC 3339: Datum a čas na internetu: Časové údaje." Internet Engineering Task Force (IETF), https://tools.ietf.org/html/rfc3339

6. Kernighan, Brian W., a Dennis M. Ritchie. "Programovací jazyk C." Prentice Hall, 1988.

7. "Přesné časování ve vysoce výkonném počítačovém zpracování." ACM Computing Surveys, https://dl.acm.org/doi/10.1145/3232678

8. "Reprezentace času ve finančních systémech." Journal of Financial Technology, https://www.fintech-journal.com/time-representation

Vyzkoušejte náš konvertor časových údajů nyní, abyste snadno převáděli unixové časové údaje jakékoli přesnosti na čitelná data. Ať už pracujete se standardními unixovými časovými údaji, milisekundovou přesností nebo mikrosekundovou přesností, náš nástroj automaticky detekuje formát a poskytuje přesné konverze.