Konwerter znaczników Unix

Wprowadzenie

Znacznik Unix (znany również jako czas POSIX lub czas Epoki) to system opisujący punkt w czasie. Jest to liczba sekund, które upłynęły od 1 stycznia 1970 roku (północ UTC/GMT), nie licząc sekund przestępnych. Znaczniki Unix są szeroko stosowane w systemach komputerowych i językach programowania, ponieważ zapewniają kompaktową, niezależną od języka reprezentację konkretnego momentu w czasie.

Ten konwerter znaczników na datę automatycznie wykrywa i przetwarza znaczniki o różnych długościach, w tym precyzji mikrosekund (16 cyfr), precyzji milisekund (13 cyfr) oraz standardowych znaczników Unix (10 cyfr). Narzędzie identyfikuje format znacznika na podstawie długości wejścia, konwertuje go na czytelny dla człowieka format daty i czasu oraz wyświetla wynik bez konieczności określania typu znacznika przez użytkowników. Obsługuje zarówno formaty czasu 12-godzinne (AM/PM), jak i 24-godzinne, aby dostosować się do różnych regionalnych i osobistych preferencji.

Jak działają znaczniki Unix

Znaczniki Unix są obliczane jako liczba sekund od Epoki Unix (1 stycznia 1970 roku, 00:00:00 UTC). Czyni to je szczególnie użytecznymi do obliczania różnic czasowych i przechowywania dat w kompaktowym formacie.

Matematyczna konwersja z znacznika Unix na datę kalendarzową obejmuje kilka kroków:

1. Rozpocznij od Epoki Unix (1 stycznia 1970 roku, 00:00:00 UTC)
2. Dodaj liczbę sekund w znaczniku
3. Uwzględnij lata przestępne, różne długości miesięcy i inne złożoności kalendarza
4. Zastosuj dostosowania strefy czasowej, jeśli to konieczne

Na przykład, znacznik Unix 1609459200 reprezentuje piątek, 1 stycznia 2021 roku, 00:00:00 UTC.

Formuła konwersji może być wyrażona jako:

$\text{Data} = \text{Epoka Unix} + \text{Znacznik (w sekundach)}$

Większość języków programowania i systemów operacyjnych zapewnia wbudowane funkcje do obsługi tej konwersji, ukrywając złożone obliczenia kalendarzowe.

Format znaczników i automatyczne wykrywanie

Nasz konwerter obsługuje trzy powszechne formaty znaczników, które są automatycznie wykrywane na podstawie liczby cyfr:

1. Standardowy znacznik Unix (10 cyfr): Reprezentuje sekundy od Epoki Unix. Przykład: 1609459200 (1 stycznia 2021 roku, 00:00:00 UTC)

2. Precyzja milisekund (13 cyfr): Reprezentuje milisekundy od Epoki Unix. Przykład: 1609459200000 (1 stycznia 2021 roku, 00:00:00 UTC)

3. Precyzja mikrosekund (16 cyfr): Reprezentuje mikrosekundy od Epoki Unix. Przykład: 1609459200000000 (1 stycznia 2021 roku, 00:00:00 UTC)

Automatyczne wykrywanie działa poprzez analizę długości wejścia:

• Jeśli wejście zawiera 10 cyfr, jest traktowane jako standardowy znacznik Unix (sekundy)
• Jeśli wejście zawiera 13 cyfr, jest traktowane jako znacznik milisekund
• Jeśli wejście zawiera 16 cyfr, jest traktowane jako znacznik mikrosekund

To automatyczne wykrywanie eliminuje potrzebę określania typu znacznika przez użytkowników, co czyni narzędzie bardziej przyjaznym dla użytkownika i efektywnym.

Opcje formatu czasu

Ten konwerter oferuje dwie opcje formatu czasu:

1. Format 24-godzinny (czasami nazywany "czasem wojskowym"): Godziny wahają się od 0 do 23, a nie ma oznaczenia AM/PM. Na przykład, 15:00 jest reprezentowane jako 15:00.

2. Format 12-godzinny: Godziny wahają się od 1 do 12, z AM (ante meridiem) dla czasów od północy do południa, oraz PM (post meridiem) dla czasów od południa do północy. Na przykład, 15:00 w formacie 24-godzinnym jest reprezentowane jako 3:00 PM.

