Unix Timestamp Converter

Įvadas

Unix timestampas (dar žinomas kaip POSIX laikas arba Epoch laikas) yra sistema, apibūdinanti tam tikrą laiko momentą. Tai yra sekundžių skaičius, kuris praėjo nuo 1970 m. sausio 1 d. (vidurnaktis UTC/GMT), neskaičiuojant šuolių sekundžių. Unix timestampai plačiai naudojami kompiuterių sistemose ir programavimo kalbose, nes jie suteikia kompaktišką, kalbai nepriklausomą tam tikro momento laiko atvaizdavimą.

Šis timestampų į datą konverteris automatiškai aptinka ir apdoroja įvairių ilgių timestampus, įskaitant mikrosekundžių tikslumą (16 skaitmenų), milisekundžių tikslumą (13 skaitmenų) ir standartinius Unix timestampus (10 skaitmenų). Įrankis nustato timestampo formatą pagal įvesties ilgį, konvertuoja jį į žmogui skaitomą datą ir laiką ir rodo rezultatą, nereikalaujant vartotojams nurodyti timestampo tipo. Jis palaiko tiek 12 valandų (AM/PM), tiek 24 valandų laiko formatus, kad atitiktų skirtingus regioninius ir asmeninius pageidavimus.

Kaip veikia Unix timestampai

Unix timestampai skaičiuojami kaip sekundžių skaičius nuo Unix Epoch (1970 m. sausio 1 d., 00:00:00 UTC). Tai daro juos ypač naudinga skaičiuojant laiko skirtumus ir saugant datas kompaktišku formatu.

Matematinis konvertavimas iš Unix timestampo į kalendorinę datą apima kelis žingsnius:

1. Pradėkite nuo Unix Epoch (1970 m. sausio 1 d., 00:00:00 UTC)
2. Pridėkite timestampo sekundžių skaičių
3. Apskaičiuokite šuolių metus, skirtingus mėnesių ilgius ir kitas kalendoriaus sudėtingybes
4. Jei reikia, pritaikykite laiko juostos korekcijas

Pavyzdžiui, Unix timestampas 1609459200 atitinka penktadienį, 2021 m. sausio 1 d., 00:00:00 UTC.

Konversijos formulė gali būti išreikšta taip:

$\text{Data} = \text{Unix Epoch} + \text{Timestamp (sekundėmis)}$

Dauguma programavimo kalbų ir operacinių sistemų teikia įmontuotas funkcijas šiai konversijai atlikti, abstrahuodamos sudėtingus kalendoriaus skaičiavimus.

Timestampo formatai ir automatinis aptikimas

Mūsų konverteris palaiko tris įprastus timestampo formatus, kurie automatiškai nustatomi pagal skaitmenų skaičių:

1. Standartinis Unix timestampas (10 skaitmenų): Atspindi sekundes nuo Unix Epoch. Pavyzdys: 1609459200 (2021 m. sausio 1 d., 00:00:00 UTC)

2. Milisekundžių tikslumas (13 skaitmenų): Atspindi milisekundes nuo Unix Epoch. Pavyzdys: 1609459200000 (2021 m. sausio 1 d., 00:00:00 UTC)

3. Mikrosekundžių tikslumas (16 skaitmenų): Atspindi mikrosekundes nuo Unix Epoch. Pavyzdys: 1609459200000000 (2021 m. sausio 1 d., 00:00:00 UTC)

Automatinis aptikimas veikia analizuojant įvesties ilgį:

• Jei įvestis turi 10 skaitmenų, ji laikoma standartiniu Unix timestampu (sekundėmis)
• Jei įvestis turi 13 skaitmenų, ji laikoma milisekundiniu timestampu
• Jei įvestis turi 16 skaitmenų, ji laikoma mikrosekundiniu timestampu

Šis automatinis aptikimas pašalina būtinybę vartotojams nurodyti timestampo tipą, todėl įrankis yra patogesnis ir efektyvesnis.

Laiko formato parinktys

Šis konverteris siūlo dvi laiko formato parinktis:

1. 24 valandų formatas (kartais vadinamas "kariniu laiku"): Valandos svyruoja nuo 0 iki 23, o AM/PM žymėjimas nėra naudojamas. Pavyzdžiui, 15:00 atitinka 3:00 PM.

2. 12 valandų formatas: Valandos svyruoja nuo 1 iki 12, su AM (ante meridiem) laikams nuo vidurnakčio iki pietų ir PM (post meridiem) laikams nuo pietų iki vidurnakčio. Pavyzdžiui, 15:00 24 valandų formatu atitinka 3:00 PM.

