Unix Timestamp Converter

Uvod

Unix timestamp (poznat i kao POSIX vreme ili Epoch vreme) je sistem za opisivanje tačke u vremenu. To je broj sekundi koje su prošle od 1. januara 1970. (ponoć UTC/GMT), ne računajući prestupne sekunde. Unix timestampi se široko koriste u računarstvu i programskim jezicima jer pružaju kompaktan, jezikom nezavistan prikaz određenog trenutka u vremenu.

Ovaj konverter vremena u datum automatski detektuje i obrađuje timestampove različitih dužina, uključujući preciznost u mikrosekundama (16 cifara), preciznost u milisekundama (13 cifara) i standardne Unix timestampove (10 cifara). Alat identifikuje format timestamp-a na osnovu dužine unosa, konvertuje ga u datum i vreme u formatu koji je lako čitljiv, i prikazuje rezultat bez potrebe da korisnici specificiraju tip timestamp-a. Podržava i 12-satni (AM/PM) i 24-satni format vremena kako bi se prilagodili različitim regionalnim i ličnim preferencijama.

Kako Unix Timestamps Funkcionišu

Unix timestampi se računaju kao broj sekundi od Unix Epohе (1. januar 1970, 00:00:00 UTC). Ovo ih čini posebno korisnim za izračunavanje razlika u vremenu i za skladištenje datuma u kompaktnom formatu.

Matematička konverzija iz Unix timestamp-a u kalendarski datum uključuje nekoliko koraka:

1. Počnite sa Unix Epohom (1. januar 1970, 00:00:00 UTC)
2. Dodajte broj sekundi u timestamp-u
3. Uzmite u obzir prestupne godine, različite dužine meseci i druge složenosti kalendara
4. Primijenite prilagođavanja vremenskoj zoni ako je potrebno

Na primer, Unix timestamp 1609459200 predstavlja petak, 1. januar 2021, 00:00:00 UTC.

Formula za konverziju može se izraziti kao:

$\text{Datum} = \text{Unix Epohа} + \text{Timestamp (u sekundama)}$

Većina programskih jezika i operativnih sistema pruža ugrađene funkcije za rukovanje ovom konverzijom, apstrahujući složene proračune kalendara.

Formati Timestamps i Automatska Detekcija

Naš konverter podržava tri uobičajena formata timestamp-a, koji se automatski detektuju na osnovu broja cifara:

1. Standardni Unix Timestamp (10 cifara): Predstavlja sekunde od Unix Epohе. Primer: 1609459200 (1. januar 2021, 00:00:00 UTC)

2. Preciznost u Milisekundama (13 cifara): Predstavlja milisekunde od Unix Epohе. Primer: 1609459200000 (1. januar 2021, 00:00:00 UTC)

3. Preciznost u Mikrosekundama (16 cifara): Predstavlja mikrosekunde od Unix Epohе. Primer: 1609459200000000 (1. januar 2021, 00:00:00 UTC)

Automatska detekcija funkcioniše analizom dužine unosa:

• Ako unos sadrži 10 cifara, tretira se kao standardni Unix timestamp (sekunde)
• Ako unos sadrži 13 cifara, tretira se kao timestamp u milisekundama
• Ako unos sadrži 16 cifara, tretira se kao timestamp u mikrosekundama

Ova automatska detekcija eliminiše potrebu za korisnicima da specificiraju tip timestamp-a, čineći alat korisnički prijatnijim i efikasnijim.

Opcije Formata Vremena

Ovaj konverter nudi dve opcije formata vremena:

1. 24-satni format (ponekad nazvan "vojni čas"): Sati se kreću od 0 do 23, a nema AM/PM oznake. Na primer, 15:00 se predstavlja kao 15:00.

2. 12-satni format: Sati se kreću od 1 do 12, sa AM (ante meridiem) za vreme od ponoći do podneva, i PM (post meridiem) za vreme od podneva do ponoći. Na primer, 15:00 u 24-satnom formatu se predstavlja kao 3:00 PM.

Izbor između ovih formata je u velikoj meri pitanje regionalne konvencije i ličnih preferencija:

• 24-satni format se obično koristi u većini Evrope, Latinske Amerike i Azije, kao i u naučnim, vojnim i medicinskim kontekstima širom sveta.
• 12-satni format je prisutan u Sjedinjenim Američkim Državama, Kanadi, Australiji i nekim drugim englesko govornim zemljama za svakodnevnu upotrebu.

Ivica Slučajevi i Ograničenja

Kada radite sa Unix timestampovima različitih preciznosti, važno je biti svestan nekoliko ivica slučajeva i ograničenja:

1. Negativni timestampovi: Ovi predstavljaju datume pre Unix Epohе (1. januar 1970). Iako su matematički validni, neki sistemi možda neće pravilno obraditi negativne timestampove. Ovo se odnosi na sve tri formate timestamp-a.

2. Problem godine 2038: Standardni Unix timestampovi (10 cifara) se često skladište kao 32-bitni potpisani celobrojni tipovi, koji će preplaviti 19. januara 2038. Nakon ovog datuma, 32-bitni sistemi neće moći pravilno prikazivati vreme osim ako nisu modifikovani da koriste veći celobrojni tip.

3. Razmatranja preciznosti:

   • Standardni timestampovi (10 cifara) imaju preciznost na nivou sekundi, što je dovoljno za većinu svakodnevnih aplikacija.
   • Timestampovi u milisekundama (13 cifara) pružaju 1000x veću preciznost, korisnu za aplikacije koje zahtevaju tačnije merenje vremena.
   • Timestampovi u mikrosekundama (16 cifara) nude još finiju preciznost (1/1,000,000 sekundi), što je neophodno za visokoperformantno računanje, naučne aplikacije i određene finansijske transakcije.

4. Ekstremno veliki timestampovi: Veoma daleki budući datumi možda neće biti predstavljeni u nekim sistemima, ili će se možda obraditi nekonzistentno. Ovo je posebno relevantno za timestampove u milisekundama i mikrosekundama, koji koriste veće numeričke vrednosti.

5. Prestupne sekunde: Unix vreme ne uzima u obzir prestupne sekunde, koje se povremeno dodaju u UTC kako bi se nadoknadila nepravilna rotacija Zemlje. To znači da Unix vreme nije precizno usklađeno sa astronomskim vremenom.

6. Razmatranja vremenskih zona: Unix timestampovi predstavljaju trenutke u UTC. Konvertovanje u lokalno vreme zahteva dodatne informacije o vremenskoj zoni.

7. Letnje računanje vremena: Kada se timestampovi konvertuju u lokalno vreme, moraju se uzeti u obzir složenosti prelaza na letnje računanje vremena.

8. Zbunjenost formata timestamp-a: Bez pravilne detekcije, 13-cifreni timestamp u milisekundama mogao bi biti pogrešno interpretiran kao veoma daleki budući datum ako se tretira kao timestamp zasnovan na sekundama. Naš konverter sprečava ovo automatskom detekcijom formata na osnovu dužine cifara.

Upotrebe

Unix timestampovi različitih preciznosti koriste se u brojnim aplikacijama širom računanja i upravljanja podacima:

1. Baze podataka: Timestampovi se obično koriste za beleženje kada su unosi kreirani ili izmenjeni.

   • Standardni timestampovi (10 cifara) su često dovoljni za opšte aplikacije baza podataka.
   • Timestampovi u milisekundama (13 cifara) se koriste kada je potrebna preciznija poredak događaja.

2. Web razvoj: HTTP zaglavlja, kolačići i mehanizmi keširanja često koriste Unix timestampove.

   • JavaScript-ova Date.now() vraća timestampove u milisekundama (13 cifara).

3. Log fajlovi: Sistemski logovi obično beleže događaje sa Unix timestampovima radi preciznog hronološkog poretka.

   • Sistemi za visoku frekvenciju logovanja mogu koristiti milisekundsku ili mikrosekundsku preciznost.

4. Sistemi za kontrolu verzija: Git i drugi VCS koriste timestampove za beleženje kada su napravljene promene.

