Unix Timestamp Converter

Uvod

Unix timestamp (također poznat kao POSIX vrijeme ili Epoch vrijeme) je sustav za opisivanje trenutka u vremenu. To je broj sekundi koje su prošle od 1. siječnja 1970. (ponoć UTC/GMT), ne računajući prijestupne sekunde. Unix timestampi se široko koriste u računalnim sustavima i programskim jezicima jer pružaju kompaktan, neovisni o jeziku prikaz određenog trenutka u vremenu.

Ovaj konverter timestamp-a u datum automatski prepoznaje i obrađuje timestamp-e različitih duljina, uključujući preciznost u mikrosekundama (16 znamenki), preciznost u milisekundama (13 znamenki) i standardne Unix timestamp-e (10 znamenki). Alat identificira format timestamp-a na temelju duljine unosa, pretvara ga u ljudski čitljiv datum i vrijeme, te prikazuje rezultat bez potrebe da korisnici specificiraju tip timestamp-a. Podržava i 12-satni (AM/PM) i 24-satni format vremena kako bi zadovoljio različite regionalne i osobne preferencije.

Kako Unix Timestamps Funkcioniraju

Unix timestampi se izračunavaju kao broj sekundi od Unix Epohе (1. siječnja 1970., 00:00:00 UTC). To ih čini posebno korisnima za izračunavanje vremenskih razlika i za pohranu datuma u kompaktnom formatu.

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

1. Počnite s Unix Epohom (1. siječnja 1970., 00:00:00 UTC)
2. Dodajte broj sekundi u timestamp-u
3. Uzmite u obzir prijestupne godine, varijabilne duljine mjeseci i druge složenosti kalendara
4. Primijenite prilagodbe vremenske zone ako je potrebno

Na primjer, Unix timestamp 1609459200 predstavlja petak, 1. siječnja 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 sustava pruža ugrađene funkcije za rukovanje ovom konverzijom, apstrahirajući složene izračune kalendara.

Formati Timestamp-a i Automatsko Prepoznavanje

Naš konverter podržava tri uobičajena formata timestamp-a, koji se automatski prepoznaju na temelju broja znamenki:

1. Standardni Unix Timestamp (10 znamenki): Predstavlja sekunde od Unix Epohе. Primjer: 1609459200 (1. siječnja 2021., 00:00:00 UTC)

2. Preciznost u Milisekundama (13 znamenki): Predstavlja milisekunde od Unix Epohе. Primjer: 1609459200000 (1. siječnja 2021., 00:00:00 UTC)

3. Preciznost u Mikrosekundama (16 znamenki): Predstavlja mikrosekunde od Unix Epohе. Primjer: 1609459200000000 (1. siječnja 2021., 00:00:00 UTC)

Automatsko prepoznavanje radi analizom duljine unosa:

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

Ovo automatsko prepoznavanje eliminira potrebu da korisnici specificiraju tip timestamp-a, čineći alat korisnički prijateljskim i učinkovitijim.

Opcije Formata Vremena

Ovaj konverter nudi dvije opcije formata vremena:

1. 24-satni format (ponekad nazvan "vojni vrijeme"): Sati se kreću od 0 do 23, a ne postoji oznaka AM/PM. Na primjer, 15:00 se prikazuje kao 15:00.

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

Izbor između ovih formata uglavnom je pitanje regionalne konvencije i osobne preferencije:

• 24-satni format se često koristi u većini Europe, Latinskoj Americi i Aziji, kao i u znanstvenim, vojnim i medicinskim kontekstima širom svijeta.
• 12-satni format je prisutan u Sjedinjenim Američkim Državama, Kanadi, Australiji i nekim drugim englesko govornim zemljama za svakodnevnu upotrebu.

Rubne Situacije i Ograničenja

Kada radite s Unix timestamp-ima različitih preciznosti, važno je biti svjestan nekoliko rubnih situacija i ograničenja:

1. Negativni timestampi: Oni predstavljaju datume prije Unix Epohе (1. siječnja 1970.). Iako su matematički valjani, neki sustavi možda neće ispravno obraditi negativne timestamp-e. Ovo se odnosi na sve tri vrste timestamp-a.

