Unix-aikaleiman muunnin

Johdanto

Unix-aikaleima (tunnetaan myös nimellä POSIX-aika tai Epoch-aika) on järjestelmä ajankohdan kuvaamiseen. Se on sekuntien määrä, joka on kulunut tammikuun 1. päivästä 1970 (keskiyö UTC/GMT), mukaan lukien karkaussekunteja. Unix-aikaleimoja käytetään laajalti tietokonejärjestelmissä ja ohjelmointikielissä, koska ne tarjoavat kompaktin, kieliriippumattoman esityksen tietystä hetkestä ajassa.

Tämä aikaleiman muunnin havaitsee ja käsittelee automaattisesti eri pituisia aikaleimoja, mukaan lukien mikrosekunnin tarkkuus (16 numeroa), millisekunnin tarkkuus (13 numeroa) ja tavalliset Unix-aikaleimat (10 numeroa). Työkalu tunnistaa aikaleiman muodon syötteen pituuden perusteella, muuntaa sen ihmisen luettavaksi päivämääräksi ja aikamuodoksi ja näyttää tuloksen ilman, että käyttäjien tarvitsee määrittää aikaleiman tyyppiä. Se tukee sekä 12 tunnin (AM/PM) että 24 tunnin aikamuotoja, jotta se voi mukautua erilaisiin alueellisiin ja henkilökohtaisiin mieltymyksiin.

Kuinka Unix-aikaleimat toimivat

Unix-aikaleimat lasketaan sekuntien määränä Unix-epochista (tammikuun 1. päivä 1970, 00:00:00 UTC). Tämä tekee niistä erityisen hyödyllisiä aikavälin laskemisessa ja päivämäärien tallentamisessa kompaktissa muodossa.

Matemaattinen muunnos Unix-aikaleimasta kalenteripäivämääräksi sisältää useita vaiheita:

1. Aloita Unix-epochista (tammikuun 1. päivä 1970, 00:00:00 UTC)
2. Lisää aikaleimassa oleva sekuntien määrä
3. Ota huomioon karkausvuodet, vaihteleva kuukausien pituus ja muut kalenterin monimutkaisuudet
4. Tee aikavyöhykkeen säädöt tarvittaessa

Esimerkiksi Unix-aikaleima 1609459200 edustaa perjantaita, tammikuun 1. päivää 2021, 00:00:00 UTC.

Muunna kaava voidaan esittää seuraavasti:

$\text{Päivämäärä} = \text{Unix-epoch} + \text{Aikaleima (sekunteina)}$

Useimmat ohjelmointikielet ja käyttöjärjestelmät tarjoavat sisäänrakennettuja toimintoja tämän muunnoksen käsittelemiseksi, piilottaen monimutkaiset kalenterilaskelmat.

Aikaleiman muodot ja automaattinen havaitseminen

Muunne tukee kolmea yleistä aikaleimamallia, jotka havaitaan automaattisesti numeroiden pituuden perusteella:

1. Tavallinen Unix-aikaleima (10 numeroa): Edustaa sekunteja Unix-epochista. Esimerkki: 1609459200 (tammikuu 1, 2021, 00:00:00 UTC)

2. Millisekunnin tarkkuus (13 numeroa): Edustaa millisekunteja Unix-epochista. Esimerkki: 1609459200000 (tammikuu 1, 2021, 00:00:00 UTC)

3. Mikrosekunnin tarkkuus (16 numeroa): Edustaa mikrosekunteja Unix-epochista. Esimerkki: 1609459200000000 (tammikuu 1, 2021, 00:00:00 UTC)

Automaattinen havaitseminen toimii analysoimalla syötteen pituutta:

• Jos syöte sisältää 10 numeroa, se käsitellään tavallisena Unix-aikaleimana (sekunteina)
• Jos syöte sisältää 13 numeroa, se käsitellään millisekuntiaikaleimana
• Jos syöte sisältää 16 numeroa, se käsitellään mikrosekuntiaikaleimana

Tämä automaattinen havaitseminen poistaa tarpeen käyttäjien määrittää aikaleiman tyyppi, mikä tekee työkalusta käyttäjäystävällisemmän ja tehokkaamman.

Aikamuoto-ominaisuudet

Tämä muunnin tarjoaa kaksi aikamuoto-ominaisuutta:

1. 24 tunnin muoto (joita kutsutaan joskus "sotilasaikamuodoksi"): Tunnit vaihtelevat välillä 0–23, eikä AM/PM-merkintää ole. Esimerkiksi klo 15:00 esitetään muodossa 15:00.