Pasirinkimas tarp šių formatų daugiausia priklauso nuo regioninės tradicijos ir asmeninių pageidavimų:

• 24 valandų formatas dažnai naudojamas daugumoje Europos, Lotynų Amerikos ir Azijos šalių, taip pat moksliniuose, kariniuose ir medicininiuose kontekstuose visame pasaulyje.
• 12 valandų formatas paplitęs JAV, Kanadoje, Australijoje ir kai kuriose kitose anglakalbių šalių kasdieniniame naudojime.

Kraštutiniai atvejai ir apribojimai

Dirbant su įvairių tikslumų Unix timestampais, svarbu žinoti kelis kraštutinius atvejus ir apribojimus:

1. Neigiami timestampai: Šie atspindi datas prieš Unix Epoch (1970 m. sausio 1 d.). Nors matematiškai tai yra galimi, kai kurios sistemos gali neteisingai apdoroti neigiamus timestampus. Tai taikoma visiems trims timestampo formatams.

2. 2038 metų problema: Standartiniai Unix timestampai (10 skaitmenų) dažnai saugomi kaip 32 bitų pasirašyti sveikieji skaičiai, kurie perpildys 2038 m. sausio 19 d. Po šio taško 32 bitų sistemos negalės teisingai atvaizduoti laikų, nebent bus modifikuotos, kad naudotų didesnį sveikąjį tipą.

3. Tikslumo svarstymai:

   • Standartiniai timestampai (10 skaitmenų) turi sekundės lygio tikslumą, kuris yra pakankamas daugumai kasdienių programų.
   • Milisekundiniai timestampai (13 skaitmenų) suteikia 1000 kartų didesnį tikslumą, naudingą programoms, kurioms reikia tikslesnio laiko matavimo.
   • Mikrosekundiniai timestampai (16 skaitmenų) siūlo dar smulkesnį tikslumą (1/1,000,000 sekundės), kuris būtinas aukštos našumo skaičiavimams, mokslinėms programoms ir tam tikroms finansinėms operacijoms.

4. Labai dideli timestampai: Labai tolimos ateities datos gali būti neįmanomos atvaizduoti kai kuriose sistemose arba gali būti tvarkomos nesuderinamai. Tai ypač aktualu milisekundiniams ir mikrosekundiniams timestampams, kurie naudoja didesnius skaitmeninius vertes.

5. Šuolių sekundės: Unix laikas neatsižvelgia į šuolių sekundes, kurios kartais pridedamos prie UTC, kad kompensuotų Žemės nereguliarų sukimąsi. Tai reiškia, kad Unix laikas nėra tiksliai sinchronizuotas su astronominiu laiku.

6. Laiko juostų svarstymai: Unix timestampai atspindi momentus UTC. Konvertavimas į vietinį laiką reikalauja papildomos laiko juostos informacijos.

7. Vasaros laiko pokyčiai: Konvertuojant timestampus į vietinį laiką, reikia atsižvelgti į Vasaros laiko perėjimo sudėtingumus.

8. Timestampo formato painiava: Be tinkamo aptikimo, 13 skaitmenų milisekundinis timestampas gali būti neteisingai interpretuojamas kaip labai tolima ateities data, jei jis laikomas sekundiniu timestampu. Mūsų konverteris to išvengia automatiškai nustatydamas formatą pagal skaitmenų ilgį.

Naudojimo atvejai

Unix timestampai įvairių tikslumų naudojami daugybėje programų kompiuterijoje ir duomenų valdyme:

1. Duomenų bazės įrašai: Timestampai dažnai naudojami norint užfiksuoti, kada įrašai buvo sukurti arba modifikuoti.

   • Standartiniai timestampai (10 skaitmenų) dažnai yra pakankami bendrai duomenų bazės programoms.
   • Milisekundiniai timestampai (13 skaitmenų) naudojami, kai reikia tikslesnio įvykių užsakymo.

2. Žiniatinklio kūrimas: HTTP antraštės, slapukai ir talpinimo mechanizmai dažnai naudoja Unix timestampus.

   • JavaScript Date.now() grąžina milisekundinius timestampus (13 skaitmenų).

3. Žurnalo failai: Sistemos žurnalai paprastai įrašo įvykius su Unix timestampais, kad būtų užtikrintas tikslus chronologinis užsakymas.

   • Aukšto dažnio žurnalo sistemose gali būti naudojamas milisekundinis arba mikrosekundinis tikslumas.