Wybór między tymi formatami jest w dużej mierze kwestią konwencji regionalnej i osobistych preferencji:

• Format 24-godzinny jest powszechnie używany w większości Europy, Ameryki Łacińskiej i Azji, a także w kontekstach naukowych, wojskowych i medycznych na całym świecie.
• Format 12-godzinny jest powszechny w Stanach Zjednoczonych, Kanadzie, Australii i niektórych innych krajach anglojęzycznych w codziennym użyciu.

Przypadki brzegowe i ograniczenia

Pracując z znacznikami Unix o różnych precyzjach, ważne jest, aby być świadomym kilku przypadków brzegowych i ograniczeń:

1. Ujemne znaczniki: Reprezentują daty przed Epoką Unix (1 stycznia 1970 roku). Chociaż matematycznie są ważne, niektóre systemy mogą nie obsługiwać ujemnych znaczników poprawnie. Dotyczy to wszystkich trzech formatów znaczników.

2. Problem roku 2038: Standardowe znaczniki Unix (10 cyfr) są często przechowywane jako 32-bitowe liczby całkowite ze znakiem, które przepełnią się 19 stycznia 2038 roku. Po tym punkcie systemy 32-bitowe nie będą w stanie poprawnie reprezentować czasów, chyba że zostaną zmodyfikowane, aby używać większego typu całkowitego.

3. Rozważania dotyczące precyzji:

   • Standardowe znaczniki (10 cyfr) mają precyzję na poziomie sekundy, co jest wystarczające dla większości codziennych zastosowań.
   • Znaczniki milisekund (13 cyfr) zapewniają 1000 razy większą precyzję, co jest przydatne w aplikacjach wymagających dokładniejszego pomiaru czasu.
   • Znaczniki mikrosekund (16 cyfr) oferują jeszcze większą precyzję (1/1 000 000 sekundy), co jest konieczne w obliczeniach wysokowydajnych, aplikacjach naukowych i niektórych transakcjach finansowych.

4. Bardzo duże znaczniki: Bardzo odległe daty w przyszłości mogą być niemożliwe do reprezentacji w niektórych systemach lub mogą być obsługiwane niespójnie. Jest to szczególnie istotne dla znaczników milisekund i mikrosekund, które używają większych wartości numerycznych.

5. Sekundy przestępne: Czas Unix nie uwzględnia sekund przestępnych, które są czasami dodawane do UTC, aby skompensować nieregularny ruch Ziemi. Oznacza to, że czas Unix nie jest precyzyjnie zsynchronizowany z czasem astronomicznym.

6. Rozważania dotyczące stref czasowych: Znaczniki Unix reprezentują momenty w czasie w UTC. Konwersja na czas lokalny wymaga dodatkowych informacji o strefie czasowej.

7. Czas letni: Przy konwersji znaczników na czas lokalny należy uwzględnić złożoności związane z przejściami czasu letniego.

8. Mylenie formatów znaczników: Bez odpowiedniego wykrywania, znacznik milisekund o długości 13 cyfr może być błędnie interpretowany jako bardzo odległa data w przyszłości, jeśli będzie traktowany jako znacznik oparty na sekundach. Nasz konwerter zapobiega temu, automatycznie wykrywając format na podstawie długości cyfr.

Przykłady użycia

Znaczniki Unix o różnych precyzjach są używane w licznych aplikacjach w zakresie komputerów i zarządzania danymi:

1. Rekordy baz danych: Znaczniki są powszechnie używane do rejestrowania, kiedy wpisy zostały utworzone lub zmodyfikowane.

   • Standardowe znaczniki (10 cyfr) są często wystarczające dla ogólnych aplikacji baz danych.
   • Znaczniki milisekund (13 cyfr) są używane, gdy potrzebne jest dokładniejsze porządkowanie zdarzeń.

2. Rozwój aplikacji internetowych: Nagłówki HTTP, pliki cookie i mechanizmy pamięci podręcznej często używają znaczników Unix.

   • Funkcja Date.now() w JavaScript zwraca znaczniki milisekund (13 cyfr).

3. Pliki dziennika: Dzienniki systemowe zazwyczaj rejestrują zdarzenia z znacznikami Unix dla precyzyjnego porządkowania chronologicznego.

   • Systemy rejestrowania o wysokiej częstotliwości mogą używać precyzji milisekund lub mikrosekund.