2. 12 tunnin muoto: Tunnit vaihtelevat välillä 1–12, AM (ante meridiem) ajalle keskiyöstä keskipäivään ja PM (post meridiem) ajalle keskipäivästä keskiyöhön. Esimerkiksi klo 15:00 24 tunnin muodossa esitetään muodossa 3:00 PM.

Valinta näiden muotojen välillä on suurelta osin alueellisten käytäntöjen ja henkilökohtaisten mieltymysten kysymys:

• 24 tunnin muotoa käytetään yleisesti suurimmassa osassa Eurooppaa, Latinalaisessa Amerikassa ja Aasiassa sekä tieteellisissä, sotilaallisissa ja lääketieteellisissä konteksteissa ympäri maailmaa.
• 12 tunnin muoto on yleinen Yhdysvalloissa, Kanadassa, Australiassa ja joissakin muissa englanninkielisissä maissa jokapäiväisessä käytössä.

Äärimmäiset tapaukset ja rajoitukset

Työskennellessäsi eri tarkkuuksien Unix-aikaleimojen kanssa on tärkeää olla tietoinen useista äärimmäisistä tapauksista ja rajoituksista:

1. Negatiiviset aikaleimat: Nämä edustavat päivämääriä ennen Unix-epochia (tammikuu 1, 1970). Vaikka ne ovat matemaattisesti voimassa, jotkin järjestelmät eivät välttämättä käsittele negatiivisia aikaleimoja oikein. Tämä koskee kaikkia kolmea aikaleimamallia.

2. Vuosi 2038 -ongelma: Tavalliset Unix-aikaleimat (10 numeroa) tallennetaan usein 32-bittisiin allekirjoitettuihin kokonaislukuihin, jotka ylivuotavat tammikuun 19. päivänä 2038. Tämän jälkeen 32-bittiset järjestelmät eivät pysty esittämään aikoja oikein, ellei niitä muuteta käyttämään suurempaa kokonaislukutyyppiä.

3. Tarkkuusnäkökohdat:

   • Tavalliset aikaleimat (10 numeroa) tarjoavat sekunnin tason tarkkuuden, mikä riittää useimpiin jokapäiväisiin sovelluksiin.
   • Millisekunnin aikaleimat (13 numeroa) tarjoavat 1000-kertaisen tarkkuuden, mikä on hyödyllistä sovelluksille, jotka vaativat tarkempaa ajoitusta.
   • Mikrosekunnin aikaleimat (16 numeroa) tarjoavat vielä hienompaa tarkkuutta (1/1 000 000 sekuntia), mikä on tarpeen huipputehokkaassa laskennassa, tieteellisissä sovelluksissa ja tietyissä rahoitustapahtumissa.

4. Erittäin suuret aikaleimat: Erittäin kaukaisia tulevaisuuden päivämääriä ei ehkä voida esittää joissakin järjestelmissä tai niitä saatetaan käsitellä epäjohdonmukaisesti. Tämä on erityisen tärkeää millisekunnin ja mikrosekunnin aikaleimoille, jotka käyttävät suurempia numeerisia arvoja.

5. Karkaussekunnit: Unix-aika ei ota huomioon karkaussekunteja, joita lisätään satunnaisesti UTC:hen maan pyörimisen epäsäännöllisyyksien korjaamiseksi. Tämä tarkoittaa, että Unix-aika ei ole tarkasti synkronoitu astronomisen ajan kanssa.

6. Aikavyöhykkeen näkökohdat: Unix-aikaleimat edustavat hetkiä UTC:ssä. Paikalliseen aikaan muuntaminen vaatii lisätietoa aikavyöhykkeestä.

7. Kesäaika: Kun muunnat aikaleimoja paikalliseen aikaan, on otettava huomioon kesäajan siirtymien monimutkaisuudet.

8. Aikaleiman muotoon liittyvä hämmennys: Ilman asianmukaista havaitsemista 13 numeroa sisältävä millisekunnin aikaleima saatetaan virheellisesti tulkita erittäin kaukaiseksi tulevaisuuden päivämääräksi, jos sitä käsitellään sekuntipohjaisena aikaleimana. Muunnin estää tämän automaattisella muodon havaitsemisella numeroiden pituuden perusteella.

Käyttötapaukset

Eri tarkkuuksien Unix-aikaleimoja käytetään monissa sovelluksissa tietojenkäsittelyssä ja datanhallinnassa:

1. Tietokantarekisterit: Aikaleimoja käytetään yleisesti tallentamaan, milloin merkinnät on luotu tai muutettu.

   • Tavalliset aikaleimat (10 numeroa) ovat usein riittäviä yleisissä tietokantasovelluksissa.
   • Millisekunnin aikaleimat (13 numeroa) käytetään, kun tarvitaan tarkempaa tapahtumien järjestystä.