2. Problem godine 2038: Standardni Unix timestampi (10 znamenki) često se pohranjuju kao 32-bitni cijeli brojevi, koji će se preopteretiti 19. siječnja 2038. Nakon ovog trenutka, 32-bitni sustavi neće moći ispravno prikazivati vrijeme osim ako se ne izmijene da koriste veći tip cijelog broja.

3. Razmatranja preciznosti:

   • Standardni timestampi (10 znamenki) imaju preciznost na razini sekundi, što je dovoljno za većinu svakodnevnih aplikacija.
   • Timestampi u milisekundama (13 znamenki) pružaju 1000x veću preciznost, korisnu za aplikacije koje zahtijevaju točnije mjerenje vremena.
   • Timestampi u mikrosekundama (16 znamenki) nude još finiju preciznost (1/1.000.000 sekunde), što je potrebno za visokoučinkovito računalstvo, znanstvene aplikacije i određene financijske transakcije.

4. Ekstremno veliki timestampi: Vrlo daleki budući datumi možda neće biti predstavljeni u nekim sustavima, ili će se s njima postupati nekonzistentno. Ovo je posebno relevantno za timestamp-e u milisekundama i mikrosekundama, koji koriste veće numeričke vrijednosti.

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

6. Razmatranja vremenskih zona: Unix timestampi predstavljaju trenutke u UTC. Pretvaranje u lokalno vrijeme zahtijeva dodatne informacije o vremenskoj zoni.

7. Ljetno računanje vremena: Pri pretvaranju timestamp-a u lokalno vrijeme, moraju se uzeti u obzir složenosti prijelaza na ljetno računanje vremena.

8. Zbunjenost s formatom timestamp-a: Bez pravilnog prepoznavanja, timestamp od 13 znamenki mogao bi se pogrešno interpretirati kao vrlo daleki budući datum ako se tretira kao timestamp temeljen na sekundama. Naš konverter to sprječava automatskim prepoznavanjem formata na temelju duljine znamenki.

Primjene

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

1. Zapisi u Bazi Podataka: Timestampi se često koriste za bilježenje kada su unosi stvoreni ili modificirani.

   • Standardni timestampi (10 znamenki) često su dovoljni za opće aplikacije baza podataka.
   • Timestampi u milisekundama (13 znamenki) koriste se kada je potrebna preciznija kronološka obrada događaja.

2. Web Razvoj: HTTP zaglavlja, kolačići i mehanizmi predmemoriranja često koriste Unix timestamp-e.

   • JavaScriptova funkcija Date.now() vraća timestamp u milisekundama (13 znamenki).

3. Log Datoteke: Sustavski logovi obično bilježe događaje s Unix timestamp-ima za precizno kronološko redoslijed.

4. Sustavi Kontrole Verzija: Git i drugi VCS koriste timestamp-e za bilježenje kada su promjene napravljene.

5. API Odgovori: Mnogi web API-ji uključuju timestamp-e u svojim odgovorima kako bi naznačili kada su podaci generirani ili kada su resursi posljednji put modificirani.

   • REST API-ji često koriste timestamp-e u milisekundama.

6. Datotečni Sustavi: Vrijeme stvaranja i modificiranja datoteka često se pohranjuje kao Unix timestamp.

7. Upravljanje Sesijama: Web aplikacije koriste timestamp-e za određivanje kada bi korisničke sesije trebale isteći.

8. Analiza Podataka: Timestampi pružaju standardizirani način rada s vremenskim podacima u analitičkim aplikacijama.

9. Visoko-Frekventno Trgovanje: Financijski sustavi često zahtijevaju preciznost u mikrosekundama (16 znamenki) za točno sekvenciranje transakcija.

10. Znanstvena Mjerenja: Istraživačka oprema može bilježiti opažanja s preciznošću u mikrosekundama za točnu vremensku analizu.

Alternativе

Iako su Unix timestampi široko korišteni, postoje alternativni formati prikaza vremena koji mogu biti prikladniji u određenim kontekstima:

1. ISO 8601: Standardizirani string format (npr., "2021-01-01T00:00:00Z") koji je ljudski čitljiv, a istovremeno održava mogućnost sortiranja. Često se preferira za razmjenu podataka i aplikacije usmjerene na korisnike.

2. RFC 3339: Profil ISO 8601 koji se koristi u internet protokolima, s strožim zahtjevima za formatiranje.

3. Ljudski čitljivi formati: Lokalizirani datumski stringovi (npr., "1. siječnja 2021.") prikladniji su za izravnu interakciju s korisnicima, ali su manje prikladni za izračune.

4. Microsoft FILETIME: 64-bitna vrijednost koja predstavlja broj intervala od 100 nanosekundi od 1. siječnja 1601., koja se koristi u Windows sustavima.

5. Julijanski Dan: Koristi se u astronomiji i nekim znanstvenim aplikacijama, brojeći dane od 1. siječnja 4713. pr. Kr.

Izbor formata vremena ovisi o faktorima kao što su:

• Potrebna preciznost
• Potrebe za ljudskom čitljivošću
• Ograničenja pohrane
• Kompatibilnost s postojećim sustavima
• Raspon datuma koji trebaju biti predstavljeni

Povijest

Koncept Unix vremena nastao je razvojem Unix operativnog sustava u Bell Labs-u krajem 1960-ih i početkom 1970-ih. Odluka da se 1. siječnja 1970. uzme kao epoha bila je pomalo arbitrarnа, ali praktična za to vrijeme - bila je dovoljno blizu da minimizira potrebe za pohranom datuma od interesa, ali dovoljno daleko u prošlosti da bude korisna za povijesne podatke.

Izvorna implementacija koristila je 32-bitni potpisani cijeli broj za pohranu broja sekundi, što je bilo adekvatno za očekivani životni vijek Unix sustava u to vrijeme. Međutim, ova odluka dovela je do problema godine 2038 (ponekad nazvanog "Y2K38" ili "Unix Millennium Bug"), jer 32-bitni potpisani cijeli brojevi mogu predstavljati datume samo do 19. siječnja 2038. (03:14:07 UTC).

Kako su se računalne potrebe razvijale, postala je potrebna veća preciznost timestamp-a:

• Preciznost u milisekundama (13 znamenki) postala je uobičajena s porastom interaktivnog računalstva i potrebom za mjerenjem brzine korisničkog sučelja.

• Preciznost u mikrosekundama (16 znamenki) pojavila se s visokoučinkovitim računalnim aplikacijama i sustavima koji zahtijevaju izuzetno precizno mjerenje vremena.

Kako su Unix i Unix-slični operativni sustavi stekli popularnost, Unix timestamp postao je de facto standard za predstavljanje vremena u računalstvu. Usvojili su ga brojni programski jezici, baze podataka i aplikacije, proširujući se daleko izvan svog izvorno Unix okruženja.

Moderni sustavi sve više koriste 64-bitne cijele brojeve za timestamp-e, što proširuje predstavljeni raspon na približno 292 milijarde godina u oba smjera od epohe, učinkovito rješavajući problem godine 2038. Međutim, naslijeđeni sustavi i aplikacije mogu i dalje biti ranjivi.

Jednostavnost i korisnost Unix timestamp-a osigurale su njegovu kontinuiranu relevantnost unatoč razvoju sofisticiranijih formata prikaza vremena. Ostaje temeljni koncept u računalstvu, koji podržava većinu naše digitalne infrastrukture.

Primjeri Koda

Evo primjera kako pretvoriti Unix timestamp-e različitih preciznosti u ljudski čitljive datume u raznim programskim jezicima:

