Unix Timestamp Converter

Introduction

Unix timestamp (tuntud ka kui POSIX aeg või Epoch aeg) on süsteem, millega kirjeldatakse ajapunkti. See on sekundite arv, mis on möödunud 1. jaanuarist 1970 (kesköö UTC/GMT), arvestamata lisasekundeid. Unix timestamp'e kasutatakse laialdaselt arvutisüsteemides ja programmeerimiskeeltes, kuna need pakuvad kompaktset, keele sõltumatut esitamist konkreetse hetke jaoks ajas.

See timestamp'i kuupäeva konverter tuvastab ja töötleb automaatselt erineva pikkusega timestamp'e, sealhulgas mikrosekundi täpsusega (16 numbrit), millisekundi täpsusega (13 numbrit) ja standardseid Unix timestamp'e (10 numbrit). Tööriist tuvastab timestamp'i formaadi sisendi pikkuse põhjal, konverteerib selle inimloetavasse kuupäeva ja kellaaja formaati ning kuvab tulemuse ilma, et kasutajad peaksid määrama timestamp'i tüübi. See toetab nii 12-tunnist (AM/PM) kui ka 24-tunnist ajavormi, et rahuldada erinevaid piirkondlikke ja isiklikke eelistusi.

How Unix Timestamps Work

Unix timestamp'id arvutatakse kui sekundite arv alates Unix Epoch'ist (1. jaanuar 1970, 00:00:00 UTC). See teeb need eriti kasulikuks ajavahede arvutamiseks ja kuupäevade kompaktseks salvestamiseks.

Matemaatiline konversioon Unix timestamp'ist kalendri kuupäeva hõlmab mitmeid samme:

1. Alustage Unix Epoch'ist (1. jaanuar 1970, 00:00:00 UTC)
2. Lisage timestamp'is olevate sekundite arv
3. Arvestage hüppeaastaid, erinevate kuupäeva pikkusi ja muid kalendri keerukusi
4. Rakendage vajadusel ajavööndi kohandusi

Näiteks Unix timestamp 1609459200 tähistab reedet, 1. jaanuari 2021, 00:00:00 UTC.

Konversioonivalem on väljendatav järgmiselt:

$\text{Kuupäev} = \text{Unix Epoch} + \text{Timestamp (sekundites)}$

Enamik programmeerimiskeeli ja operatsioonisüsteeme pakuvad sisseehitatud funktsioone selle konversiooni käsitlemiseks, peites keerulised kalendriarvutused.

Timestamp Formats and Automatic Detection

Meie konverter toetab kolme levinud timestamp'i formaati, mida tuvastatakse automaatselt numbrite arvu põhjal:

1. Standardne Unix Timestamp (10 numbrit): Esindab sekundeid alates Unix Epoch'ist. Näide: 1609459200 (1. jaanuar 2021, 00:00:00 UTC)

2. Millisekundi täpsus (13 numbrit): Esindab millisekundeid alates Unix Epoch'ist. Näide: 1609459200000 (1. jaanuar 2021, 00:00:00 UTC)

3. Mikrosekundi täpsus (16 numbrit): Esindab mikrosekundeid alates Unix Epoch'ist. Näide: 1609459200000000 (1. jaanuar 2021, 00:00:00 UTC)

Automaatne tuvastamine töötab, analüüsides sisendi pikkust:

• Kui sisend sisaldab 10 numbrit, käsitletakse seda standardse Unix timestamp'ina (sekundid)
• Kui sisend sisaldab 13 numbrit, käsitletakse seda millisekundi timestamp'ina
• Kui sisend sisaldab 16 numbrit, käsitletakse seda mikrosekundi timestamp'ina

See automaatne tuvastamine elimineerib vajaduse, et kasutajad peaksid määrama timestamp'i tüübi, muutes tööriista kasutajasõbralikumaks ja efektiivsemaks.

Time Format Options

See konverter pakub kahte ajavormi valikut:

1. 24-tunnine formaat (mõnikord nimetatakse "sõjaväe ajaks"): Tunnid ulatuvad vahemikku 0 kuni 23, ja AM/PM tähistust ei ole. Näiteks 15:00 on esindatud kui 15:00.