2. Verkkokehitys: HTTP-otsikot, evästeet ja välimuistimekanismit käyttävät usein Unix-aikaleimoja.

   • JavaScriptin Date.now() palauttaa millisekunnin aikaleimat (13 numeroa).

3. Lokitiedostot: Järjestelmän lokit tallentavat tyypillisesti tapahtumia Unix-aikaleimoilla tarkan aikajärjestyksen saavuttamiseksi.

   • Korkean taajuuden lokitusjärjestelmät saattavat käyttää millisekunnin tai mikrosekunnin tarkkuutta.

4. Versionhallintajärjestelmät: Git ja muut VCS:t käyttävät aikaleimoja tallentaakseen, milloin sitoumukset on tehty.

5. API-vastaukset: Monet verkkosovellusrajapinnat sisältävät aikaleimoja vastauksissaan osoittaakseen, milloin tiedot on luotu tai milloin resursseja on viimeksi muutettu.

   • REST-rajapinnat käyttävät usein millisekunnin tarkkuuden aikaleimoja.

6. Tiedostojärjestelmät: Tiedostojen luonti- ja muokkausaikoja tallennetaan usein Unix-aikaleimoina.

7. Istunnon hallinta: Verkkosovellukset käyttävät aikaleimoja määrittääkseen, milloin käyttäjäistunnot tulisi vanhentaa.

8. Datan analyysi: Aikaleimat tarjoavat standardoidun tavan työskennellä aikadatan kanssa analytiikkasovelluksissa.

9. Korkean taajuuden kaupankäynti: Rahoitusjärjestelmät vaativat usein mikrosekunnin tarkkuutta (16 numeroa) tapahtumien oikean järjestyksen saavuttamiseksi.

10. Tieteelliset mittaukset: Tutkimuslaitteet voivat tallentaa havaintoja mikrosekunnin tarkkuudella tarkan aikalyönnin analyysin saavuttamiseksi.

Vaihtoehdot

Vaikka Unix-aikaleimat ovat laajalti käytössä, on olemassa vaihtoehtoisia aikamuotoja, jotka saattavat olla sopivampia tietyissä konteksteissa:

1. ISO 8601: Standardoitu merkkijonomuoto (esim. "2021-01-01T00:00:00Z"), joka on ihmiselle luettavissa mutta säilyttää lajittelukelpoisuuden. Sitä käytetään usein tiedonvaihdossa ja käyttäjäystävällisissä sovelluksissa.

2. RFC 3339: ISO 8601:n profiili, jota käytetään internetprotokollissa, tiukemmilla muotoiluvaatimuksilla.

3. Ihmisen luettavat muodot: Paikalliset päivämäärämerkkijonot (esim. "1. tammikuuta 2021") ovat sopivampia suoraan käyttäjävuorovaikutukseen, mutta vähemmän sopivia laskentaan.

4. Microsoft FILETIME: 64-bittinen arvo, joka edustaa 100-nanosekunnin aikavälejä tammikuun 1. päivästä 1601, jota käytetään Windows-järjestelmissä.

5. Julian Day Number: Käytetään tähtitieteessä ja joissakin tieteellisissä sovelluksissa, lasketaan päiviä tammikuun 1. päivästä 4713 eaa.

Aikamuodon valinta riippuu tekijöistä, kuten:

• Tarvittava tarkkuus
• Ihmisen luettavuuden tarpeet
• Tallennusrajoitukset
• Yhteensopivuus olemassa olevien järjestelmien kanssa
• Edustettavien päivämäärien alue

Historia

Unix-ajan käsite syntyi Unix-käyttöjärjestelmän kehittämisen myötä Bell Labsissa 1960- ja 1970-luvuilla. Päätös käyttää tammikuun 1. päivää 1970 epochina oli jossain määrin satunnainen mutta käytännöllinen tuolloin – se oli tarpeeksi uusi vähentämään tallennustarvetta kiinnostaville päivämäärille, mutta tarpeeksi kaukana menneisyydessä ollakseen hyödyllinen historiallisille tiedoille.

Alkuperäinen toteutus käytti 32-bittistä allekirjoitettua kokonaislukua sekuntien määrän tallentamiseen, mikä oli riittävää Unix-järjestelmien odotetulle elinkaarelle tuolloin. Kuitenkin tämä päätös johti Vuosi 2038 -ongelmaan (joita kutsutaan joskus "Y2K38" tai "Unixin vuosituhatbugi"), koska 32-bittiset allekirjoitetut kokonaisluvut voivat edustaa vain aikoja tammikuun 19. päivään 2038 asti (03:14:07 UTC).