4. Versijų kontrolės sistemos: Git ir kitos VCS naudoja timestampus, kad užfiksuotų, kada buvo atlikti įsipareigojimai.

5. API atsakymai: Daugelis žiniatinklio API įtraukia timestampus į savo atsakymus, kad nurodytų, kada duomenys buvo sugeneruoti arba kada ištekliai buvo paskutinį kartą modifikuoti.

   • REST API dažnai naudoja milisekundinius timestampus.

6. Failų sistemos: Failų sukūrimo ir modifikavimo laikai dažnai saugomi kaip Unix timestampai.

7. Sesijų valdymas: Žiniatinklio programos naudoja timestampus, kad nustatytų, kada vartotojo sesijos turėtų pasibaigti.

8. Duomenų analizė: Timestampai suteikia standartizuotą būdą dirbti su laiko duomenimis analitikos programose.

9. Aukšto dažnio prekyba: Finansinės sistemos dažnai reikalauja mikrosekundinio tikslumo (16 skaitmenų), kad tiksliai sekti sandorius.

10. Moksliniai matavimai: Tyrimų įranga gali užfiksuoti stebėjimus mikrosekundiniu tikslumu, kad būtų galima tiksliai analizuoti laiką.

Alternatyvos

Nors Unix timestampai yra plačiai naudojami, yra alternatyvūs laiko atvaizdavimo formatai, kurie gali būti tinkamesni tam tikrose kontekstuose:

1. ISO 8601: Standartizuotas eilutės formatas (pvz., "2021-01-01T00:00:00Z"), kuris yra žmogui skaitomas, išlaikant rūšiavimo galimybes. Jis dažnai pageidaujamas duomenų mainams ir vartotojams skirtoms programoms.

2. RFC 3339: ISO 8601 profiliavimas, naudojamas interneto protokoluose, su griežtesniais formatavimo reikalavimais.

3. Žmogui skaitomi formatai: Lokalizuotos datos eilutės (pvz., "2021 m. sausio 1 d.") yra labiau tinkamos tiesioginiam vartotojų sąveikai, tačiau mažiau tinkamos skaičiavimams.

4. Microsoft FILETIME: 64 bitų reikšmė, atspindinti 100 nanosekundžių intervalus nuo 1601 m. sausio 1 d., naudojama Windows sistemose.

5. Juliano dienos numeris: Naudojamas astronomijoje ir kai kuriose mokslinėse programose, skaičiuojant dienas nuo 4713 m. pr. m. e. sausio 1 d.

Laiko formato pasirinkimas priklauso nuo tokių veiksnių kaip:

• Reikalingas tikslumas
• Žmogaus skaitomumo poreikiai
• Saugojimo apribojimai
• Suderinamumas su esamomis sistemomis
• Reikalingas datų diapazonas

Istorija

Unix laiko koncepcija atsirado kartu su Unix operacinės sistemos kūrimu Bell Labs vėlyvųjų 1960-ųjų ir ankstyvųjų 1970-ųjų metų. Sprendimas naudoti 1970 m. sausio 1 d. kaip epochą buvo šiek tiek savavališkas, tačiau praktiškas tuo metu – jis buvo pakankamai neseniai, kad sumažintų saugojimo reikalavimus svarbioms datoms, tačiau pakankamai seniai, kad būtų naudinga istoriniams duomenims.

Pradinė įgyvendinimas naudojo 32 bitų pasirašytą sveikąjį skaičių, kad saugotų sekundžių skaičių, kas buvo pakankama numatomam Unix sistemų gyvavimo laikui. Tačiau ši sprendimas sukėlė 2038 metų problemą (kartais vadinamą "Y2K38" arba "Unix tūkstantmečio klaida"), nes 32 bitų pasirašyti sveikieji skaičiai gali atspindėti datas tik iki 2038 m. sausio 19 d. (03:14:07 UTC).

Kaip kompiuteriniai poreikiai vystėsi, didesnio tikslumo timestampai tapo būtini:

• Milisekundžių tikslumas (13 skaitmenų) tapo įprastas su interaktyvios kompiuterijos atsiradimu ir poreikiu matuoti vartotojo sąsajos reakcijos laiką.

• Mikrosekundžių tikslumas (16 skaitmenų) atsirado su aukštos našumo kompiuterinėmis programomis ir sistemomis, reikalaujančiomis labai tikslaus laiko matavimo.