2. 12-tunnine formaat: Tunnid ulatuvad vahemikku 1 kuni 12, AM (ante meridiem) ajaks, mis on vahemikus keskööst keskpäevani, ja PM (post meridiem) ajaks, mis on vahemikus keskpäevast keskööni. Näiteks 15:00 24-tunnises formaadis on esindatud kui 3:00 PM.

Valik nende formaatide vahel on peamiselt piirkondlik konventsioon ja isiklik eelistus:

• 24-tunnist formaati kasutatakse tavaliselt enamikus Euroopas, Ladina-Ameerikas ja Aasias, samuti teaduslikes, sõjaväelistes ja meditsiinilistes kontekstides üle kogu maailma.
• 12-tunnine formaat on levinud Ameerika Ühendriikides, Kanadas, Austraalias ja mõnes muus ingliskeelses riigis igapäevases kasutuses.

Edge Cases and Limitations

Unix timestamp'idega töötamisel erineva täpsusega on oluline olla teadlik mitmest äärmuslikust juhtumist ja piirangust:

1. Negatiivsed timestamp'id: Need tähistavad kuupäevi enne Unix Epoch'it (1. jaanuar 1970). Kuigi matemaatiliselt kehtivad, ei pruugi mõned süsteemid negatiivseid timestamp'e õigesti käsitleda. See kehtib kõigi kolme timestamp'i formaadi puhul.

2. Aasta 2038 probleem: Standardseid Unix timestamp'e (10 numbrit) salvestatakse sageli 32-bitiste allkirjastatud täisarvudena, mis ületavad 19. jaanuaril 2038. Standardsete 32-bitiste süsteemide puhul ei suudeta pärast seda kuupäeva aegu õigesti esitada, kui neid ei muudetud suurema täisarvu tüübi kasutamiseks.

3. Täpsuse kaalutlused:

   • Standard timestamp'id (10 numbrit) omavad sekundi tasemel täpsust, mis on piisav enamiku igapäevaste rakenduste jaoks.
   • Millisekundi timestamp'id (13 numbrit) pakuvad 1000x rohkem täpsust, mis on kasulik rakendustes, mis nõuavad täpsemat ajastust.
   • Mikrosekundi timestamp'id (16 numbrit) pakuvad veelgi peenemat granulaarsust (1,000,000 osa sekundist), mis on vajalik kõrge jõudlusega arvutustes, teaduslikes rakendustes ja teatud rahandustehingutes.

4. Äärmiselt suured timestamp'id: Väga kauged tuleviku kuupäevad võivad mõnes süsteemis olla esitatavad või neid võidakse käsitleda ebajärjekindlalt. See on eriti oluline millisekundi ja mikrosekundi timestamp'ide puhul, mis kasutavad suuremaid numbrilisi väärtusi.

5. Hüppesekundid: Unix aeg ei arvesta hüppesekundeid, mis lisatakse aeg-ajalt UTC-s, et kompenseerida Maa ebaühtlast pöörlemist. See tähendab, et Unix aeg ei ole täpselt sünkroonitud astronoomilise ajaga.

6. Ajavööndi kaalutlused: Unix timestamp'id esindavad hetki UTC-s. Kohalikku aega konverteerimiseks on vajalik täiendav ajavööndi teave.

7. Suveaja: Timestamp'ide konverteerimisel kohalikku aega tuleb arvesse võtta suveaja üleminekute keerukusi.

8. Timestamp'i formaadi segadus: Ilma nõuetekohase tuvastamiseta võib 13-numbriline millisekundi timestamp vale tõlgendamise korral tähendada väga kauget tuleviku kuupäeva, kui seda käsitletakse sekundipõhise timestamp'ina. Meie konverter takistab seda, tuvastades automaatselt formaadi numbrite pikkuse põhjal.

Use Cases

Unix timestamp'e erineva täpsusega kasutatakse mitmesugustes rakendustes arvutite ja andmehalduse valdkonnas:

1. Andmebaasi kirjed: Timestamp'e kasutatakse sageli selleks, et registreerida, millal kirjed loodi või muudeti.

   • Standardtimestamp'id (10 numbrit) on sageli piisavad üldiste andmebaasi rakenduste jaoks.
   • Millisekundi timestamp'id (13 numbrit) kasutatakse siis, kui on vajalik sündmuste täpsem järjestamine.

2. Veebiarendus: HTTP päised, küpsised ja vahemälu mehhanismid kasutavad sageli Unix timestamp'e.

   • JavaScripti Date.now() tagastab millisekundi timestamp'e (13 numbrit).

3. Logifailid: Süsteemi logid registreerivad tavaliselt sündmusi Unix timestamp'idega, et tagada täpne kronoloogiline järjestus.

   • Kõrge sagedusega logimisüsteemid võivad kasutada millisekundi või mikrosekundi täpsust.

4. Versioonihaldussüsteemid: Git ja teised VCS kasutavad timestamp'e, et registreerida, millal commit'id tehti.

5. API vastused: Paljud veeb API-d sisaldavad oma vastustes timestamp'e, et näidata, millal andmed genereeriti või millal ressursse viimati muudeti.

   • REST API-d kasutavad sageli millisekundi täpsusega timestamp'e.

6. Failisüsteemid: Failide loomise ja muutmise ajad salvestatakse sageli Unix timestamp'idena.

7. Seansihaldus: Veebirakendused kasutavad timestamp'e, et määrata, millal kasutaja seansid peaksid aeguma.

8. Andmeanalüüs: Timestamp'id pakuvad standardiseeritud viisi ajaga seotud andmetega töötamiseks analüütika rakendustes.

9. Kõrge sagedusega kauplemine: Finantsüsteemid nõuavad sageli mikrosekundi täpsust (16 numbrit), et täpselt järjestada tehingud.

10. Teaduslikud mõõtmised: Uurimisseadmed võivad registreerida vaatlusandmeid mikrosekundi täpsusega täpse ajanalüüsi jaoks.

Alternatives

Kuigi Unix timestamp'id on laialdaselt kasutusel, on teatud kontekstides sobivamad alternatiivsed aj esitusvormid:

1. ISO 8601: Standardiseeritud stringiformaat (nt "2021-01-01T00:00:00Z"), mis on inimloetav, säilitades samas sorteeritavuse. Seda eelistatakse sageli andmevahetuses ja kasutajate jaoks suunatud rakendustes.

2. RFC 3339: ISO 8601 profiil, mida kasutatakse interneti protokollides, millel on rangemad vormindamisnõuded.

3. Inimloetavad formaadid: Lokaliseeritud kuupäeva stringid (nt "1. jaanuar 2021") sobivad paremini otsese kasutajaga suhtlemiseks, kuid on vähem sobivad arvutamiseks.

4. Microsoft FILETIME: 64-bitine väärtus, mis esindab 100-nanosekundiliste intervallide arvu alates 1. jaanuarist 1601, mida kasutatakse Windows süsteemides.

5. Juuli päevade number: Kasutatakse astronoomias ja mõnedes teaduslikes rakendustes, loendades päevi alates 1. jaanuarist 4713 eKr.

Ajavormi valik sõltub sellistest teguritest nagu:

• Nõutav täpsus
• Inimese loetavuse vajadused
• Salvestuspiirangud
• Ühilduvus olemasolevate süsteemidega
• Kuupäevade vahemik, mida tuleb esindada

History

Unix aja mõisted pärinevad Unix operatsioonisüsteemi arendamisest Bell Labs'is 1960. aastate lõpus ja 1970. aastate alguses. Otsus kasutada 1. jaanuari 1970 kui epoch'i oli mõnevõrra meelevaldne, kuid praktiline tol ajal - see oli piisavalt hiline, et minimeerida huvipakkuvate kuupäevade salvestusnõudeid, kuid piisavalt kaugel minevikus, et olla kasulik ajalooliste andmete jaoks.