4. Systemy kontroli wersji: Git i inne systemy VCS używają znaczników do rejestrowania, kiedy dokonano zatwierdzeń.

5. Odpowiedzi API: Wiele interfejsów API internetowych zawiera znaczniki w swoich odpowiedziach, aby wskazać, kiedy dane zostały wygenerowane lub kiedy zasoby zostały ostatnio zmodyfikowane.

   • Interfejsy API REST często używają znaczników o precyzji milisekund.

6. Systemy plików: Czas utworzenia i modyfikacji plików jest często przechowywany jako znaczniki Unix.

7. Zarządzanie sesjami: Aplikacje internetowe używają znaczników do określenia, kiedy sesje użytkowników powinny wygasać.

8. Analiza danych: Znaczniki zapewniają ustandaryzowany sposób pracy z danymi czasowymi w aplikacjach analitycznych.

9. Handel wysokiej częstotliwości: Systemy finansowe często wymagają precyzji mikrosekund (16 cyfr), aby dokładnie uporządkować transakcje.

10. Pomiar naukowy: Sprzęt badawczy może rejestrować obserwacje z precyzją mikrosekund dla dokładnej analizy czasowej.

Alternatywy

Chociaż znaczniki Unix są szeroko stosowane, istnieją alternatywne formaty reprezentacji czasu, które mogą być bardziej odpowiednie w niektórych kontekstach:

1. ISO 8601: Ustandaryzowany format ciągu (np. "2021-01-01T00:00:00Z"), który jest czytelny dla człowieka, zachowując jednocześnie możliwość sortowania. Często jest preferowany do wymiany danych i aplikacji skierowanych do użytkownika.

2. RFC 3339: Profil ISO 8601 używany w protokołach internetowych, z surowszymi wymaganiami dotyczącymi formatowania.

3. Formaty czytelne dla człowieka: Zlokalizowane ciągi dat (np. "1 stycznia 2021") są bardziej odpowiednie do bezpośredniej interakcji z użytkownikami, ale są mniej odpowiednie do obliczeń.

4. Microsoft FILETIME: 64-bitowa wartość reprezentująca liczbę interwałów 100-nanosekundowych od 1 stycznia 1601 roku, używana w systemach Windows.

5. Numer dnia juliańskiego: Używany w astronomii i niektórych zastosowaniach naukowych, zliczający dni od 1 stycznia 4713 roku p.n.e.

Wybór formatu czasu zależy od takich czynników jak:

• Wymagana precyzja
• Potrzeby dotyczące czytelności dla człowieka
• Ograniczenia przechowywania
• Kompatybilność z istniejącymi systemami
• Zakres dat, które muszą być reprezentowane

Historia

Koncepcja czasu Unix powstała wraz z rozwojem systemu operacyjnego Unix w Bell Labs pod koniec lat 60. i na początku lat 70. Decyzja o użyciu 1 stycznia 1970 roku jako epoki była w pewnym sensie arbitralna, ale praktyczna w tamtym czasie — była wystarczająco bliska, aby zminimalizować wymagania dotyczące przechowywania dat interesujących, ale wystarczająco daleko w przeszłość, aby być użytecznym dla danych historycznych.

Oryginalna implementacja używała 32-bitowej liczby całkowitej ze znakiem do przechowywania liczby sekund, co było wystarczające dla przewidywanej długości życia systemów Unix w tamtym czasie. Jednak ta decyzja doprowadziła do problemu roku 2038 (czasami nazywanego "Y2K38" lub "Błędem Milenijnym Unixu"), ponieważ 32-bitowe liczby całkowite ze znakiem mogą reprezentować daty tylko do 19 stycznia 2038 roku (03:14:07 UTC).

W miarę jak potrzeby obliczeniowe ewoluowały, stały się konieczne znaczniki o wyższej precyzji:

• Precyzja milisekund (13 cyfr) stała się powszechna wraz ze wzrostem interaktywnego przetwarzania i potrzebą pomiaru responsywności interfejsu użytkownika.

• Precyzja mikrosekund (16 cyfr) pojawiła się w aplikacjach obliczeniowych o wysokiej wydajności oraz w systemach wymagających niezwykle precyzyjnego pomiaru czasu.