5. API odgovori: Mnogi web API-ji uključuju timestampove u svojim odgovorima kako bi označili kada su podaci generisani ili kada su resursi poslednji put izmenjeni.

   • REST API-ji često koriste timestampove u milisekundama.

6. Fajl sistemi: Vremena kreiranja i izmene fajlova često se skladište kao Unix timestampovi.

7. Upravljanje sesijama: Web aplikacije koriste timestampove da odrede kada bi korisničke sesije trebale isteći.

8. Analiza podataka: Timestampovi pružaju standardizovan način za rad sa vremenskim podacima u analitičkim aplikacijama.

9. Trgovanje visokom frekvencijom: Finansijski sistemi često zahtevaju mikrosekundsku preciznost (16 cifara) kako bi tačno sekvencirali transakcije.

10. Naučna merenja: Istraživačka oprema može beležiti posmatranja sa mikrosekundskom preciznošću za tačnu analizu vremena.

Alternativе

Iako su Unix timestampovi široko korišćeni, postoje alternativni formati predstavljanja vremena koji mogu biti prikladniji u određenim kontekstima:

1. ISO 8601: Standardizovani string format (npr. "2021-01-01T00:00:00Z") koji je lako čitljiv dok zadržava mogućnost sortiranja. Često se preferira za razmenu podataka i aplikacije usmerene na korisnike.

2. RFC 3339: Profil ISO 8601 korišćen u internet protokolima, sa strožim zahtevima za formatiranje.

3. Ljudski čitljivi formati: Lokalizovane stringove datuma (npr. "1. januar 2021") su prikladnije za direktnu interakciju sa korisnicima, ali su manje pogodne za računanje.

4. Microsoft FILETIME: 64-bitna vrednost koja predstavlja broj intervala od 100 nanosekundi od 1. januara 1601. godine, korišćena u Windows sistemima.

5. Julijanski dan: Koristi se u astronomiji i nekim naučnim aplikacijama, brojeći dane od 1. januara 4713. pre nove ere.

Izbor formata vremena zavisi od faktora kao što su:

• Potrebna preciznost
• Potrebe za ljudskom čitljivošću
• Ograničenja skladištenja
• Kompatibilnost sa postojećim sistemima
• Opseg datuma koji treba predstaviti

Istorija

Koncept Unix vremena potiče od razvoja Unix operativnog sistema u Bell Labs-u krajem 1960-ih i početkom 1970-ih. Odluka da se 1. januar 1970. uzme kao epoha bila je donekle arbitrarna, ali praktična za to vreme—bila je dovoljno blizu da minimizira zahteve za skladištenjem datuma od interesa, ali dovoljno daleko u prošlosti da bude korisna za istorijske podatke.

Originalna implementacija koristila je 32-bitni potpisani celobrojni tip za skladištenje broja sekundi, što je bilo adekvatno za očekivani vek Unix sistema tog vremena. Međutim, ova odluka dovela je do problema godine 2038 (ponekad nazvanog "Y2K38" ili "Unix Millennium Bug"), jer 32-bitni potpisani celobrojni tipovi mogu predstavljati datume samo do 19. januara 2038. (03:14:07 UTC).

Kako su se računske potrebe razvijale, postala je neophodna veća preciznost timestampova:

• Preciznost u milisekundama (13 cifara) postala je uobičajena sa porastom interaktivnog računanja i potrebom za merenjem odgovora korisničkog interfejsa.

• Preciznost u mikrosekundama (16 cifara) pojavila se sa visokoperformantnim računanjem i sistemima koji zahtevaju izuzetno precizno merenje vremena.

Kako su Unix i Unix-like operativni sistemi postajali sve popularniji, Unix timestamp postao je de facto standard za predstavljanje vremena u računarstvu. Usvojili su ga mnogi programski jezici, baze podataka i aplikacije, proširujući se daleko izvan svog originalnog Unix okruženja.