Algne rakendus kasutas 32-bitist allkirjastatud täisarvu, et salvestada sekundite arv, mis oli piisav Unix süsteemide oodatud eluea jaoks tol ajal. Kuid see otsus viis Aasta 2038 probleemini (mõnikord nimetatakse "Y2K38" või "Unixi aastatuhande veaks"), kuna 32-bitised allkirjastatud täisarvud saavad esindada ainult kuupäevi kuni 19. jaanuarini 2038.

Kuna arvutamisvajadused on arenenud, on suurema täpsusega timestamp'id muutunud vajalikuks:

• Millisekundi täpsus (13 numbrit) sai tavaliseks interaktiivse arvutamise tõusuga ja vajadusega mõõta kasutajaliidese reageerimiskiirus.

• Mikrosekundi täpsus (16 numbrit) tekkis kõrge jõudlusega arvutuste ja süsteemide vajaduse tõttu, mis nõuavad äärmiselt täpset ajastust.

Kuna Unix ja Unix-taolised operatsioonisüsteemid said populaarseks, muutus Unix timestamp de facto standardiks aja esindamiseks arvutites. Seda võtsid kasutusele mitmed programmeerimiskeeled, andmebaasid ja rakendused, ulatudes kaugele oma algsest Unix keskkonnast.

Kaasaegsed süsteemid kasutavad üha enam 64-bitiseid täisarve timestamp'ide jaoks, mis pikendab esitatava vahemiku umbes 292 miljardit aastat mõlemas suunas epoch'ist, lahendades tõhusalt Aasta 2038 probleemi. Siiski võivad pärand süsteemid ja rakendused endiselt olla haavatavad.

Unix timestamp'i lihtsus ja kasulikkus on taganud selle jätkuva tähtsuse hoolimata keerukamate aj esitusvormide arengust. See jääb arvutite aluseks olevaks kontseptsiooniks, mis toetab suurt osa meie digitaalsest infrastruktuurist.

Code Examples

Siin on näited, kuidas konverteerida Unix timestamp'e erineva täpsusega inimloetavateks kuupäevadeks erinevates programmeerimiskeeltes:

1// JavaScript timestamp'i konversioon automaatse formaadi tuvastamisega
2function convertTimestamp(timestamp, use12Hour = false) {
3  // Muutke string numbriks, kui on vajalik
4  const numericTimestamp = Number(timestamp);
5  
6  // Tuvastage timestamp'i formaat numbrite arvu põhjal
7  let date;
8  if (timestamp.length === 16) {
9    // Mikrosekundi täpsus (jagage 1 000 000, et saada sekundid)
10    date = new Date(numericTimestamp / 1000);
11    console.log("Tuvastatud: Mikrosekundi täpsuse timestamp");
12  } else if (timestamp.length === 13) {
13    // Millisekundi täpsus
14    date = new Date(numericTimestamp);
15    console.log("Tuvastatud: Millisekundi täpsuse timestamp");
16  } else if (timestamp.length === 10) {
17    // Standardne Unix timestamp (sekundid)
18    date = new Date(numericTimestamp * 1000);
19    console.log("Tuvastatud: Standardne Unix timestamp (sekundid)");
20  } else {
21    throw new Error("Vale timestamp'i formaat. Oodatud 10, 13 või 16 numbrit.");
22  }
23  
24  // Vormindamisvalikud
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  // Muutke stringiks, kasutades lokaali vormindamist
37  return date.toLocaleString(undefined, options);
38}
39
40// Näide kasutamisest
41try {
42  // Standardne Unix timestamp (10 numbrit)
43  console.log(convertTimestamp("1609459200", false)); 
44  
45  // Millisekundi täpsus (13 numbrit)
46  console.log(convertTimestamp("1609459200000", false)); 
47  
48  // Mikrosekundi täpsus (16 numbrit)
49  console.log(convertTimestamp("1609459200000000", true)); 
50} catch (error) {
51  console.error(error.message);
52}
53