Kaip Unix ir Unix tipo operacinės sistemos įgavo populiarumą, Unix timestampas tapo de facto standartu laiko atvaizdavimui kompiuterijoje. Jis buvo priimtas daugelio programavimo kalbų, duomenų bazių ir programų, išplėsdamos toli už savo pradinės Unix aplinkos.

Šiuolaikinės sistemos vis dažniau naudoja 64 bitų sveikuosius skaičius timestampams, kas prailgina atvaizduojamą diapazoną iki maždaug 292 milijardų metų abiem kryptimis nuo epochos, efektyviai išsprendžiant 2038 metų problemą. Tačiau senesnės sistemos ir programos gali vis dar būti pažeidžiamos.

Unix timestampo paprastumas ir naudingumas užtikrino jo tęstinį aktualumą nepaisant sudėtingesnių laiko atvaizdavimo formatų kūrimo. Jis išlieka pagrindine koncepcija kompiuterijoje, sudarančia daug mūsų skaitmeninės infrastruktūros.

Kodo pavyzdžiai

Štai pavyzdžiai, kaip konvertuoti Unix timestampus įvairių tikslumų į žmogui skaitomas datas įvairiose programavimo kalbose:

1// JavaScript timestampų konvertavimas su automatinio formato aptikimu
2function convertTimestamp(timestamp, use12Hour = false) {
3  // Konvertuoti eilutę į skaičių, jei reikia
4  const numericTimestamp = Number(timestamp);
5  
6  // Nustatyti timestampo formatą pagal skaitmenų ilgį
7  let date;
8  if (timestamp.length === 16) {
9    // Mikrosekundžių tikslumas (padalinti iš 1,000,000, kad gautume sekundes)
10    date = new Date(numericTimestamp / 1000);
11    console.log("Aptikta: Mikrosekundžių tikslumo timestampas");
12  } else if (timestamp.length === 13) {
13    // Milisekundžių tikslumas
14    date = new Date(numericTimestamp);
15    console.log("Aptikta: Milisekundžių tikslumo timestampas");
16  } else if (timestamp.length === 10) {
17    // Standartinis Unix timestampas (sekundės)
18    date = new Date(numericTimestamp * 1000);
19    console.log("Aptikta: Standartinis Unix timestampas (sekundės)");
20  } else {
21    throw new Error("Neteisingas timestampo formatas. Tikėtasi 10, 13 arba 16 skaitmenų.");
22  }
23  
24  // Formatavimo parinktys
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  // Konvertuoti į eilutę naudojant lokalizuotą formatavimą
37  return date.toLocaleString(undefined, options);
38}
39
40// Pavyzdžio naudojimas
41try {
42  // Standartinis Unix timestampas (10 skaitmenų)
43  console.log(convertTimestamp("1609459200", false)); 
44  
45  // Milisekundžių tikslumas (13 skaitmenų)
46  console.log(convertTimestamp("1609459200000", false)); 
47  
48  // Mikrosekundžių tikslumas (16 skaitmenų)
49  console.log(convertTimestamp("1609459200000000", true)); 
50} catch (error) {
51  console.error(error.message);
52}
53

1# Python timestampų konvertavimas su automatinio formato aptikimu
2import datetime
3
4def convert_timestamp(timestamp, use_12hour=False):
5    # Konvertuoti į sveikąjį skaičių
6    timestamp = str(timestamp).strip()
7    numeric_timestamp = int(timestamp)
8    
9    # Nustatyti timestampo formatą pagal skaitmenų ilgį
10    if len(timestamp) == 16:
11        # Mikrosekundžių tikslumas (padalinti iš 1,000,000, kad gautume sekundes)
12        date = datetime.datetime.fromtimestamp(numeric_timestamp / 1000000)
13        print("Aptikta: Mikrosekundžių tikslumo timestampas")
14    elif len(timestamp) == 13:
15        # Milisekundžių tikslumas (padalinti iš 1,000, kad gautume sekundes)
16        date = datetime.datetime.fromtimestamp(numeric_timestamp / 1000)
17        print("Aptikta: Milisekundžių tikslumo timestampas")
18    elif len(timestamp) == 10:
19        # Standartinis Unix timestampas (sekundės)
20        date = datetime.datetime.fromtimestamp(numeric_timestamp)
21        print("Aptikta: Standartinis Unix timestampas (sekundės)")
22    else:
23        raise ValueError("Neteisingas timestampo formatas. Tikėtasi 10, 13 arba 16 skaitmenų.")
24    
25    # Formatavimo datos eilutė
26    if use_12hour:
27        format_string = "%A, %B %d, %Y %I:%M:%S %p"  # 12 valandų formatas su AM/PM
28    else:
29        format_string = "%A, %B %d, %Y %H:%M:%S"     # 24 valandų formatas
30    
31    return date.strftime(format_string)
32
33# Pavyzdžio naudojimas
34try:
35    # Standartinis Unix timestampas (10 skaitmenų)
36    print(convert_timestamp("1609459200", False))
37    
38    # Milisekundžių tikslumas (13 skaitmenų)
39    print(convert_timestamp("1609459200000", False))
40    
41    # Mikrosekundžių tikslumas (16 skaitmenų)
42    print(convert_timestamp("1609459200000000", True))
43except ValueError as e:
44    print(e)
45