Kun laskentatarpeet kehittyivät, tarkkuuden aikaleimat tulivat tarpeellisiksi:

• Millisekunnin tarkkuus (13 numeroa) tuli yleiseksi interaktiivisen laskennan ja käyttäjäliittymän reagointikyvyn mittaamisen tarpeen myötä.

• Mikrosekunnin tarkkuus (16 numeroa) syntyi huipputehokkaiden laskentaprosessien ja järjestelmien myötä, jotka vaativat äärimmäisen tarkkaa ajoitusta.

Kun Unix- ja Unix-tyyppiset käyttöjärjestelmät saivat suosiota, Unix-aikaleimasta tuli de facto -standardi ajan esittämiseen tietojenkäsittelyssä. Sitä hyväksyttiin lukuisissa ohjelmointikielissä, tietokannoissa ja sovelluksissa, laajentuen kauas alkuperäisestä Unix-ympäristöstään.

Nykyajan järjestelmät käyttävät yhä enemmän 64-bittisiä kokonaislukuja aikaleimojen tallentamiseen, mikä laajentaa edustettavan alueen noin 292 miljardiin vuoteen molempiin suuntiin epochista, mikä käytännössä ratkaisee Vuosi 2038 -ongelman. Kuitenkin vanhat järjestelmät ja sovellukset saattavat silti olla alttiita.

Unix-aikaleiman yksinkertaisuus ja hyödyllisyys ovat varmistaneet sen jatkuvan merkityksen huolimatta kehittyneemmistä aikamuotojen esityksistä. Se pysyy keskeisenä käsitteenä tietojenkäsittelyssä, joka tukee suurinta osaa digitaalista infrastruktuuria.

Koodiesimerkit

Tässä on esimerkkejä siitä, kuinka muuntaa Unix-aikaleimoja eri tarkkuuksilla ihmisen luettaviksi päivämääriksi eri ohjelmointikielissä:

1// JavaScript aikaleiman muunnos automaattisella muodon havaitsemisella
2function convertTimestamp(timestamp, use12Hour = false) {
3  // Muunna merkkijono numeroksi tarvittaessa
4  const numericTimestamp = Number(timestamp);
5  
6  // Tunnista aikaleiman muoto numeroiden pituuden perusteella
7  let date;
8  if (timestamp.length === 16) {
9    // Mikrosekunnin tarkkuus (jaetaan 1 000 000:lla saadaksemme sekunnit)
10    date = new Date(numericTimestamp / 1000);
11    console.log("Havaitut: Mikrosekunnin tarkkuus aikaleima");
12  } else if (timestamp.length === 13) {
13    // Millisekunnin tarkkuus
14    date = new Date(numericTimestamp);
15    console.log("Havaitut: Millisekunnin tarkkuus aikaleima");
16  } else if (timestamp.length === 10) {
17    // Tavallinen Unix-aikaleima (sekunnit)
18    date = new Date(numericTimestamp * 1000);
19    console.log("Havaitut: Tavallinen Unix-aikaleima (sekunnit)");
20  } else {
21    throw new Error("Virheellinen aikaleiman muoto. Odotettiin 10, 13 tai 16 numeroa.");
22  }
23  
24  // Muotoiluvaihtoehdot
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  // Muunna merkkijonoksi paikallisen muotoilun avulla
37  return date.toLocaleString(undefined, options);
38}
39
40// Esimerkkikäyttö
41try {
42  // Tavallinen Unix-aikaleima (10 numeroa)
43  console.log(convertTimestamp("1609459200", false)); 
44  
45  // Millisekunnin tarkkuus (13 numeroa)
46  console.log(convertTimestamp("1609459200000", false)); 
47  
48  // Mikrosekunnin tarkkuus (16 numeroa)
49  console.log(convertTimestamp("1609459200000000", true)); 
50} catch (error) {
51  console.error(error.message);
52}
53