W miarę jak systemy Unix i systemy podobne do Unix zyskały popularność, znacznik Unix stał się de facto standardem reprezentacji czasu w obliczeniach. Został przyjęty przez liczne języki programowania, bazy danych i aplikacje, rozszerzając się daleko poza swoje pierwotne środowisko Unix.

Nowoczesne systemy coraz częściej używają 64-bitowych liczb całkowitych do znaczników, co wydłuża zakres reprezentowalnych dat do około 292 miliardów lat w obie strony od epoki, skutecznie rozwiązując problem roku 2038. Jednak starsze systemy i aplikacje mogą nadal być podatne.

Prostota i użyteczność znacznika Unix zapewniły jego ciągłą aktualność, pomimo rozwoju bardziej zaawansowanych formatów reprezentacji czasu. Pozostaje on fundamentalną koncepcją w informatyce, stanowiąc podstawę naszej infrastruktury cyfrowej.

Przykłady kodu

Oto przykłady, jak konwertować znaczniki Unix o różnych precyzjach na daty czytelne dla człowieka w różnych językach programowania:

1// Konwersja znaczników w JavaScript z automatycznym wykrywaniem formatu
2function convertTimestamp(timestamp, use12Hour = false) {
3  // Konwertuj ciąg na liczbę, jeśli to konieczne
4  const numericTimestamp = Number(timestamp);
5  
6  // Wykrywanie formatu znacznika na podstawie długości cyfr
7  let date;
8  if (timestamp.length === 16) {
9    // Precyzja mikrosekund (podziel przez 1 000 000, aby uzyskać sekundy)
10    date = new Date(numericTimestamp / 1000);
11    console.log("Wykryto: znacznik precyzji mikrosekund");
12  } else if (timestamp.length === 13) {
13    // Precyzja milisekund
14    date = new Date(numericTimestamp);
15    console.log("Wykryto: znacznik precyzji milisekund");
16  } else if (timestamp.length === 10) {
17    // Standardowy znacznik Unix (sekundy)
18    date = new Date(numericTimestamp * 1000);
19    console.log("Wykryto: standardowy znacznik Unix (sekundy)");
20  } else {
21    throw new Error("Nieprawidłowy format znacznika. Oczekiwano 10, 13 lub 16 cyfr.");
22  }
23  
24  // Opcje formatu
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  // Konwertuj na ciąg przy użyciu formatowania lokalnego
37  return date.toLocaleString(undefined, options);
38}
39
40// Przykład użycia
41try {
42  // Standardowy znacznik Unix (10 cyfr)
43  console.log(convertTimestamp("1609459200", false)); 
44  
45  // Precyzja milisekund (13 cyfr)
46  console.log(convertTimestamp("1609459200000", false)); 
47  
48  // Precyzja mikrosekund (16 cyfr)
49  console.log(convertTimestamp("1609459200000000", true)); 
50} catch (error) {
51  console.error(error.message);
52}
53

1# Konwersja znaczników w Pythonie z automatycznym wykrywaniem formatu
2import datetime
3
4def convert_timestamp(timestamp, use_12hour=False):
5    # Konwertuj na liczbę całkowitą
6    timestamp = str(timestamp).strip()
7    numeric_timestamp = int(timestamp)
8    
9    # Wykrywanie formatu znacznika na podstawie długości cyfr
10    if len(timestamp) == 16:
11        # Precyzja mikrosekund (podziel przez 1 000 000, aby uzyskać sekundy)
12        date = datetime.datetime.fromtimestamp(numeric_timestamp / 1000000)
13        print("Wykryto: znacznik precyzji mikrosekund")
14    elif len(timestamp) == 13:
15        # Precyzja milisekund (podziel przez 1 000, aby uzyskać sekundy)
16        date = datetime.datetime.fromtimestamp(numeric_timestamp / 1000)
17        print("Wykryto: znacznik precyzji milisekund")
18    elif len(timestamp) == 10:
19        # Standardowy znacznik Unix (sekundy)
20        date = datetime.datetime.fromtimestamp(numeric_timestamp)
21        print("Wykryto: standardowy znacznik Unix (sekundy)")
22    else:
23        raise ValueError("Nieprawidłowy format znacznika. Oczekiwano 10, 13 lub 16 cyfr.")
24    
25    # Format ciągu
26    if use_12hour:
27        format_string = "%A, %B %d, %Y %I:%M:%S %p"  # Format 12-godzinny z AM/PM
28    else:
29        format_string = "%A, %B %d, %Y %H:%M:%S"     # Format 24-godzinny
30    
31    return date.strftime(format_string)
32
33# Przykład użycia
34try:
35    # Standardowy znacznik Unix (10 cyfr)
36    print(convert_timestamp("1609459200", False))
37    
38    # Precyzja milisekund (13 cyfr)
39    print(convert_timestamp("1609459200000", False))
40    
41    # Precyzja mikrosekund (16 cyfr)
42    print(convert_timestamp("1609459200000000", True))
43except ValueError as e:
44    print(e)
45