1# Python timestamp'i konversioon automaatse formaadi tuvastamisega
2import datetime
3
4def convert_timestamp(timestamp, use_12hour=False):
5    # Muutke täisarvuks
6    timestamp = str(timestamp).strip()
7    numeric_timestamp = int(timestamp)
8    
9    # Tuvastage timestamp'i formaat numbrite arvu põhjal
10    if len(timestamp) == 16:
11        # Mikrosekundi täpsus (jagage 1 000 000, et saada sekundid)
12        date = datetime.datetime.fromtimestamp(numeric_timestamp / 1000000)
13        print("Tuvastatud: Mikrosekundi täpsuse timestamp")
14    elif len(timestamp) == 13:
15        # Millisekundi täpsus (jagage 1 000, et saada sekundid)
16        date = datetime.datetime.fromtimestamp(numeric_timestamp / 1000)
17        print("Tuvastatud: Millisekundi täpsuse timestamp")
18    elif len(timestamp) == 10:
19        # Standardne Unix timestamp (sekundid)
20        date = datetime.datetime.fromtimestamp(numeric_timestamp)
21        print("Tuvastatud: Standardne Unix timestamp (sekundid)")
22    else:
23        raise ValueError("Vale timestamp'i formaat. Oodatud 10, 13 või 16 numbrit.")
24    
25    # Vormindage kuupäeva string
26    if use_12hour:
27        format_string = "%A, %B %d, %Y %I:%M:%S %p"  # 12-tunnine formaat AM/PM
28    else:
29        format_string = "%A, %B %d, %Y %H:%M:%S"     # 24-tunnine formaat
30    
31    return date.strftime(format_string)
32
33# Näide kasutamisest
34try:
35    # Standardne Unix timestamp (10 numbrit)
36    print(convert_timestamp("1609459200", False))
37    
38    # Millisekundi täpsus (13 numbrit)
39    print(convert_timestamp("1609459200000", False))
40    
41    # Mikrosekundi täpsus (16 numbrit)
42    print(convert_timestamp("1609459200000000", True))
43except ValueError as e:
44    print(e)
45

1<?php
2// PHP timestamp'i konversioon automaatse formaadi tuvastamisega
3function convertTimestamp($timestamp, $use12Hour = false) {
4    // Veenduge, et timestamp on string, et kontrollida pikkust
5    $timestamp = trim((string)$timestamp);
6    
7    // Tuvastage timestamp'i formaat numbrite arvu põhjal
8    if (strlen($timestamp) === 16) {
9        // Mikrosekundi täpsus (jagage 1 000 000, et saada sekundid)
10        $seconds = $numericTimestamp / 1000000;
11        echo "Tuvastatud: Mikrosekundi täpsuse timestamp\n";
12    } elseif (strlen($timestamp) === 13) {
13        // Millisekundi täpsus
14        $seconds = $numericTimestamp / 1000;
15        echo "Tuvastatud: Millisekundi täpsuse timestamp\n";
16    } elseif (strlen($timestamp) === 10) {
17        // Standardne Unix timestamp (sekundid)
18        $seconds = $numericTimestamp;
19        echo "Tuvastatud: Standardne Unix timestamp (sekundid)\n";
20    } else {
21        throw new Exception("Vale timestamp'i formaat. Oodatud 10, 13 või 16 numbrit.");
22    }
23    
24    // Vormindamisstring
25    $formatString = $use12Hour 
26        ? 'l, F j, Y g:i:s A'  // 12-tunnine formaat AM/PM
27        : 'l, F j, Y H:i:s';   // 24-tunnine formaat
28    
29    // Muutke ja vormindage kuupäev
30    return date($formatString, $seconds);
31}
32
33// Näide kasutamisest
34try {
35    // Standardne Unix timestamp (10 numbrit)
36    echo convertTimestamp("1609459200", false) . "\n";
37    
38    // Millisekundi täpsus (13 numbrit)
39    echo convertTimestamp("1609459200000", false) . "\n";
40    
41    // Mikrosekundi täpsus (16 numbrit)
42    echo convertTimestamp("1609459200000000", true) . "\n";
43} catch (Exception $e) {
44    echo $e->getMessage() . "\n";
45}
46?>
47