1# Python aikaleiman muunnos automaattisella muodon havaitsemisella
2import datetime
3
4def convert_timestamp(timestamp, use_12hour=False):
5    # Muunna kokonaisluvuksi
6    timestamp = str(timestamp).strip()
7    numeric_timestamp = int(timestamp)
8    
9    # Tunnista aikaleiman muoto numeroiden pituuden perusteella
10    if len(timestamp) == 16:
11        # Mikrosekunnin tarkkuus (jaetaan 1 000 000:lla saadaksemme sekunnit)
12        date = datetime.datetime.fromtimestamp(numeric_timestamp / 1000000)
13        print("Havaitut: Mikrosekunnin tarkkuus aikaleima")
14    elif len(timestamp) == 13:
15        # Millisekunnin tarkkuus (jaetaan 1 000:lla saadaksemme sekunnit)
16        date = datetime.datetime.fromtimestamp(numeric_timestamp / 1000)
17        print("Havaitut: Millisekunnin tarkkuus aikaleima")
18    elif len(timestamp) == 10:
19        # Tavallinen Unix-aikaleima (sekunnit)
20        date = datetime.datetime.fromtimestamp(numeric_timestamp)
21        print("Havaitut: Tavallinen Unix-aikaleima (sekunnit)")
22    else:
23        raise ValueError("Virheellinen aikaleiman muoto. Odotettiin 10, 13 tai 16 numeroa.")
24    
25    # Muotoile päivämäärämerkkijono
26    if use_12hour:
27        format_string = "%A, %B %d, %Y %I:%M:%S %p"  # 12 tunnin muoto AM/PM
28    else:
29        format_string = "%A, %B %d, %Y %H:%M:%S"     # 24 tunnin muoto
30    
31    return date.strftime(format_string)
32
33# Esimerkkikäyttö
34try:
35    # Tavallinen Unix-aikaleima (10 numeroa)
36    print(convert_timestamp("1609459200", False))
37    
38    # Millisekunnin tarkkuus (13 numeroa)
39    print(convert_timestamp("1609459200000", False))
40    
41    # Mikrosekunnin tarkkuus (16 numeroa)
42    print(convert_timestamp("1609459200000000", True))
43except ValueError as e:
44    print(e)
45

1<?php
2// PHP aikaleiman muunnos automaattisella muodon havaitsemisella
3function convertTimestamp($timestamp, $use12Hour = false) {
4    // Varmista, että aikaleima on merkkijono pituuden tarkistamista varten
5    $timestamp = trim((string)$timestamp);
6    
7    // Tunnista aikaleiman muoto numeroiden pituuden perusteella
8    if (strlen($timestamp) === 16) {
9        // Mikrosekunnin tarkkuus (jaetaan 1 000 000:lla saadaksemme sekunnit)
10        $seconds = $numericTimestamp / 1000000;
11        echo "Havaitut: Mikrosekunnin tarkkuus aikaleima\n";
12    } elseif (strlen($timestamp) === 13) {
13        // Millisekunnin tarkkuus
14        $seconds = $numericTimestamp / 1000;
15        echo "Havaitut: Millisekunnin tarkkuus aikaleima\n";
16    } elseif (strlen($timestamp) === 10) {
17        // Tavallinen Unix-aikaleima (sekunnit)
18        $seconds = $numericTimestamp;
19        echo "Havaitut: Tavallinen Unix-aikaleima (sekunnit)\n";
20    } else {
21        throw new Exception("Virheellinen aikaleiman muoto. Odotettiin 10, 13 tai 16 numeroa.");
22    }
23    
24    // Muotoilustring
25    $formatString = $use12Hour 
26        ? 'l, F j, Y g:i:s A'  // 12 tunnin muoto AM/PM
27        : 'l, F j, Y H:i:s';   // 24 tunnin muoto
28    
29    // Muunna ja muotoile päivämäärä
30    return date($formatString, $seconds);
31}
32
33// Esimerkkikäyttö
34try {
35    // Tavallinen Unix-aikaleima (10 numeroa)
36    echo convertTimestamp("1609459200", false) . "\n";
37    
38    // Millisekunnin tarkkuus (13 numeroa)
39    echo convertTimestamp("1609459200000", false) . "\n";
40    
41    // Mikrosekunnin tarkkuus (16 numeroa)
42    echo convertTimestamp("1609459200000000", true) . "\n";
43} catch (Exception $e) {
44    echo $e->getMessage() . "\n";
45}
46?>
47