1<?php
2// PHP timestampų konvertavimas su automatinio formato aptikimu
3function convertTimestamp($timestamp, $use12Hour = false) {
4    // Užtikrinti, kad timestampas būtų eilutė, kad būtų galima patikrinti ilgį
5    $timestamp = trim((string)$timestamp);
6    
7    // Nustatyti timestampo formatą pagal skaitmenų ilgį
8    if (strlen($timestamp) === 16) {
9        // Mikrosekundžių tikslumas (padalinti iš 1,000,000, kad gautume sekundes)
10        $seconds = $numericTimestamp / 1000000;
11        echo "Aptikta: Mikrosekundžių tikslumo timestampas\n";
12    } elseif (strlen($timestamp) === 13) {
13        // Milisekundžių tikslumas
14        $seconds = $numericTimestamp / 1000;
15        echo "Aptikta: Milisekundžių tikslumo timestampas\n";
16    } elseif (strlen($timestamp) === 10) {
17        // Standartinis Unix timestampas (sekundės)
18        $seconds = $numericTimestamp;
19        echo "Aptikta: Standartinis Unix timestampas (sekundės)\n";
20    } else {
21        throw new Exception("Neteisingas timestampo formatas. Tikėtasi 10, 13 arba 16 skaitmenų.");
22    }
23    
24    // Formatavimo eilutė
25    $formatString = $use12Hour 
26        ? 'l, F j, Y g:i:s A'  // 12 valandų formatas su AM/PM
27        : 'l, F j, Y H:i:s';   // 24 valandų formatas
28    
29    // Konvertuoti ir formatuoti datą
30    return date($formatString, $seconds);
31}
32
33// Pavyzdžio naudojimas
34try {
35    // Standartinis Unix timestampas (10 skaitmenų)
36    echo convertTimestamp("1609459200", false) . "\n";
37    
38    // Milisekundžių tikslumas (13 skaitmenų)
39    echo convertTimestamp("1609459200000", false) . "\n";
40    
41    // Mikrosekundžių tikslumas (16 skaitmenų)
42    echo convertTimestamp("1609459200000000", true) . "\n";
43} catch (Exception $e) {
44    echo $e->getMessage() . "\n";
45}
46?>
47

1// Java timestampų konvertavimas su automatinio formato aptikimu
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        // Nupjauti įvestį
10        timestamp = timestamp.trim();
11        
12        // Nustatyti timestampo formatą pagal skaitmenų ilgį
13        LocalDateTime dateTime;
14        if (timestamp.length() == 16) {
15            // Mikrosekundžių tikslumas (padalinti iš 1,000,000, kad gautume sekundes)
16            long microseconds = Long.parseLong(timestamp);
17            Instant instant = Instant.ofEpochSecond(0, microseconds * 1000); // Konvertuoti į nanosekundes
18            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
19            System.out.println("Aptikta: Mikrosekundžių tikslumo timestampas");
20        } else if (timestamp.length() == 13) {
21            // Milisekundžių tikslumas
22            long milliseconds = Long.parseLong(timestamp);
23            Instant instant = Instant.ofEpochMilli(milliseconds);
24            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
25            System.out.println("Aptikta: Milisekundžių tikslumo timestampas");
26        } else if (timestamp.length() == 10) {
27            // Standartinis Unix timestampas (sekundės)
28            long seconds = Long.parseLong(timestamp);
29            Instant instant = Instant.ofEpochSecond(seconds);
30            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
31            System.out.println("Aptikta: Standartinis Unix timestampas (sekundės)");
32        } else {
33            throw new IllegalArgumentException("Neteisingas timestampo formatas. Tikėtasi 10, 13 arba 16 skaitmenų.");
34        }
35        
36        // Sukurti formatavimo objektą pagal pageidaujamą formatą
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        // Formatuoti datą
42        return dateTime.format(formatter);
43    }
44    
45    public static void main(String[] args) {
46        try {
47            // Standartinis Unix timestampas (10 skaitmenų)
48            System.out.println(convertTimestamp("1609459200", false));
49            
50            // Milisekundžių tikslumas (13 skaitmenų)
51            System.out.println(convertTimestamp("1609459200000", false));
52            
53            // Mikrosekundžių tikslumas (16 skaitmenų)
54            System.out.println(convertTimestamp("1609459200000000", true));
55        } catch (IllegalArgumentException e) {
56            System.err.println(e.getMessage());
57        }
58    }
59}
60