1// Java timestamp'i konversioon automaatse formaadi tuvastamisega
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        // Trimige sisend
10        timestamp = timestamp.trim();
11        
12        // Tuvastage timestamp'i formaat numbrite arvu põhjal
13        LocalDateTime dateTime;
14        if (timestamp.length() == 16) {
15            // Mikrosekundi täpsus (jagage 1 000 000, et saada sekundid)
16            long microseconds = Long.parseLong(timestamp);
17            Instant instant = Instant.ofEpochSecond(0, microseconds * 1000); // Muutke nanosekunditeks
18            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
19            System.out.println("Tuvastatud: Mikrosekundi täpsuse timestamp");
20        } else if (timestamp.length() == 13) {
21            // Millisekundi täpsus
22            long milliseconds = Long.parseLong(timestamp);
23            Instant instant = Instant.ofEpochMilli(milliseconds);
24            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
25            System.out.println("Tuvastatud: Millisekundi täpsuse timestamp");
26        } else if (timestamp.length() == 10) {
27            // Standardne Unix timestamp (sekundid)
28            long seconds = Long.parseLong(timestamp);
29            Instant instant = Instant.ofEpochSecond(seconds);
30            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
31            System.out.println("Tuvastatud: Standardne Unix timestamp (sekundid)");
32        } else {
33            throw new IllegalArgumentException("Vale timestamp'i formaat. Oodatud 10, 13 või 16 numbrit.");
34        }
35        
36        // Looge vormindaja soovitud formaadi põhjal
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        // Vormindage kuupäev
42        return dateTime.format(formatter);
43    }
44    
45    public static void main(String[] args) {
46        try {
47            // Standardne Unix timestamp (10 numbrit)
48            System.out.println(convertTimestamp("1609459200", false));
49            
50            // Millisekundi täpsus (13 numbrit)
51            System.out.println(convertTimestamp("1609459200000", false));
52            
53            // Mikrosekundi täpsus (16 numbrit)
54            System.out.println(convertTimestamp("1609459200000000", true));
55        } catch (IllegalArgumentException e) {
56            System.err.println(e.getMessage());
57        }
58    }
59}
60

1// C# timestamp'i konversioon automaatse formaadi tuvastamisega
2using System;
3
4class TimestampConverter
5{
6    public static string ConvertTimestamp(string timestamp, bool use12Hour)
7    {
8        // Trimige sisend
9        timestamp = timestamp.Trim();
10        
11        // Tuvastage timestamp'i formaat numbrite arvu põhjal
12        DateTime dateTime;
13        if (timestamp.Length == 16)
14        {
15            // Mikrosekundi täpsus (jagage 1 000 000, et saada sekundid)
16            if (!double.TryParse(timestamp, out double microseconds))
17                throw new ArgumentException("Vale timestamp'i formaat");
18                
19            // Muutke mikrosekundid DateTime'iks
20            dateTime = DateTimeOffset.FromUnixTimeSeconds(0).DateTime.AddSeconds(microseconds / 1000000);
21            Console.WriteLine("Tuvastatud: Mikrosekundi täpsuse timestamp");
22        }
23        else if (timestamp.Length == 13)
24        {
25            // Millisekundi täpsus
26            if (!long.TryParse(timestamp, out long milliseconds))
27                throw new ArgumentException("Vale timestamp'i formaat");
28                
29            dateTime = DateTimeOffset.FromUnixTimeMilliseconds(milliseconds).DateTime;
30            Console.WriteLine("Tuvastatud: Millisekundi täpsuse timestamp");
31        }
32        else if (timestamp.Length == 10)
33        {
34            // Standardne Unix timestamp (sekundid)
35            if (!long.TryParse(timestamp, out long seconds))
36                throw new ArgumentException("Vale timestamp'i formaat");
37                
38            dateTime = DateTimeOffset.FromUnixTimeSeconds(seconds).DateTime;
39            Console.WriteLine("Tuvastatud: Standardne Unix timestamp (sekundid)");
40        }
41        else
42        {
43            throw new ArgumentException("Vale timestamp'i formaat. Oodatud 10, 13 või 16 numbrit.");
44        }
45        
46        // Vormindamisstring 12-tunnise või 24-tunnise eelistuse põhjal
47        string formatString = use12Hour 
48            ? "dddd, MMMM d, yyyy h:mm:ss tt"  // 12-tunnine formaat AM/PM
49            : "dddd, MMMM d, yyyy HH:mm:ss";   // 24-tunnine formaat
50        
51        // Tagastage vormindatud kuupäeva string
52        return dateTime.ToString(formatString);
53    }
54    
55    static void Main()
56    {
57        try
58        {
59            // Standardne Unix timestamp (10 numbrit)
60            Console.WriteLine(ConvertTimestamp("1609459200", false));
61            
62            // Millisekundi täpsus (13 numbrit)
63            Console.WriteLine(ConvertTimestamp("1609459200000", false));
64            
65            // Mikrosekundi täpsus (16 numbrit)
66            Console.WriteLine(ConvertTimestamp("1609459200000000", true));
67        }
68        catch (ArgumentException e)
69        {
70            Console.WriteLine(e.Message);
71        }
72    }
73}
74