1// Java aikaleiman muunnos automaattisella muodon havaitsemisella
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        // Trimmaa syöte
10        timestamp = timestamp.trim();
11        
12        // Tunnista aikaleiman muoto numeroiden pituuden perusteella
13        LocalDateTime dateTime;
14        if (timestamp.length() == 16) {
15            // Mikrosekunnin tarkkuus (jaetaan 1 000 000:lla saadaksemme sekunnit)
16            long microseconds = Long.parseLong(timestamp);
17            Instant instant = Instant.ofEpochSecond(0, microseconds * 1000); // Muunna nanosekunniksi
18            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
19            System.out.println("Havaitut: Mikrosekunnin tarkkuus aikaleima");
20        } else if (timestamp.length() == 13) {
21            // Millisekunnin tarkkuus
22            long milliseconds = Long.parseLong(timestamp);
23            Instant instant = Instant.ofEpochMilli(milliseconds);
24            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
25            System.out.println("Havaitut: Millisekunnin tarkkuus aikaleima");
26        } else if (timestamp.length() == 10) {
27            // Tavallinen Unix-aikaleima (sekunnit)
28            long seconds = Long.parseLong(timestamp);
29            Instant instant = Instant.ofEpochSecond(seconds);
30            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
31            System.out.println("Havaitut: Tavallinen Unix-aikaleima (sekunnit)");
32        } else {
33            throw new IllegalArgumentException("Virheellinen aikaleiman muoto. Odotettiin 10, 13 tai 16 numeroa.");
34        }
35        
36        // Luo muotoilija halutun muodon perusteella
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        // Muotoile päivämäärä
42        return dateTime.format(formatter);
43    }
44    
45    public static void main(String[] args) {
46        try {
47            // Tavallinen Unix-aikaleima (10 numeroa)
48            System.out.println(convertTimestamp("1609459200", false));
49            
50            // Millisekunnin tarkkuus (13 numeroa)
51            System.out.println(convertTimestamp("1609459200000", false));
52            
53            // Mikrosekunnin tarkkuus (16 numeroa)
54            System.out.println(convertTimestamp("1609459200000000", true));
55        } catch (IllegalArgumentException e) {
56            System.err.println(e.getMessage());
57        }
58    }
59}
60

1// C# aikaleiman muunnos automaattisella muodon havaitsemisella
2using System;
3
4class TimestampConverter
5{
6    public static string ConvertTimestamp(string timestamp, bool use12Hour)
7    {
8        // Trimmaa syöte
9        timestamp = timestamp.Trim();
10        
11        // Tunnista aikaleiman muoto numeroiden pituuden perusteella
12        DateTime dateTime;
13        if (timestamp.Length == 16)
14        {
15            // Mikrosekunnin tarkkuus (jaetaan 1 000 000:lla saadaksemme sekunnit)
16            if (!double.TryParse(timestamp, out double microseconds))
17                throw new ArgumentException("Virheellinen aikaleiman muoto");
18                
19            // Muunna mikrosekunnit DateTime:ksi
20            dateTime = DateTimeOffset.FromUnixTimeSeconds(0).DateTime.AddSeconds(microseconds / 1000000);
21            Console.WriteLine("Havaitut: Mikrosekunnin tarkkuus aikaleima");
22        }
23        else if (timestamp.Length == 13)
24        {
25            // Millisekunnin tarkkuus
26            if (!long.TryParse(timestamp, out long milliseconds))
27                throw new ArgumentException("Virheellinen aikaleiman muoto");
28                
29            dateTime = DateTimeOffset.FromUnixTimeMilliseconds(milliseconds).DateTime;
30            Console.WriteLine("Havaitut: Millisekunnin tarkkuus aikaleima");
31        }
32        else if (timestamp.Length == 10)
33        {
34            // Tavallinen Unix-aikaleima (sekunnit)
35            if (!long.TryParse(timestamp, out long seconds))
36                throw new ArgumentException("Virheellinen aikaleiman muoto");
37                
38            dateTime = DateTimeOffset.FromUnixTimeSeconds(seconds).DateTime;
39            Console.WriteLine("Havaitut: Tavallinen Unix-aikaleima (sekunnit)");
40        }
41        else
42        {
43            throw new ArgumentException("Virheellinen aikaleiman muoto. Odotettiin 10, 13 tai 16 numeroa.");
44        }
45        
46        // Muotoilustring 12 tunnin tai 24 tunnin mieltymyksen perusteella
47        string formatString = use12Hour 
48            ? "dddd, MMMM d, yyyy h:mm:ss tt"  // 12 tunnin muoto AM/PM
49            : "dddd, MMMM d, yyyy HH:mm:ss";   // 24 tunnin muoto
50        
51        // Palauta muotoiltu päivämäärämerkkijono
52        return dateTime.ToString(formatString);
53    }
54    
55    static void Main()
56    {
57        try
58        {
59            // Tavallinen Unix-aikaleima (10 numeroa)
60            Console.WriteLine(ConvertTimestamp("1609459200", false));
61            
62            // Millisekunnin tarkkuus (13 numeroa)
63            Console.WriteLine(ConvertTimestamp("1609459200000", false));
64            
65            // Mikrosekunnin tarkkuus (16 numeroa)
66            Console.WriteLine(ConvertTimestamp("1609459200000000", true));
67        }
68        catch (ArgumentException e)
69        {
70            Console.WriteLine(e.Message);
71        }
72    }
73}
74