1<?php
2// Konwersja znaczników w PHP z automatycznym wykrywaniem formatu
3function convertTimestamp($timestamp, $use12Hour = false) {
4    // Upewnij się, że znacznik jest ciągiem do sprawdzenia długości
5    $timestamp = trim((string)$timestamp);
6    $numericTimestamp = (float)$timestamp;
7    
8    // Wykrywanie formatu znacznika na podstawie długości cyfr
9    if (strlen($timestamp) === 16) {
10        // Precyzja mikrosekund (podziel przez 1 000 000, aby uzyskać sekundy)
11        $seconds = $numericTimestamp / 1000000;
12        echo "Wykryto: znacznik precyzji mikrosekund\n";
13    } elseif (strlen($timestamp) === 13) {
14        // Precyzja milisekund (podziel przez 1 000, aby uzyskać sekundy)
15        $seconds = $numericTimestamp / 1000;
16        echo "Wykryto: znacznik precyzji milisekund\n";
17    } elseif (strlen($timestamp) === 10) {
18        // Standardowy znacznik Unix (sekundy)
19        $seconds = $numericTimestamp;
20        echo "Wykryto: standardowy znacznik Unix (sekundy)\n";
21    } else {
22        throw new Exception("Nieprawidłowy format znacznika. Oczekiwano 10, 13 lub 16 cyfr.");
23    }
24    
25    // Format ciągu
26    $formatString = $use12Hour 
27        ? 'l, F j, Y g:i:s A'  // Format 12-godzinny z AM/PM
28        : 'l, F j, Y H:i:s';   // Format 24-godzinny
29    
30    // Konwertuj i sformatuj datę
31    return date($formatString, $seconds);
32}
33
34// Przykład użycia
35try {
36    // Standardowy znacznik Unix (10 cyfr)
37    echo convertTimestamp("1609459200", false) . "\n";
38    
39    // Precyzja milisekund (13 cyfr)
40    echo convertTimestamp("1609459200000", false) . "\n";
41    
42    // Precyzja mikrosekund (16 cyfr)
43    echo convertTimestamp("1609459200000000", true) . "\n";
44} catch (Exception $e) {
45    echo $e->getMessage() . "\n";
46}
47?>
48

1// Konwersja znaczników w Javie z automatycznym wykrywaniem formatu
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 wejścia
10        timestamp = timestamp.trim();
11        
12        // Wykrywanie formatu znacznika na podstawie długości cyfr
13        LocalDateTime dateTime;
14        if (timestamp.length() == 16) {
15            // Precyzja mikrosekund (podziel przez 1 000 000, aby uzyskać sekundy)
16            long microseconds = Long.parseLong(timestamp);
17            Instant instant = Instant.ofEpochSecond(0, microseconds * 1000); // Konwertuj na nanosekundy
18            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
19            System.out.println("Wykryto: znacznik precyzji mikrosekund");
20        } else if (timestamp.length() == 13) {
21            // Precyzja milisekund
22            long milliseconds = Long.parseLong(timestamp);
23            Instant instant = Instant.ofEpochMilli(milliseconds);
24            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
25            System.out.println("Wykryto: znacznik precyzji milisekund");
26        } else if (timestamp.length() == 10) {
27            // Standardowy znacznik Unix (sekundy)
28            long seconds = Long.parseLong(timestamp);
29            Instant instant = Instant.ofEpochSecond(seconds);
30            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
31            System.out.println("Wykryto: standardowy znacznik Unix (sekundy)");
32        } else {
33            throw new IllegalArgumentException("Nieprawidłowy format znacznika. Oczekiwano 10, 13 lub 16 cyfr.");
34        }
35        
36        // Utwórz formatowanie na podstawie preferowanego 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        // Sformatuj datę
42        return dateTime.format(formatter);
43    }
44    
45    public static void main(String[] args) {
46        try {
47            // Standardowy znacznik Unix (10 cyfr)
48            System.out.println(convertTimestamp("1609459200", false));
49            
50            // Precyzja milisekund (13 cyfr)
51            System.out.println(convertTimestamp("1609459200000", false));
52            
53            // Precyzja mikrosekund (16 cyfr)
54            System.out.println(convertTimestamp("1609459200000000", true));
55        } catch (IllegalArgumentException e) {
56            System.err.println(e.getMessage());
57        }
58    }
59}
60