Savremeni sistemi sve više koriste 64-bitne celobrojne tipove za timestampove, što produžava opseg koji se može predstaviti na oko 292 milijarde godina u obe smeri od epohe, efikasno rešavajući problem godine 2038. Međutim, nasleđeni sistemi i aplikacije i dalje mogu biti ranjivi.

Jednostavnost i korisnost Unix timestamp-a osigurali su njegovu kontinuiranu relevantnost uprkos razvoju sofisticiranijih formata predstavljanja vremena. Ostaje fundamentalni koncept u računarstvu, koji podržava većinu naše digitalne infrastrukture.

Primeri Koda

Evo primera kako konvertovati Unix timestampove različitih preciznosti u ljudski čitljive datume u različitim programskim jezicima:

1// JavaScript konverzija timestamp-a sa automatskom detekcijom formata
2function convertTimestamp(timestamp, use12Hour = false) {
3  // Konvertujte string u broj ako je potrebno
4  const numericTimestamp = Number(timestamp);
5  
6  // Detektujte format timestamp-a na osnovu dužine cifara
7  let date;
8  if (timestamp.length === 16) {
9    // Preciznost u mikrosekundama (podelite sa 1.000.000 da dobijete sekunde)
10    date = new Date(numericTimestamp / 1000);
11    console.log("Detektovano: Timestamp sa mikrosekundnom preciznošću");
12  } else if (timestamp.length === 13) {
13    // Preciznost u milisekundama
14    date = new Date(numericTimestamp);
15    console.log("Detektovano: Timestamp sa milisekundnom preciznošću");
16  } else if (timestamp.length === 10) {
17    // Standardni Unix timestamp (sekunde)
18    date = new Date(numericTimestamp * 1000);
19    console.log("Detektovano: Standardni Unix timestamp (sekunde)");
20  } else {
21    throw new Error("Nevalidan format timestamp-a. Očekivano 10, 13 ili 16 cifara.");
22  }
23  
24  // Opcije formata
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  // Konvertujte u string koristeći lokalno formatiranje
37  return date.toLocaleString(undefined, options);
38}
39
40// Primer korišćenja
41try {
42  // Standardni Unix timestamp (10 cifara)
43  console.log(convertTimestamp("1609459200", false)); 
44  
45  // Preciznost u milisekundama (13 cifara)
46  console.log(convertTimestamp("1609459200000", false)); 
47  
48  // Preciznost u mikrosekundama (16 cifara)
49  console.log(convertTimestamp("1609459200000000", true)); 
50} catch (error) {
51  console.error(error.message);
52}
53

1# Python konverzija timestamp-a sa automatskom detekcijom formata
2import datetime
3
4def convert_timestamp(timestamp, use_12hour=False):
5    # Konvertujte u ceo broj
6    timestamp = str(timestamp).strip()
7    numeric_timestamp = int(timestamp)
8    
9    # Detektujte format timestamp-a na osnovu dužine cifara
10    if len(timestamp) == 16:
11        # Preciznost u mikrosekundama (podelite sa 1.000.000 da dobijete sekunde)
12        date = datetime.datetime.fromtimestamp(numeric_timestamp / 1000000)
13        print("Detektovano: Timestamp sa mikrosekundnom preciznošću")
14    elif len(timestamp) == 13:
15        # Preciznost u milisekundama (podelite sa 1.000 da dobijete sekunde)
16        date = datetime.datetime.fromtimestamp(numeric_timestamp / 1000)
17        print("Detektovano: Timestamp sa milisekundnom preciznošću")
18    elif len(timestamp) == 10:
19        # Standardni Unix timestamp (sekunde)
20        date = datetime.datetime.fromtimestamp(numeric_timestamp)
21        print("Detektovano: Standardni Unix timestamp (sekunde)")
22    else:
23        raise ValueError("Nevalidan format timestamp-a. Očekivano 10, 13 ili 16 cifara.")
24    
25    # Formatirajte string datuma
26    if use_12hour:
27        format_string = "%A, %B %d, %Y %I:%M:%S %p"  # 12-satni format sa AM/PM
28    else:
29        format_string = "%A, %B %d, %Y %H:%M:%S"     # 24-satni format
30    
31    return date.strftime(format_string)
32
33# Primer korišćenja
34try:
35    # Standardni Unix timestamp (10 cifara)
36    print(convert_timestamp("1609459200", False))
37    
38    # Preciznost u milisekundama (13 cifara)
39    print(convert_timestamp("1609459200000", False))
40    
41    # Preciznost u mikrosekundama (16 cifara)
42    print(convert_timestamp("1609459200000000", True))
43except ValueError as e:
44    print(e)
45