1// C# timestampų konvertavimas su automatinio formato aptikimu
2using System;
3
4class TimestampConverter
5{
6    public static string ConvertTimestamp(string timestamp, bool use12Hour)
7    {
8        // Nupjauti įvestį
9        timestamp = timestamp.Trim();
10        
11        // Nustatyti timestampo formatą pagal skaitmenų ilgį
12        DateTime dateTime;
13        if (timestamp.Length == 16)
14        {
15            // Mikrosekundžių tikslumas (padalinti iš 1,000,000, kad gautume sekundes)
16            if (!double.TryParse(timestamp, out double microseconds))
17                throw new ArgumentException("Neteisingas timestampo formatas");
18                
19            // Konvertuoti mikrosekundes į DateTime
20            dateTime = DateTimeOffset.FromUnixTimeSeconds(0).DateTime.AddSeconds(microseconds / 1000000);
21            Console.WriteLine("Aptikta: Mikrosekundžių tikslumo timestampas");
22        }
23        else if (timestamp.Length == 13)
24        {
25            // Milisekundžių tikslumas
26            if (!long.TryParse(timestamp, out long milliseconds))
27                throw new ArgumentException("Neteisingas timestampo formatas");
28                
29            dateTime = DateTimeOffset.FromUnixTimeMilliseconds(milliseconds).DateTime;
30            Console.WriteLine("Aptikta: Milisekundžių tikslumo timestampas");
31        }
32        else if (timestamp.Length == 10)
33        {
34            // Standartinis Unix timestampas (sekundės)
35            if (!long.TryParse(timestamp, out long seconds))
36                throw new ArgumentException("Neteisingas timestampo formatas");
37                
38            dateTime = DateTimeOffset.FromUnixTimeSeconds(seconds).DateTime;
39            Console.WriteLine("Aptikta: Standartinis Unix timestampas (sekundės)");
40        }
41        else
42        {
43            throw new ArgumentException("Neteisingas timestampo formatas. Tikėtasi 10, 13 arba 16 skaitmenų.");
44        }
45        
46        // Formatavimo eilutė pagal 12 valandų arba 24 valandų pageidavimą
47        string formatString = use12Hour 
48            ? "dddd, MMMM d, yyyy h:mm:ss tt"  // 12 valandų formatas su AM/PM
49            : "dddd, MMMM d, yyyy HH:mm:ss";   // 24 valandų formatas
50        
51        // Grąžinti suformatuotą datos eilutę
52        return dateTime.ToString(formatString);
53    }
54    
55    static void Main()
56    {
57        try
58        {
59            // Standartinis Unix timestampas (10 skaitmenų)
60            Console.WriteLine(ConvertTimestamp("1609459200", false));
61            
62            // Milisekundžių tikslumas (13 skaitmenų)
63            Console.WriteLine(ConvertTimestamp("1609459200000", false));
64            
65            // Mikrosekundžių tikslumas (16 skaitmenų)
66            Console.WriteLine(ConvertTimestamp("1609459200000000", true));
67        }
68        catch (ArgumentException e)
69        {
70            Console.WriteLine(e.Message);
71        }
72    }
73}
74

Kraštutinių atvejų valdymas

Dirbant su Unix timestampais įvairių tikslumų, svarbu teisingai valdyti kraštutinius atvejus. Štai pavyzdys, demonstruojantis išsamų kraštutinių atvejų valdymą:

1// JavaScript išsamus kraštutinių atvejų valdymas keliems timestampo formatams
2function safeConvertTimestamp(timestamp, use12Hour = false) {
3  // Įvesties validacija
4  if (timestamp === undefined || timestamp === null || timestamp === '') {
5    return "Klaida: Tuščias arba nenustatytas timestampas";
6  }
7  
8  // Užtikrinti, kad timestampas būtų eilutė, kad būtų galima patikrinti ilgį
9  const timestampStr = String(timestamp).trim();
10  
11  // Patikrinti, ar timestampas sudarytas tik iš skaitmenų
12  if (!/^\d+$/.test(timestampStr)) {
13    return "Klaida: Timestampas turi sudaryti tik skaitmenys";
14  }
15  
16  // Nustatyti formatą pagal ilgį
17  let date;
18  try {
19    if (timestampStr.length === 16) {
20      // Mikrosekundžių tikslumas
21      const microseconds = Number(timestampStr);
22      date = new Date(microseconds / 1000); // Konvertuoti į milisekundes
23      console.log("Apdorojamas mikrosekundžių timestampas (16 skaitmenų)");
24      
25      // Patikrinti, ar data galiojanti
26      if (isNaN(date.getTime())) {
27        return "Klaida: Neteisingas mikrosekundžių timestampas";
28      }
29    } else if (timestampStr.length === 13) {
30      // Milisekundžių tikslumas
31      const milliseconds = Number(timestampStr);
32      date = new Date(milliseconds);
33      console.log("Apdorojamas milisekundžių timestampas (13 skaitmenų)");
34      
35      // Patikrinti, ar data galiojanti
36      if (isNaN(date.getTime())) {
37        return "Klaida: Neteisingas milisekundžių timestampas";
38      }
39    } else if (timestampStr.length === 10) {
40      // Standartinis Unix timestampas (sekundės)
41      const seconds = Number(timestampStr);
42      date = new Date(seconds * 1000);
43      console.log("Apdorojamas standartinis timestampas (10 skaitmenų)");
44      
45      // Patikrinti, ar data galiojanti
46      if (isNaN(date.getTime())) {
47        return "Klaida: Neteisingas standartinis timestampas";
48      }
49      
50      // Patikrinti Y2K38 problemą (32 bitų sistemoms)
51      const maxInt32 = 2147483647; // Didžiausia 32 bitų pasirašyto sveikojo skaičiaus vertė
52      if (seconds > maxInt32) {
53        console.warn("Įspėjimas: Timestampas viršija 32 bitų sveikojo skaičiaus ribą (Y2K38 problema)");
54      }
55    } else {
56      return "Klaida: Neteisingas timestampo ilgis. Tikėtasi 10, 13 arba 16 skaitmenų.";
57    }
58    
59    // Formatuoti datą
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 "Klaida konvertuojant timestampą: " + error.message;
74  }
75}
76
77// Išbandykite su įvairiais kraštutiniais atvejais
78console.log(safeConvertTimestamp("1609459200"));      // Standartinis (10 skaitmenų)
79console.log(safeConvertTimestamp("1609459200000"));   // Milisekundžių (13 skaitmenų)
80console.log(safeConvertTimestamp("1609459200000000")); // Mikrosekundžių (16 skaitmenų)
81console.log(safeConvertTimestamp("abc123"));          // Neskaitmeninis
82console.log(safeConvertTimestamp("12345"));           // Neteisingas ilgis
83console.log(safeConvertTimestamp("9999999999999999")); // Labai didelis mikrosekundinis timestampas
84console.log(safeConvertTimestamp(""));                // Tuščia eilutė
85

Dažnai užduodami klausimai

Kas yra Unix timestampas?

Unix timestampas yra sekundžių skaičius, kuris praėjo nuo 1970 m. sausio 1 d. (vidurnaktis UTC/GMT), neskaičiuojant šuolių sekundžių. Jis suteikia kompaktišką, kalbai nepriklausomą tam tikro momento laiko atvaizdavimą.

Kaip veikia automatinis timestampo formato aptikimas?

Konverteris automatiškai nustato timestampo formatą pagal skaitmenų skaičių:

• 10 skaitmenų: Standartinis Unix timestampas (sekundės nuo epochos)
• 13 skaitmenų: Milisekundžių tikslumo timestampas
• 16 skaitmenų: Mikrosekundžių tikslumo timestampas

Kodėl man reikalingas milisekundžių ar mikrosekundžių tikslumas?