1// Konwersja znaczników w C# z automatycznym wykrywaniem formatu
2using System;
3
4class TimestampConverter
5{
6    public static string ConvertTimestamp(string timestamp, bool use12Hour)
7    {
8        // Trim wejścia
9        timestamp = timestamp.Trim();
10        
11        // Wykrywanie formatu znacznika na podstawie długości cyfr
12        DateTime dateTime;
13        if (timestamp.Length == 16)
14        {
15            // Precyzja mikrosekund (podziel przez 1 000 000, aby uzyskać sekundy)
16            if (!double.TryParse(timestamp, out double microseconds))
17                throw new ArgumentException("Nieprawidłowy format znacznika");
18                
19            // Konwertuj mikrosekundy na DateTime
20            dateTime = DateTimeOffset.FromUnixTimeSeconds(0).DateTime.AddSeconds(microseconds / 1000000);
21            Console.WriteLine("Wykryto: znacznik precyzji mikrosekund");
22        }
23        else if (timestamp.Length == 13)
24        {
25            // Precyzja milisekund
26            if (!long.TryParse(timestamp, out long milliseconds))
27                throw new ArgumentException("Nieprawidłowy format znacznika");
28                
29            dateTime = DateTimeOffset.FromUnixTimeMilliseconds(milliseconds).DateTime;
30            Console.WriteLine("Wykryto: znacznik precyzji milisekund");
31        }
32        else if (timestamp.Length == 10)
33        {
34            // Standardowy znacznik Unix (sekundy)
35            if (!long.TryParse(timestamp, out long seconds))
36                throw new ArgumentException("Nieprawidłowy format znacznika");
37                
38            dateTime = DateTimeOffset.FromUnixTimeSeconds(seconds).DateTime;
39            Console.WriteLine("Wykryto: standardowy znacznik Unix (sekundy)");
40        }
41        else
42        {
43            throw new ArgumentException("Nieprawidłowy format znacznika. Oczekiwano 10, 13 lub 16 cyfr.");
44        }
45        
46        // Format ciągu na podstawie preferencji 12-godzinnych lub 24-godzinnych
47        string formatString = use12Hour 
48            ? "dddd, MMMM d, yyyy h:mm:ss tt"  // Format 12-godzinny z AM/PM
49            : "dddd, MMMM d, yyyy HH:mm:ss";   // Format 24-godzinny
50        
51        // Zwróć sformatowany ciąg daty
52        return dateTime.ToString(formatString);
53    }
54    
55    static void Main()
56    {
57        try
58        {
59            // Standardowy znacznik Unix (10 cyfr)
60            Console.WriteLine(ConvertTimestamp("1609459200", false));
61            
62            // Precyzja milisekund (13 cyfr)
63            Console.WriteLine(ConvertTimestamp("1609459200000", false));
64            
65            // Precyzja mikrosekund (16 cyfr)
66            Console.WriteLine(ConvertTimestamp("1609459200000000", true));
67        }
68        catch (ArgumentException e)
69        {
70            Console.WriteLine(e.Message);
71        }
72    }
73}
74

Obsługa przypadków brzegowych

Pracując z znacznikami Unix o różnych precyzjach, ważne jest, aby poprawnie obsługiwać przypadki brzegowe. Oto przykład, który demonstruje kompleksową obsługę przypadków brzegowych:

1// JavaScript kompleksowa obsługa przypadków brzegowych dla wielu formatów znaczników
2function safeConvertTimestamp(timestamp, use12Hour = false) {
3  // Walidacja wejścia
4  if (timestamp === undefined || timestamp === null || timestamp === '') {
5    return "Błąd: Pusty lub niezdefiniowany znacznik";
6  }
7  
8  // Upewnij się, że znacznik jest ciągiem do sprawdzenia długości
9  const timestampStr = String(timestamp).trim();
10  
11  // Sprawdź, czy znacznik zawiera tylko cyfry
12  if (!/^\d+$/.test(timestampStr)) {
13    return "Błąd: Znacznik musi zawierać tylko cyfry";
14  }
15  
16  // Wykrywanie formatu na podstawie długości
17  let date;
18  try {
19    if (timestampStr.length === 16) {
20      // Precyzja mikrosekund
21      const microseconds = Number(timestampStr);
22      date = new Date(microseconds / 1000); // Konwertuj na milisekundy
23      console.log("Przetwarzanie znacznika mikrosekund (16 cyfr)");
24      
25      // Sprawdź, czy data jest nieprawidłowa
26      if (isNaN(date.getTime())) {
27        return "Błąd: Nieprawidłowy znacznik mikrosekund";
28      }
29    } else if (timestampStr.length === 13) {
30      // Precyzja milisekund
31      const milliseconds = Number(timestampStr);
32      date = new Date(milliseconds);
33      console.log("Przetwarzanie znacznika milisekund (13 cyfr)");
34      
35      // Sprawdź, czy data jest nieprawidłowa
36      if (isNaN(date.getTime())) {
37        return "Błąd: Nieprawidłowy znacznik milisekund";
38      }
39    } else if (timestampStr.length === 10) {
40      // Standardowy znacznik Unix (sekundy)
41      const seconds = Number(timestampStr);
42      date = new Date(seconds * 1000);
43      console.log("Przetwarzanie standardowego znacznika (10 cyfr)");
44      
45      // Sprawdź, czy data jest nieprawidłowa
46      if (isNaN(date.getTime())) {
47        return "Błąd: Nieprawidłowy standardowy znacznik";
48      }
49      
50      // Sprawdź problem Y2K38 (dla systemów 32-bitowych)
51      const maxInt32 = 2147483647; // Maksymalna wartość dla 32-bitowej liczby całkowitej ze znakiem
52      if (seconds > maxInt32) {
53        console.warn("Ostrzeżenie: Znacznik przekracza limit 32-bitowej liczby całkowitej (problem Y2K38)");
54      }
55    } else {
56      return "Błąd: Nieprawidłowa długość znacznika. Oczekiwano 10, 13 lub 16 cyfr.";
57    }
58    
59    // Formatowanie daty
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 "Błąd konwersji znacznika: " + error.message;
74  }
75}
76
77// Testuj różne przypadki brzegowe
78console.log(safeConvertTimestamp("1609459200"));      // Standardowy (10 cyfr)
79console.log(safeConvertTimestamp("1609459200000"));   // Milisekundy (13 cyfr)
80console.log(safeConvertTimestamp("1609459200000000")); // Mikrosekundy (16 cyfr)
81console.log(safeConvertTimestamp("abc123"));          // Niecyfrowy
82console.log(safeConvertTimestamp("12345"));           // Nieprawidłowa długość
83console.log(safeConvertTimestamp("9999999999999999")); // Bardzo duży znacznik mikrosekund
84console.log(safeConvertTimestamp(""));                // Pusty ciąg
85

Najczęściej zadawane pytania

Czym jest znacznik Unix?

Znacznik Unix to liczba sekund, które upłynęły od 1 stycznia 1970 roku (północ UTC/GMT), nie licząc sekund przestępnych. Zapewnia kompaktowy, niezależny od języka sposób reprezentacji konkretnego momentu w czasie.

Jak działa automatyczne wykrywanie formatu znacznika?

Konwerter automatycznie wykrywa format znacznika na podstawie liczby cyfr:

• 10 cyfr: Standardowy znacznik Unix (sekundy od epoki)
• 13 cyfr: Znacznik precyzji milisekund
• 16 cyfr: Znacznik precyzji mikrosekund

Dlaczego potrzebuję precyzji milisekund lub mikrosekund?

Precyzja milisekund (13 cyfr) jest przydatna w aplikacjach wymagających dokładniejszego pomiaru czasu, takich jak monitorowanie wydajności, śledzenie interakcji użytkownika i niektóre aplikacje finansowe. Precyzja mikrosekund (16 cyfr) jest konieczna w obliczeniach wysokowydajnych, aplikacjach naukowych i systemach handlu wysokiej częstotliwości, gdzie niezwykle precyzyjny pomiar czasu jest krytyczny.