1<?php
2// PHP konverzija timestamp-a sa automatskom detekcijom formata
3function convertTimestamp($timestamp, $use12Hour = false) {
4    // Osigurajte da je timestamp string za proveru dužine
5    $timestamp = trim((string)$timestamp);
6    
7    // Detektujte format timestamp-a na osnovu dužine cifara
8    if (strlen($timestamp) === 16) {
9        // Preciznost u mikrosekundama (podelite sa 1.000.000 da dobijete sekunde)
10        $seconds = $numericTimestamp / 1000000;
11        echo "Detektovano: Timestamp sa mikrosekundnom preciznošću\n";
12    } elseif (strlen($timestamp) === 13) {
13        // Preciznost u milisekundama (podelite sa 1.000 da dobijete sekunde)
14        $seconds = $numericTimestamp / 1000;
15        echo "Detektovano: Timestamp sa milisekundnom preciznošću\n";
16    } elseif (strlen($timestamp) === 10) {
17        // Standardni Unix timestamp (sekunde)
18        $seconds = $numericTimestamp;
19        echo "Detektovano: Standardni Unix timestamp (sekunde)\n";
20    } else {
21        throw new Exception("Nevalidan format timestamp-a. Očekivano 10, 13 ili 16 cifara.");
22    }
23    
24    // Format string
25    $formatString = $use12Hour 
26        ? 'l, F j, Y g:i:s A'  // 12-satni format sa AM/PM
27        : 'l, F j, Y H:i:s';   // 24-satni format
28    
29    // Konvertujte i formatirajte datum
30    return date($formatString, $seconds);
31}
32
33// Primer korišćenja
34try {
35    // Standardni Unix timestamp (10 cifara)
36    echo convertTimestamp("1609459200", false) . "\n";
37    
38    // Preciznost u milisekundama (13 cifara)
39    echo convertTimestamp("1609459200000", false) . "\n";
40    
41    // Preciznost u mikrosekundama (16 cifara)
42    echo convertTimestamp("1609459200000000", true) . "\n";
43} catch (Exception $e) {
44    echo $e->getMessage() . "\n";
45}
46?>
47

1// Java konverzija timestamp-a sa automatskom detekcijom formata
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        // Trimujte unos
10        timestamp = timestamp.trim();
11        
12        // Detektujte format timestamp-a na osnovu dužine cifara
13        LocalDateTime dateTime;
14        if (timestamp.length() == 16) {
15            // Preciznost u mikrosekundama (podelite sa 1.000.000 da dobijete sekunde)
16            long microseconds = Long.parseLong(timestamp);
17            Instant instant = Instant.ofEpochSecond(0, microseconds * 1000); // Konvertujte u nanosekunde
18            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
19            System.out.println("Detektovano: Timestamp sa mikrosekundnom preciznošću");
20        } else if (timestamp.length() == 13) {
21            // Preciznost u milisekundama
22            long milliseconds = Long.parseLong(timestamp);
23            Instant instant = Instant.ofEpochMilli(milliseconds);
24            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
25            System.out.println("Detektovano: Timestamp sa milisekundnom preciznošću");
26        } else if (timestamp.length() == 10) {
27            // Standardni Unix timestamp (sekunde)
28            long seconds = Long.parseLong(timestamp);
29            Instant instant = Instant.ofEpochSecond(seconds);
30            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
31            System.out.println("Detektovano: Standardni Unix timestamp (sekunde)");
32        } else {
33            throw new IllegalArgumentException("Nevalidan format timestamp-a. Očekivano 10, 13 ili 16 cifara.");
34        }
35        
36        // Kreirajte format prema željenom formatu
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        // Formatirajte datum
42        return dateTime.format(formatter);
43    }
44    
45    public static void main(String[] args) {
46        try {
47            // Standardni Unix timestamp (10 cifara)
48            System.out.println(convertTimestamp("1609459200", false));
49            
50            // Preciznost u milisekundama (13 cifara)
51            System.out.println(convertTimestamp("1609459200000", false));
52            
53            // Preciznost u mikrosekundama (16 cifara)
54            System.out.println(convertTimestamp("1609459200000000", true));
55        } catch (IllegalArgumentException e) {
56            System.err.println(e.getMessage());
57        }
58    }
59}
60