Milisekundžių tikslumas (13 skaitmenų) yra naudingas programoms, kurioms reikia tikslesnio laiko matavimo, tokioms kaip našumo stebėjimas, vartotojo sąveikos sekimas ir tam tikros finansinės programos. Mikrosekundžių tikslumas (16 skaitmenų) būtinas aukštos našumo skaičiavimams, mokslinėms programoms ir aukšto dažnio prekybos sistemoms, kur tikslus laikas yra kritiškai svarbus.

Ar galiu konvertuoti datas prieš 1970 m. naudojant Unix timestampus?

Taip, datos prieš 1970 m. sausio 1 d. atvaizduojamos naudojant neigiamus timestampus. Tačiau kai kurios sistemos gali neteisingai apdoroti neigiamus timestampus, todėl svarbu išbandyti šią funkciją, jei reikia dirbti su istorinių datų.

Kas yra 2038 metų problema?

2038 metų problema kyla dėl to, kad daugelis sistemų saugo Unix timestampus kaip 32 bitų pasirašytus sveikuosius skaičius, kurie gali atspindėti datas tik iki 2038 m. sausio 19 d. (03:14:07 UTC). Po šio taško sveikasis skaičius perpildys, potencialiai sukeldamas sistemos gedimus. Šiuolaikinės sistemos vis dažniau naudoja 64 bitų sveikuosius skaičius, kad išvengtų šios problemos.

Kaip aš galiu valdyti laiko juostų konversijas su Unix timestampais?

Unix timestampai visada yra UTC (Koordinuotas visuotinai laikas). Norint konvertuoti į konkrečią laiko juostą, reikia pritaikyti atitinkamą offsetą po timestampo konvertavimo į datą. Dauguma programavimo kalbų teikia įmontuotas funkcijas, kad būtų galima valdyti laiko juostų konversijas.

Koks skirtumas tarp Unix laiko ir ISO 8601?

Unix laikas yra skaitmeninis atvaizdavimas (sekundės nuo epochos), o ISO 8601 yra eilutės formatas (pvz., "2021-01-01T00:00:00Z"). Unix laikas yra kompaktiškesnis ir lengviau naudojamas skaičiavimams, tuo tarpu ISO 8601 yra labiau žmogui skaitomas ir savarankiškai aprašomas.

Kiek tikslūs yra Unix timestampai?

Standartiniai Unix timestampai turi sekundės lygio tikslumą. Programoms, reikalaujančioms didesnio tikslumo, milisekundiniai timestampai (13 skaitmenų) suteikia 1/1000 sekundės tikslumą, o mikrosekundiniai timestampai (16 skaitmenų) suteikia 1/1,000,000 sekundės tikslumą.

Ar Unix timestampai atsižvelgia į šuolių sekundes?

Ne, Unix laikas apibrėžiamas kaip sekundžių skaičius nuo epochos, neatsižvelgiant į šuolių sekundes. Tai reiškia, kad šuolių sekundės metu Unix timestampas nepadidėja. Tai gali sukelti problemų programose, reikalaujančiose tikslaus astronominio laiko.

Ar galiu naudoti Unix timestampus planuojant ateities įvykius?

Taip, Unix timestampai plačiai naudojami planuojant. Tačiau turint omenyje labai tolimas ateities datas, reikia būti atsargiems dėl galimų apribojimų, tokių kaip 2038 metų problema 32 bitų sistemoms ir laiko juostų pokyčių bei vasaros laiko perėjimų tvarkymas.

Nuorodos

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

2. "Year 2038 Problem." Wikipedia, Wikimedia Foundation, https://en.wikipedia.org/wiki/Year_2038_problem

3. Olson, Arthur David. "The Complexities of Calendrical Time." 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: Date and Time on the Internet: Timestamps." Internet Engineering Task Force (IETF), https://tools.ietf.org/html/rfc3339

6. Kernighan, Brian W., and Dennis M. Ritchie. "The C Programming Language." Prentice Hall, 1988.

7. "Precision Timing in High-Performance Computing." ACM Computing Surveys, https://dl.acm.org/doi/10.1145/3232678

8. "Time Representation in Financial Systems." Journal of Financial Technology, https://www.fintech-journal.com/time-representation

Išbandykite mūsų timestampų konverterį dabar, kad lengvai konvertuotumėte Unix timestampus bet kokiu tikslumu į žmogui skaitomas datas. Nesvarbu, ar dirbate su standartiniais Unix timestampais, milisekundžių tikslumu, ar mikrosekundžių tikslumu, mūsų įrankis automatiškai nustato formatą ir teikia tikslius konversijas.