Czy mogę konwertować daty przed 1970 rokiem za pomocą znaczników Unix?

Tak, daty przed 1 stycznia 1970 roku są reprezentowane za pomocą ujemnych znaczników. Jednak niektóre systemy mogą nie obsługiwać ujemnych znaczników poprawnie, dlatego ważne jest przetestowanie tej funkcjonalności, jeśli musisz pracować z danymi historycznymi.

Czym jest problem roku 2038?

Problem roku 2038 występuje, ponieważ wiele systemów przechowuje znaczniki Unix jako 32-bitowe liczby całkowite ze znakiem, które mogą reprezentować daty tylko do 19 stycznia 2038 roku (03:14:07 UTC). Po tym punkcie liczba całkowita przepełni się, co może spowodować awarie systemu. Nowoczesne systemy coraz częściej używają 64-bitowych liczb całkowitych, aby uniknąć tego problemu.

Jak obsługiwać konwersje stref czasowych z znacznikami Unix?

Znaczniki Unix są zawsze w UTC (Czas Uniwersalny Koordynowany). Aby przekonwertować na konkretną strefę czasową, musisz zastosować odpowiedni offset po konwersji znacznika na datę. Większość języków programowania zapewnia wbudowane funkcje do obsługi konwersji stref czasowych.

Jaka jest różnica między czasem Unix a ISO 8601?

Czas Unix to reprezentacja numeryczna (sekundy od epoki), podczas gdy ISO 8601 to format ciągu (np. "2021-01-01T00:00:00Z"). Czas Unix jest bardziej kompaktowy i łatwiejszy do użycia w obliczeniach, podczas gdy ISO 8601 jest bardziej czytelny dla człowieka i samodokumentujący.

Jak dokładne są znaczniki Unix?

Standardowe znaczniki Unix mają precyzję na poziomie sekundy. W aplikacjach wymagających większej dokładności znaczniki milisekund (13 cyfr) zapewniają precyzję 1/1000 sekundy, a znaczniki mikrosekund (16 cyfr) oferują precyzję 1/1 000 000 sekundy.

Czy znaczniki Unix uwzględniają sekundy przestępne?

Nie, czas Unix jest definiowany jako liczba sekund od epoki, z wyłączeniem sekund przestępnych. Oznacza to, że podczas sekundy przestępnej znacznik Unix nie zwiększa się. Może to powodować problemy w aplikacjach wymagających precyzyjnego czasu astronomicznego.

Czy mogę używać znaczników Unix do planowania przyszłych wydarzeń?

Tak, znaczniki Unix są szeroko stosowane do planowania. Jednak w przypadku bardzo odległych dat w przyszłości należy być świadomym potencjalnych ograniczeń, takich jak problem roku 2038 dla systemów 32-bitowych oraz obsługa zmian stref czasowych i przejść czasu letniego.

Źródła

1. "Czas Unix." Wikipedia, Fundacja Wikimedia, https://en.wikipedia.org/wiki/Unix_time

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

3. Olson, Arthur David. "Złożoności czasów kalendarzowych." The Open Group, https://www.usenix.org/legacy/events/usenix01/full_papers/olson/olson.pdf

4. "ISO 8601." Wikipedia, Fundacja Wikimedia, https://en.wikipedia.org/wiki/ISO_8601

5. "RFC 3339: Data i czas w Internecie: Znaczniki." Internet Engineering Task Force (IETF), https://tools.ietf.org/html/rfc3339

6. Kernighan, Brian W., i Dennis M. Ritchie. "Język programowania C." Prentice Hall, 1988.

7. "Precyzyjne pomiary czasu w obliczeniach wysokowydajnych." ACM Computing Surveys, https://dl.acm.org/doi/10.1145/3232678

8. "Reprezentacja czasu w systemach finansowych." Journal of Financial Technology, https://www.fintech-journal.com/time-representation

Wypróbuj nasz konwerter znaczników już teraz, aby łatwo konwertować znaczniki Unix o dowolnej precyzji na daty czytelne dla człowieka. Niezależnie od tego, czy pracujesz ze standardowymi znacznikami Unix, znacznikami o precyzji milisekund czy mikrosekund, nasze narzędzie automatycznie wykrywa format i zapewnia dokładne konwersje.