Handling Edge Cases

Unix timestamp'itega töötamisel erineva täpsusega on oluline õigesti käsitleda äärmuslikke juhtumeid. Siin on näide, mis demonstreerib ulatuslikku äärmuslike juhtumite käsitlemist:

1// JavaScripti ulatuslik äärmuslike juhtumite käsitlemine mitme timestamp'i formaadi jaoks
2function safeConvertTimestamp(timestamp, use12Hour = false) {
3  // Sisendi valideerimine
4  if (timestamp === undefined || timestamp === null || timestamp === '') {
5    return "Viga: Tühine või määramata timestamp";
6  }
7  
8  // Veenduge, et timestamp on string, et kontrollida pikkust
9  const timestampStr = String(timestamp).trim();
10  
11  // Kontrollige, kas timestamp sisaldab ainult numbreid
12  if (!/^\d+$/.test(timestampStr)) {
13    return "Viga: Timestamp peab sisaldama ainult numbreid";
14  }
15  
16  // Tuvastage formaat pikkuse põhjal
17  let date;
18  try {
19    if (timestampStr.length === 16) {
20      // Mikrosekundi täpsus
21      const microseconds = Number(timestampStr);
22      date = new Date(microseconds / 1000); // Muutke millisekunditeks
23      console.log("Töödeldakse mikrosekundi timestamp'i (16 numbrit)");
24      
25      // Kontrollige, kas kuupäev on kehtetu
26      if (isNaN(date.getTime())) {
27        return "Viga: Kehtetu mikrosekundi timestamp";
28      }
29    } else if (timestampStr.length === 13) {
30      // Millisekundi täpsus
31      const milliseconds = Number(timestampStr);
32      date = new Date(milliseconds);
33      console.log("Töödeldakse millisekundi timestamp'i (13 numbrit)");
34      
35      // Kontrollige, kas kuupäev on kehtetu
36      if (isNaN(date.getTime())) {
37        return "Viga: Kehtetu millisekundi timestamp";
38      }
39    } else if (timestampStr.length === 10) {
40      // Standardne Unix timestamp (sekundid)
41      const seconds = Number(timestampStr);
42      date = new Date(seconds * 1000);
43      console.log("Töödeldakse standardset timestamp'i (10 numbrit)");
44      
45      // Kontrollige, kas kuupäev on kehtetu
46      if (isNaN(date.getTime())) {
47        return "Viga: Kehtetu standardne timestamp";
48      }
49      
50      // Kontrollige Y2K38 probleemi (32-bitiste süsteemide jaoks)
51      const maxInt32 = 2147483647; // 32-bitise allkirjastatud täisarvu maksimaalne väärtus
52      if (seconds > maxInt32) {
53        console.warn("Hoiatus: Timestamp ületab 32-bitise täisarvu piiri (Y2K38 probleem)");
54      }
55    } else {
56      return "Viga: Vale timestamp'i pikkus. Oodatud 10, 13 või 16 numbrit.";
57    }
58    
59    // Vormindage kuupäev
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 "Viga timestamp'i konverteerimisel: " + error.message;
74  }
75}
76
77// Testige erinevaid äärmuslikke juhtumeid
78console.log(safeConvertTimestamp("1609459200"));      // Standardne (10 numbrit)
79console.log(safeConvertTimestamp("1609459200000"));   // Millisekundid (13 numbrit)
80console.log(safeConvertTimestamp("1609459200000000")); // Mikrosekundid (16 numbrit)
81console.log(safeConvertTimestamp("abc123"));          // Mitte-numeriline
82console.log(safeConvertTimestamp("12345"));           // Vale pikkus
83console.log(safeConvertTimestamp("9999999999999999")); // Väga suur mikrosekundi timestamp
84console.log(safeConvertTimestamp(""));                // Tühi string
85