1// JavaScript konverzija timestamp-a s automatskim prepoznavanjem formata
2function convertTimestamp(timestamp, use12Hour = false) {
3  // Pretvori string u broj ako je potrebno
4  const numericTimestamp = Number(timestamp);
5  
6  // Prepoznaj format timestamp-a na temelju duljine znamenki
7  let date;
8  if (timestamp.length === 16) {
9    // Preciznost u mikrosekundama (podijeli s 1.000.000 da dobiješ sekunde)
10    date = new Date(numericTimestamp / 1000);
11    console.log("Prepoznato: Timestamp u mikrosekundama");
12  } else if (timestamp.length === 13) {
13    // Preciznost u milisekundama
14    date = new Date(numericTimestamp);
15    console.log("Prepoznato: Timestamp u milisekundama");
16  } else if (timestamp.length === 10) {
17    // Standardni Unix timestamp (sekunde)
18    date = new Date(numericTimestamp * 1000);
19    console.log("Prepoznato: Standardni Unix timestamp (sekunde)");
20  } else {
21    throw new Error("Nevažeći format timestamp-a. Očekivano 10, 13 ili 16 znamenki.");
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  // Pretvori u string koristeći lokalno formatiranje
37  return date.toLocaleString(undefined, options);
38}
39
40// Primjer korištenja
41try {
42  // Standardni Unix timestamp (10 znamenki)
43  console.log(convertTimestamp("1609459200", false)); 
44  
45  // Preciznost u milisekundama (13 znamenki)
46  console.log(convertTimestamp("1609459200000", false)); 
47  
48  // Preciznost u mikrosekundama (16 znamenki)
49  console.log(convertTimestamp("1609459200000000", true)); 
50} catch (error) {
51  console.error(error.message);
52}
53

1# Python konverzija timestamp-a s automatskim prepoznavanjem formata
2import datetime
3
4def convert_timestamp(timestamp, use_12hour=False):
5    # Pretvori u cijeli broj
6    timestamp = str(timestamp).strip()
7    numeric_timestamp = int(timestamp)
8    
9    # Prepoznaj format timestamp-a na temelju duljine znamenki
10    if len(timestamp) == 16:
11        # Preciznost u mikrosekundama (podijeli s 1.000.000 da dobiješ sekunde)
12        date = datetime.datetime.fromtimestamp(numeric_timestamp / 1000000)
13        print("Prepoznato: Timestamp u mikrosekundama")
14    elif len(timestamp) == 13:
15        # Preciznost u milisekundama (podijeli s 1.000 da dobiješ sekunde)
16        date = datetime.datetime.fromtimestamp(numeric_timestamp / 1000)
17        print("Prepoznato: Timestamp u milisekundama")
18    elif len(timestamp) == 10:
19        # Standardni Unix timestamp (sekunde)
20        date = datetime.datetime.fromtimestamp(numeric_timestamp)
21        print("Prepoznato: Standardni Unix timestamp (sekunde)")
22    else:
23        raise ValueError("Nevažeći format timestamp-a. Očekivano 10, 13 ili 16 znamenki.")
24    
25    # Formatiraj string datuma
26    if use_12hour:
27        format_string = "%A, %B %d, %Y %I:%M:%S %p"  # 12-satni format s 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# Primjer korištenja
34try:
35    # Standardni Unix timestamp (10 znamenki)
36    print(convert_timestamp("1609459200", False))
37    
38    # Preciznost u milisekundama (13 znamenki)
39    print(convert_timestamp("1609459200000", False))
40    
41    # Preciznost u mikrosekundama (16 znamenki)
42    print(convert_timestamp("1609459200000000", True))
43except ValueError as e:
44    print(e)
45

1<?php
2// PHP konverzija timestamp-a s automatskim prepoznavanjem formata
3function convertTimestamp($timestamp, $use12Hour = false) {
4    // Osiguraj da je timestamp string za provjeru duljine
5    $timestamp = trim((string)$timestamp);
6    
7    // Prepoznaj format timestamp-a na temelju duljine znamenki
8    if (strlen($timestamp) === 16) {
9        // Preciznost u mikrosekundama (podijeli s 1.000.000 da dobiješ sekunde)
10        $seconds = $numericTimestamp / 1000000;
11        echo "Prepoznato: Timestamp u mikrosekundama\n";
12    } elseif (strlen($timestamp) === 13) {
13        // Preciznost u milisekundama
14        $seconds = $numericTimestamp / 1000;
15        echo "Prepoznato: Timestamp u milisekundama\n";
16    } elseif (strlen($timestamp) === 10) {
17        // Standardni Unix timestamp (sekunde)
18        $seconds = $numericTimestamp;
19        echo "Prepoznato: Standardni Unix timestamp (sekunde)\n";
20    } else {
21        throw new Exception("Nevažeći format timestamp-a. Očekivano 10, 13 ili 16 znamenki.");
22    }
23    
24    // Format string
25    $formatString = $use12Hour 
26        ? 'l, F j, Y g:i:s A'  // 12-satni format s AM/PM
27        : 'l, F j, Y H:i:s';   // 24-satni format
28    
29    // Pretvori i formatiraj datum
30    return date($formatString, $seconds);
31}
32
33// Primjer korištenja
34try {
35    // Standardni Unix timestamp (10 znamenki)
36    echo convertTimestamp("1609459200", false) . "\n";
37    
38    // Preciznost u milisekundama (13 znamenki)
39    echo convertTimestamp("1609459200000", false) . "\n";
40    
41    // Preciznost u mikrosekundama (16 znamenki)
42    echo convertTimestamp("1609459200000000", true) . "\n";
43} catch (Exception $e) {
44    echo $e->getMessage() . "\n";
45}
46?>
47

1// Java konverzija timestamp-a s automatskim prepoznavanjem 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        // Trim unosa
10        timestamp = timestamp.trim();
11        
12        // Prepoznaj format timestamp-a na temelju duljine znamenki
13        LocalDateTime dateTime;
14        if (timestamp.length() == 16) {
15            // Preciznost u mikrosekundama (podijeli s 1.000.000 da dobiješ sekunde)
16            long microseconds = Long.parseLong(timestamp);
17            Instant instant = Instant.ofEpochSecond(0, microseconds * 1000); // Pretvori u nanosekunde
18            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
19            System.out.println("Prepoznato: Timestamp u mikrosekundama");
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("Prepoznato: Timestamp u milisekundama");
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("Prepoznato: Standardni Unix timestamp (sekunde)");
32        } else {
33            throw new IllegalArgumentException("Nevažeći format timestamp-a. Očekivano 10, 13 ili 16 znamenki.");
34        }
35        
36        // Kreiraj 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        // Formatiraj datum
42        return dateTime.format(formatter);
43    }
44    
45    public static void main(String[] args) {
46        try {
47            // Standardni Unix timestamp (10 znamenki)
48            System.out.println(convertTimestamp("1609459200", false));
49            
50            // Preciznost u milisekundama (13 znamenki)
51            System.out.println(convertTimestamp("1609459200000", false));
52            
53            // Preciznost u mikrosekundama (16 znamenki)
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 s automatskim prepoznavanjem formata
2using System;
3
4class TimestampConverter
5{
6    public static string ConvertTimestamp(string timestamp, bool use12Hour)
7    {
8        // Trim unosa
9        timestamp = timestamp.Trim();
10        
11        // Prepoznaj format timestamp-a na temelju duljine znamenki
12        DateTime dateTime;
13        if (timestamp.Length == 16)
14        {
15            // Preciznost u mikrosekundama (podijeli s 1.000.000 da dobiješ sekunde)
16            if (!double.TryParse(timestamp, out double microseconds))
17                throw new ArgumentException("Nevažeći format timestamp-a");
18                
19            // Pretvori mikrosekunde u DateTime
20            dateTime = DateTimeOffset.FromUnixTimeSeconds(0).DateTime.AddSeconds(microseconds / 1000000);
21            Console.WriteLine("Prepoznato: Timestamp u mikrosekundama");
22        }
23        else if (timestamp.Length == 13)
24        {
25            // Preciznost u milisekundama
26            if (!long.TryParse(timestamp, out long milliseconds))
27                throw new ArgumentException("Nevažeći format timestamp-a");
28                
29            dateTime = DateTimeOffset.FromUnixTimeMilliseconds(milliseconds).DateTime;
30            Console.WriteLine("Prepoznato: Timestamp u milisekundama");
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("Nevažeći format timestamp-a");
37                
38            dateTime = DateTimeOffset.FromUnixTimeSeconds(seconds).DateTime;
39            Console.WriteLine("Prepoznato: Standardni Unix timestamp (sekunde)");
40        }
41        else
42        {
43            throw new ArgumentException("Nevažeći format timestamp-a. Očekivano 10, 13 ili 16 znamenki.");
44        }
45        
46        // Format string na temelju 12-satnog ili 24-satnog preferencija
47        string formatString = use12Hour 
48            ? "dddd, MMMM d, yyyy h:mm:ss tt"  // 12-satni format s 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 znamenki)
60            Console.WriteLine(ConvertTimestamp("1609459200", false));
61            
62            // Preciznost u milisekundama (13 znamenki)
63            Console.WriteLine(ConvertTimestamp("1609459200000", false));
64            
65            // Preciznost u mikrosekundama (16 znamenki)
66            Console.WriteLine(ConvertTimestamp("1609459200000000", true));
67        }
68        catch (ArgumentException e)
69        {
70            Console.WriteLine(e.Message);
71        }
72    }
73}
74

Rukovanje Rubnim Situacijama

Kada radite s Unix timestamp-ima različitih preciznosti, važno je ispravno obraditi rubne situacije. Evo primjera koji prikazuje sveobuhvatno rukovanje rubnim situacijama:

1// JavaScript sveobuhvatno rukovanje rubnim situacijama za više formata timestamp-a
2function safeConvertTimestamp(timestamp, use12Hour = false) {
3  // Provjera unosa
4  if (timestamp === undefined || timestamp === null || timestamp === '') {
5    return "Greška: Prazan ili neodređen timestamp";
6  }
7  
8  // Osiguraj da je timestamp string za provjeru duljine
9  const timestampStr = String(timestamp).trim();
10  
11  // Provjerite sadrži li timestamp samo znamenke
12  if (!/^\d+$/.test(timestampStr)) {
13    return "Greška: Timestamp mora sadržavati samo znamenke";
14  }
15  
16  // Prepoznaj format na temelju duljine
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); // Pretvori u milisekunde
23      console.log("Obrada timestamp-a u mikrosekundama (16 znamenki)");
24      
25      // Provjera nevažećeg datuma
26      if (isNaN(date.getTime())) {
27        return "Greška: Nevažeći timestamp u mikrosekundama";
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 u milisekundama (13 znamenki)");
34      
35      // Provjera nevažećeg datuma
36      if (isNaN(date.getTime())) {
37        return "Greška: Nevažeći timestamp u milisekundama";
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 znamenki)");
44      
45      // Provjera nevažećeg datuma
46      if (isNaN(date.getTime())) {
47        return "Greška: Nevažeći standardni timestamp";
48      }
49      
50      // Provjera problema s Y2K38 (za 32-bitne sustave)
51      const maxInt32 = 2147483647; // Maksimalna vrijednost za 32-bitni potpisani cijeli broj
52      if (seconds > maxInt32) {
53        console.warn("Upozorenje: Timestamp premašuje granicu 32-bitnog cijelog broja (Y2K38 problem)");
54      }
55    } else {
56      return "Greška: Nevažeća duljina timestamp-a. Očekivano 10, 13 ili 16 znamenki.";
57    }
58    
59    // Formatiraj 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 pri konverziji timestamp-a: " + error.message;
74  }
75}
76
77// Testiraj s raznim rubnim situacijama
78console.log(safeConvertTimestamp("1609459200"));      // Standardni (10 znamenki)
79console.log(safeConvertTimestamp("1609459200000"));   // Milisekunde (13 znamenki)
80console.log(safeConvertTimestamp("1609459200000000")); // Mikrosekunde (16 znamenki)
81console.log(safeConvertTimestamp("abc123"));          // Ne-numerički
82console.log(safeConvertTimestamp("12345"));           // Nevažeća duljina
83console.log(safeConvertTimestamp("9999999999999999")); // Vrlo veliki timestamp u mikrosekundama
84console.log(safeConvertTimestamp(""));                // Prazan string
85