1// C# konverzija timestamp-a sa automatskom detekcijom formata
2using System;
3
4class TimestampConverter
5{
6    public static string ConvertTimestamp(string timestamp, bool use12Hour)
7    {
8        // Trimujte unos
9        timestamp = timestamp.Trim();
10        
11        // Detektujte format timestamp-a na osnovu dužine cifara
12        DateTime dateTime;
13        if (timestamp.Length == 16)
14        {
15            // Preciznost u mikrosekundama (podelite sa 1.000.000 da dobijete sekunde)
16            if (!double.TryParse(timestamp, out double microseconds))
17                throw new ArgumentException("Nevalidan format timestamp-a");
18                
19            // Konvertujte mikrosekunde u DateTime
20            dateTime = DateTimeOffset.FromUnixTimeSeconds(0).DateTime.AddSeconds(microseconds / 1000000);
21            Console.WriteLine("Detektovano: Timestamp sa mikrosekundnom preciznošću");
22        }
23        else if (timestamp.Length == 13)
24        {
25            // Preciznost u milisekundama
26            if (!long.TryParse(timestamp, out long milliseconds))
27                throw new ArgumentException("Nevalidan format timestamp-a");
28                
29            dateTime = DateTimeOffset.FromUnixTimeMilliseconds(milliseconds).DateTime;
30            Console.WriteLine("Detektovano: Timestamp sa milisekundnom preciznošću");
31        }
32        else if (timestamp.Length == 10)
33        {
34            // Standardni Unix timestamp (sekunde)
35            if (!long.TryParse(timestamp, out long seconds))
36                throw new ArgumentException("Nevalidan format timestamp-a");
37                
38            dateTime = DateTimeOffset.FromUnixTimeSeconds(seconds).DateTime;
39            Console.WriteLine("Detektovano: Standardni Unix timestamp (sekunde)");
40        }
41        else
42        {
43            throw new ArgumentException("Nevalidan format timestamp-a. Očekivano 10, 13 ili 16 cifara.");
44        }
45        
46        // Format string na osnovu 12-satnog ili 24-satnog izbora
47        string formatString = use12Hour 
48            ? "dddd, MMMM d, yyyy h:mm:ss tt"  // 12-satni format sa AM/PM
49            : "dddd, MMMM d, yyyy HH:mm:ss";   // 24-satni format
50        
51        // Vratite formatirani string datuma
52        return dateTime.ToString(formatString);
53    }
54    
55    static void Main()
56    {
57        try
58        {
59            // Standardni Unix timestamp (10 cifara)
60            Console.WriteLine(ConvertTimestamp("1609459200", false));
61            
62            // Preciznost u milisekundama (13 cifara)
63            Console.WriteLine(ConvertTimestamp("1609459200000", false));
64            
65            // Preciznost u mikrosekundama (16 cifara)
66            Console.WriteLine(ConvertTimestamp("1609459200000000", true));
67        }
68        catch (ArgumentException e)
69        {
70            Console.WriteLine(e.Message);
71        }
72    }
73}
74

Rukovanje Ivica Slučajevima

Kada radite sa Unix timestampovima različitih preciznosti, važno je pravilno obraditi ivica slučajeve. Evo primera koji prikazuje sveobuhvatno rukovanje ivica slučajevima:

1// JavaScript sveobuhvatno rukovanje ivica slučajevima za više formata timestamp-a
2function safeConvertTimestamp(timestamp, use12Hour = false) {
3  // Validacija unosa
4  if (timestamp === undefined || timestamp === null || timestamp === '') {
5    return "Greška: Prazan ili neodređen timestamp";
6  }
7  
8  // Osigurajte da je timestamp string za proveru dužine
9  const timestampStr = String(timestamp).trim();
10  
11  // Proverite da li timestamp sadrži samo cifre
12  if (!/^\d+$/.test(timestampStr)) {
13    return "Greška: Timestamp mora sadržati samo cifre";
14  }
15  
16  // Detektujte format na osnovu dužine
17  let date;
18  try {
19    if (timestampStr.length === 16) {
20      // Preciznost u mikrosekundama
21      const microseconds = Number(timestampStr);
22      date = new Date(microseconds / 1000); // Konvertujte u milisekunde
23      console.log("Obrada timestamp-a sa mikrosekundnom preciznošću (16 cifara)");
24      
25      // Proverite za nevalidan datum
26      if (isNaN(date.getTime())) {
27        return "Greška: Nevalidan timestamp sa mikrosekundnom preciznošću";
28      }
29    } else if (timestampStr.length === 13) {
30      // Preciznost u milisekundama
31      const milliseconds = Number(timestampStr);
32      date = new Date(milliseconds);
33      console.log("Obrada timestamp-a sa milisekundnom preciznošću (13 cifara)");
34      
35      // Proverite za nevalidan datum
36      if (isNaN(date.getTime())) {
37        return "Greška: Nevalidan timestamp sa milisekundnom preciznošću";
38      }
39    } else if (timestampStr.length === 10) {
40      // Standardni Unix timestamp (sekunde)
41      const seconds = Number(timestampStr);
42      date = new Date(seconds * 1000);
43      console.log("Obrada standardnog timestamp-a (10 cifara)");
44      
45      // Proverite za nevalidan datum
46      if (isNaN(date.getTime())) {
47        return "Greška: Nevalidan standardni timestamp";
48      }
49      
50      // Proverite za Y2K38 problem (za 32-bitne sisteme)
51      const maxInt32 = 2147483647; // Maksimalna vrednost za 32-bitni potpisani celobrojni tip
52      if (seconds > maxInt32) {
53        console.warn("Upozorenje: Timestamp premašuje granicu 32-bitnog celobrojnog tipa (Y2K38 problem)");
54      }
55    } else {
56      return "Greška: Nevalidna dužina timestamp-a. Očekivano 10, 13 ili 16 cifara.";
57    }
58    
59    // Formatirajte 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 "Greška prilikom konvertovanja timestamp-a: " + error.message;
74  }
75}
76
77// Testirajte sa raznim ivica slučajevima
78console.log(safeConvertTimestamp("1609459200"));      // Standardni (10 cifara)
79console.log(safeConvertTimestamp("1609459200000"));   // Milisekunde (13 cifara)
80console.log(safeConvertTimestamp("1609459200000000")); // Mikrosekunde (16 cifara)
81console.log(safeConvertTimestamp("abc123"));          // Ne-numerički
82console.log(safeConvertTimestamp("12345"));           // Nevalidna dužina
83console.log(safeConvertTimestamp("9999999999999999")); // Veoma veliki timestamp u mikrosekundama
84console.log(safeConvertTimestamp(""));                // Prazan string
85

Često Postavljana Pitanja

Šta je Unix timestamp?

Unix timestamp je broj sekundi koje su prošle od 1. januara 1970. (ponoć UTC/GMT), ne računajući prestupne sekunde. Pruža kompaktan, jezikom nezavistan način za predstavljanje određenog trenutka u vremenu.

Kako funkcioniše automatska detekcija formata timestamp-a?

Konverter automatski detektuje format timestamp-a na osnovu broja cifara:

• 10 cifara: Standardni Unix timestamp (sekunde od epohe)
• 13 cifara: Timestamp u milisekundama
• 16 cifara: Timestamp u mikrosekundama

Zašto bi mi bila potrebna preciznost u milisekundama ili mikrosekundama?