Frequently Asked Questions

Mis on Unix timestamp?

Unix timestamp on sekundite arv, mis on möödunud 1. jaanuarist 1970 (kesköö UTC/GMT), arvestamata hüppesekundeid. See pakub kompaktset, keele sõltumatut viisi konkreetse hetke esitlemiseks ajas.

Kuidas töötab automaatne timestamp'i formaadi tuvastamine?

Konverter tuvastab automaatselt timestamp'i formaadi numbrite arvu põhjal:

• 10 numbrit: Standardne Unix timestamp (sekundid epoch'ist)
• 13 numbrit: Millisekundi täpsuse timestamp
• 16 numbrit: Mikrosekundi täpsuse timestamp

Miks ma vajaksin millisekundi või mikrosekundi täpsust?

Millisekundi täpsus (13 numbrit) on kasulik rakendustes, mis nõuavad täpsemat ajastust, näiteks jõudluse jälgimine, kasutajaliidese jälgimine ja teatud rahandusrakendused. Mikrosekundi täpsus (16 numbrit) on vajalik kõrge jõudlusega arvutustes, teaduslikes rakendustes ja kõrge sagedusega kauplemise süsteemides, kus äärmiselt täpne ajastus on kriitilise tähtsusega.

Kas ma saan kasutada Unix timestamp'e kuupäevade planeerimiseks tulevikus?

Jah, Unix timestamp'e kasutatakse laialdaselt planeerimiseks. Kuid väga kaugete tuleviku kuupäevade puhul olge teadlik võimalikest piirangutest, nagu Aasta 2038 probleem 32-bitistes süsteemides ja ajavööndi muutuste ning suveaja üleminekute käsitlemine.

Milline on Unix aja ja ISO 8601 vahe?

Unix aeg on numbriline esitus (sekundid epoch'ist), samas kui ISO 8601 on stringiformaat (nt "2021-01-01T00:00:00Z"). Unix aeg on kompaktsem ja kergemini kasutatav arvutustes, samas kui ISO 8601 on inimloetavam ja enesekirjeldav.

Kui täpsed on Unix timestamp'id?

Standardsetel Unix timestamp'id on sekundi tasemel täpsus. Rakendustes, mis vajavad suuremat täpsust, pakuvad millisekundi timestamp'id (13 numbrit) 1/1000 sekundi täpsust ja mikrosekundi timestamp'id (16 numbrit) 1/1,000,000 sekundi täpsust.

Kas Unix timestamp'id arvestavad hüppesekundeid?

Ei, Unix aeg on määratletud kui sekundite arv epoch'ist, välja arvatud hüppesekundid. See tähendab, et hüppesekundi ajal ei suurene Unix timestamp. See võib tekitada probleeme rakendustes, mis nõuavad astronoomilist aega.

Kas Unix timestamp'e saab kasutada tulevaste sündmuste ajastamiseks?

Jah, Unix timestamp'e kasutatakse laialdaselt ajastamiseks. Siiski, väga kaugete tuleviku kuupäevade puhul olge teadlik võimalikest piirangutest, nagu Aasta 2038 probleem 32-bitistes süsteemides ja ajavööndi muutuste ning suveaja üleminekute käsitlemine.

References

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

Proovige meie timestamp'i konverterit nüüd, et hõlpsasti konverteerida Unix timestamp'e mis tahes täpsusega inimloetavateks kuupäevadeks. Olgu need standardsed Unix timestamp'id, millisekundi täpsus või mikrosekundi täpsus, meie tööriist tuvastab automaatselt formaadi ja pakub täpseid konversioone.