Često Postavljana Pitanja

Što je Unix timestamp?

Unix timestamp je broj sekundi koje su prošle od 1. siječnja 1970. (ponoć UTC/GMT), ne računajući prijestupne sekunde. Pruža kompaktan, neovisan o jeziku prikaz određenog trenutka u vremenu.

Kako funkcionira automatsko prepoznavanje formata timestamp-a?

Konverter automatski prepoznaje format timestamp-a na temelju broja znamenki:

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

Zašto bih trebao milisekundnu ili mikrosekundnu preciznost?

Preciznost u milisekundama (13 znamenki) korisna je za aplikacije koje zahtijevaju točnije mjerenje vremena, kao što su praćenje performansi, praćenje interakcije korisnika i određene financijske aplikacije. Preciznost u mikrosekundama (16 znamenki) potrebna je za visokoučinkovito računalstvo, znanstvene aplikacije i sustave visoke frekvencije trgovanja gdje je izuzetno precizno mjerenje vremena ključno.

Mogu li koristiti Unix timestamp-e za zakazivanje budućih događaja?

Da, Unix timestampi se široko koriste za zakazivanje. Međutim, za vrlo daleke buduće datume, budite svjesni potencijalnih ograničenja kao što su problem godine 2038 za 32-bitne sustave i rukovanje promjenama vremenskih zona i prijelazima na ljetno računanje vremena.