Äärimmäisten tapausten käsittely

Työskennellessäsi eri tarkkuuksien Unix-aikaleimojen kanssa on tärkeää käsitellä äärimmäiset tapaukset oikein. Tässä on esimerkki, joka havainnollistaa kattavaa äärimmäisten tapausten käsittelyä:

1// JavaScript kattava äärimmäisten tapausten käsittely useille aikaleimamalleille
2function safeConvertTimestamp(timestamp, use12Hour = false) {
3  // Syötteen validointi
4  if (timestamp === undefined || timestamp === null || timestamp === '') {
5    return "Virhe: Tyhjät tai määrittelemättömät aikaleimat";
6  }
7  
8  // Varmista, että aikaleima on merkkijono pituuden tarkistamista varten
9  const timestampStr = String(timestamp).trim();
10  
11  // Tarkista, sisältääkö aikaleima vain numeroita
12  if (!/^\d+$/.test(timestampStr)) {
13    return "Virhe: Aikaleiman on sisältävä vain numeroita";
14  }
15  
16  // Tunnista muoto pituuden perusteella
17  let date;
18  try {
19    if (timestampStr.length === 16) {
20      // Mikrosekunnin tarkkuus
21      const microseconds = Number(timestampStr);
22      date = new Date(microseconds / 1000); // Muunna millisekunneiksi
23      console.log("Käsitellään mikrosekunnin aikaleimaa (16 numeroa)");
24      
25      // Tarkista virheellinen päivämäärä
26      if (isNaN(date.getTime())) {
27        return "Virhe: Virheellinen mikrosekunnin aikaleima";
28      }
29    } else if (timestampStr.length === 13) {
30      // Millisekunnin tarkkuus
31      const milliseconds = Number(timestampStr);
32      date = new Date(milliseconds);
33      console.log("Käsitellään millisekunnin aikaleimaa (13 numeroa)");
34      
35      // Tarkista virheellinen päivämäärä
36      if (isNaN(date.getTime())) {
37        return "Virhe: Virheellinen millisekunnin aikaleima";
38      }
39    } else if (timestampStr.length === 10) {
40      // Tavallinen Unix-aikaleima (sekunnit)
41      const seconds = Number(timestampStr);
42      date = new Date(seconds * 1000);
43      console.log("Käsitellään tavallista aikaleimaa (10 numeroa)");
44      
45      // Tarkista virheellinen päivämäärä
46      if (isNaN(date.getTime())) {
47        return "Virhe: Virheellinen tavallinen aikaleima";
48      }
49      
50      // Tarkista Y2K38-ongelma (32-bittisille järjestelmille)
51      const maxInt32 = 2147483647; // 32-bittisen allekirjoitetun kokonaisluvun maksimiarvo
52      if (seconds > maxInt32) {
53        console.warn("Varoitus: Aikaleima ylittää 32-bittisen kokonaisluvun rajan (Y2K38-ongelma)");
54      }
55    } else {
56      return "Virhe: Virheellinen aikaleiman pituus. Odotettiin 10, 13 tai 16 numeroa.";
57    }
58    
59    // Muotoile päivämäärä
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 "Virhe aikaleiman muunnossa: " + error.message;
74  }
75}
76
77// Testaa erilaisilla äärimmäisillä tapauksilla
78console.log(safeConvertTimestamp("1609459200"));      // Tavallinen (10 numeroa)
79console.log(safeConvertTimestamp("1609459200000"));   // Millisekunnit (13 numeroa)
80console.log(safeConvertTimestamp("1609459200000000")); // Mikrosekunnit (16 numeroa)
81console.log(safeConvertTimestamp("abc123"));          // Ei-numeerinen
82console.log(safeConvertTimestamp("12345"));           // Virheellinen pituus
83console.log(safeConvertTimestamp("9999999999999999")); // Erittäin suuri mikrosekunnin aikaleima
84console.log(safeConvertTimestamp(""));                // Tyhjät merkit
85

Usein kysytyt kysymykset

Mikä on Unix-aikaleima?

Unix-aikaleima on sekuntien määrä, joka on kulunut tammikuun 1. päivästä 1970 (keskiyö UTC/GMT), mukaan lukien karkaussekunteja. Se tarjoaa kompaktin, kieliriippumattoman tavan esittää tietty hetki ajassa.

Kuinka automaattinen aikaleiman muodon havaitseminen toimii?

Muunnin havaitsee automaattisesti aikaleiman muodon numeroiden pituuden perusteella:

• 10 numeroa: Tavallinen Unix-aikaleima (sekunteja epochista)
• 13 numeroa: Millisekunnin tarkkuus aikaleima
• 16 numeroa: Mikrosekunnin tarkkuus aikaleima

Miksi tarvitsisin millisekunnin tai mikrosekunnin tarkkuuden?

Millisekunnin tarkkuus (13 numeroa) on hyödyllinen sovelluksille, jotka vaativat tarkempaa ajoitusta, kuten suorituskyvyn seurantaa, käyttäjävuorovaikutuksen seurantaa ja tiettyjä rahoitussovelluksia. Mikrosekunnin tarkkuus (16 numeroa) on tarpeen huipputehokkaassa laskennassa, tieteellisissä sovelluksissa ja korkean taajuuden kaupankäynnissä, joissa äärimmäisen tarkka ajoitus on kriittistä.

Voinko muuntaa päivämääriä ennen vuotta 1970 Unix-aikaleimien avulla?

Kyllä, päivämäärät ennen tammikuun 1. päivää 1970 esitetään negatiivisilla aikaleimoilla. Kuitenkin jotkin järjestelmät eivät välttämättä käsittele negatiivisia aikaleimoja oikein, joten on tärkeää testata tätä toimintoa, jos sinun on työskenneltävä historiallisten päivämäärien kanssa.

Mikä on Vuosi 2038 -ongelma?

Vuosi 2038 -ongelma syntyy, koska monet järjestelmät tallentavat Unix-aikaleimat 32-bittisiin allekirjoitettuihin kokonaislukuihin, jotka voivat ylivuotaa tammikuun 19. päivänä 2038. Tämän jälkeen kokonaisluku ei voi enää edustaa aikoja oikein, mikä voi aiheuttaa järjestelmäongelmia. Nykyajan järjestelmät käyttävät yhä enemmän 64-bittisiä kokonaislukuja tämän ongelman välttämiseksi.

Kuinka käsittelen aikavyöhykkeen muunnoksia Unix-aikaleimojen kanssa?

Unix-aikaleimat ovat aina UTC:ssä (koordinoitu yleisaika). Paikalliseen aikaan muuntaminen vaatii oikean aikavyöhykkeen käytön, kun aikaleima on muunnettu päivämääräksi. Useimmat ohjelmointikielet tarjoavat sisäänrakennettuja toimintoja aikavyöhykkeen muunnosten käsittelemiseksi.

Mikä on ero Unix-ajan ja ISO 8601:n välillä?

Unix-aika on numeerinen esitys (sekuntien määrä epochista), kun taas ISO 8601 on merkkijonomuoto (esim. "2021-01-01T00:00:00Z"). Unix-aika on kompaktimpi ja helpompi käyttää laskennassa, kun taas ISO 8601 on ihmiselle luettavampi ja itsekuvaava.

Kuinka tarkkoja Unix-aikaleimat ovat?

Tavalliset Unix-aikaleimat tarjoavat sekunnin tason tarkkuuden. Tarkkuutta vaativille sovelluksille millisekunnin aikaleimat (13 numeroa) tarjoavat 1/1000 sekunnin tarkkuuden ja mikrosekunnin aikaleimat (16 numeroa) tarjoavat 1/1 000 000 sekunnin tarkkuuden.

Ovatko Unix-aikaleimat karkaussekuntien huomioivia?

Ei, Unix-aika määritellään sekuntien määränä epochista, mukaan lukien karkaussekunnat. Tämä tarkoittaa, että karkaussekunnin aikana Unix-aikaleima ei kasva. Tämä voi aiheuttaa ongelmia sovelluksissa, jotka vaativat tarkkaa astronomista aikaa.

Voinko käyttää Unix-aikaleimoja tulevien tapahtumien aikatauluttamiseen?

Kyllä, Unix-aikaleimat ovat laajalti käytössä aikatauluttamisessa. Kuitenkin erittäin kaukaisten tulevaisuuden päivämäärien osalta on otettava huomioon mahdolliset rajoitukset, kuten Vuosi 2038 -ongelma 32-bittisille järjestelmille ja aikavyöhykkeiden ja kesäajan siirtymien käsittely.

Viitteet

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

Yritä aikaleiman muunninta nyt, jotta voit helposti muuntaa Unix-aikaleimoja minkä tahansa tarkkuuden mukaan ihmisen luettaviksi päivämääriksi. Olitpa työstämässä tavallisia Unix-aikaleimoja, millisekunnin tarkkuutta tai mikrosekunnin tarkkuutta, työkalumme havaitsee automaattisesti muodon ja tarjoaa tarkkoja muunnoksia.