Preciznost u milisekundama (13 cifara) je korisna za aplikacije koje zahtevaju tačnije merenje vremena, kao što su praćenje performansi, praćenje korisničkih interakcija i određene finansijske aplikacije. Preciznost u mikrosekundama (16 cifara) je neophodna za visokoperformantno računanje, naučne aplikacije i sisteme trgovanja visokom frekvencijom gde je izuzetno precizno merenje ključno.

Mogu li koristiti Unix timestampove za zakazivanje budućih događaja?

Da, Unix timestampovi se široko koriste za zakazivanje. Međutim, za veoma daleke buduće datume, budite svesni potencijalnih ograničenja kao što su problem godine 2038 za 32-bitne sisteme i rukovanje promenama vremenskih zona i prelazima na letnje računanje vremena.

Šta je problem godine 2038?

Problem godine 2038 se javlja jer mnogi sistemi skladište Unix timestampove kao 32-bitne potpisane celobrojne tipove, koji mogu predstavljati datume samo do 19. januara 2038. (03:14:07 UTC). Nakon ovog datuma, ceo broj će preplaviti, što može dovesti do kvara sistema. Savremeni sistemi sve više koriste 64-bitne celobrojne tipove kako bi izbegli ovaj problem.

Kako da obradim konverzije vremenskih zona sa Unix timestampovima?

Unix timestampovi su uvek u UTC (Koordinisano univerzalno vreme). Da biste konvertovali u određenu vremensku zonu, potrebno je primeniti odgovarajući pomak nakon konvertovanja timestamp-a u datum. Većina programskih jezika pruža ugrađene funkcije za rukovanje konverzijama vremenskih zona.

Koja je razlika između Unix vremena i ISO 8601?

Unix vreme je numerička reprezentacija (sekunde od epohe), dok je ISO 8601 string format (npr. "2021-01-01T00:00:00Z"). Unix vreme je kompaktno i lakše se koristi za proračune, dok je ISO 8601 više ljudski čitljiv i samopopisiv.

Koliko su tačni Unix timestampovi?

Standardni Unix timestampovi imaju preciznost na nivou sekundi. Za aplikacije koje zahtevaju veću preciznost, timestampovi u milisekundama (13 cifara) pružaju preciznost od 1/1000 sekunde, a timestampovi u mikrosekundama (16 cifara) nude preciznost od 1/1,000,000 sekunde.

Da li Unix timestampovi uzimaju u obzir prestupne sekunde?

Ne, Unix vreme je definisano kao broj sekundi od epohe, isključujući prestupne sekunde. To znači da se tokom prestupne sekunde Unix timestamp ne povećava. Ovo može izazvati probleme u aplikacijama koje zahtevaju precizno astronomsko vreme.

Mogu li koristiti Unix timestampove za zakazivanje budućih događaja?

Da, Unix timestampovi se široko koriste za zakazivanje. Međutim, za veoma daleke buduće datume, budite svesni potencijalnih ograničenja kao što su problem godine 2038 za 32-bitne sisteme i rukovanje promenama vremenskih zona i prelazima na letnje računanje vremena.

Reference

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

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

3. Olson, Arthur David. "Složenosti kalendarskog vremena." 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 i vreme na internetu: Timestamps." Internet Engineering Task Force (IETF), https://tools.ietf.org/html/rfc3339

6. Kernighan, Brian W., i Dennis M. Ritchie. "C programski jezik." Prentice Hall, 1988.

7. "Precizno merenje vremena u visokoperformantnom računanju." ACM Computing Surveys, https://dl.acm.org/doi/10.1145/3232678

8. "Predstavljanje vremena u finansijskim sistemima." Časopis finansijske tehnologije, https://www.fintech-journal.com/time-representation

Probajte naš konverter timestamp-a sada da lako konvertujete Unix timestampove bilo koje preciznosti u ljudski čitljive datume. Bilo da radite sa standardnim Unix timestampovima, timestampovima u milisekundama ili timestampovima u mikrosekundama, naš alat automatski detektuje format i pruža tačne konverzije.