Što je problem godine 2038?

Problem godine 2038 nastaje jer mnogi sustavi pohranjuju Unix timestamp-e kao 32-bitne potpisane cijele brojeve, koji mogu predstavljati datume samo do 19. siječnja 2038. (03:14:07 UTC). Nakon ovog trenutka, cijeli broj će se preopteretiti, što može uzrokovati kvarove sustava. Moderni sustavi sve više koriste 64-bitne cijele brojeve kako bi izbjegli ovaj problem.

Kako da rukujem konverzijama vremenskih zona s Unix timestamp-ima?

Unix timestampi su uvijek u UTC (Koordinirano univerzalno vrijeme). Da biste se pretvorili u određenu vremensku zonu, trebate primijeniti odgovarajući pomak nakon što timestamp pretvorite 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 vrijeme je numerička reprezentacija (sekunde od epohe), dok je ISO 8601 string format (npr., "2021-01-01T00:00:00Z"). Unix vrijeme je kompaktnije i lakše se koristi za izračune, dok je ISO 8601 čitljiviji za ljude i samopopisiv.

Koliko su točni Unix timestampi?

Standardni Unix timestampi imaju preciznost na razini sekundi. Za aplikacije koje zahtijevaju veću preciznost, timestampi u milisekundama (13 znamenki) pružaju preciznost od 1/1000 sekunde, a timestampi u mikrosekundama (16 znamenki) nude preciznost od 1/1.000.000 sekunde.

Da li Unix timestampi uzimaju u obzir prijestupne sekunde?

Ne, Unix vrijeme se definira kao broj sekundi od epohe, isključujući prijestupne sekunde. To znači da tijekom prijestupne sekunde, Unix timestamp ne povećava se. To može uzrokovati probleme u aplikacijama koje zahtijevaju precizno astronomijsko vrijeme.

Mogu li koristiti Unix timestamp-e za zakazivanje budućih događaja?

Da, Unix timestampi se široko koriste za zakazivanje. Međutim, za vrlo daleke buduće datume, budite svjesni potencijalnih ograničenja poput problema godine 2038 za 32-bitne sustave i rukovanja promjenama vremenskih zona i prijelazima na ljetno 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 vrijeme 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 mjerenje vremena u visokoučinkovitom računalstvu." ACM Computing Surveys, https://dl.acm.org/doi/10.1145/3232678

8. "Predstavljanje vremena u financijskim sustavima." Časopis financijske tehnologije, https://www.fintech-journal.com/time-representation

Isprobajte naš konverter timestamp-a sada kako biste lako pretvorili Unix timestamp-e bilo koje preciznosti u ljudski čitljive datume. Bilo da radite sa standardnim Unix timestamp-ima, timestamp-ima u milisekundama ili timestamp-ima u mikrosekundama, naš alat automatski prepoznaje format i pruža točne konverzije.