Unix laiko žymės į datą konverteris: 12/24 valandų formato palaikymas

Unix laiko žymės konverteris

Įvadas

Unix laiko žymė (dar žinoma kaip POSIX laikas arba Epoch laikas) yra sistema, skirta apibūdinti tam tikrą laiko momentą. Tai yra sekundžių skaičius, kuris praėjo nuo 1970 m. sausio 1 d. (vidurnaktis UTC/GMT), neįskaitant šuolio sekundžių. Unix laiko žymės plačiai naudojamos kompiuterių sistemose ir programavimo kalbose, nes jos suteikia kompaktišką, kalbos nepriklausomą tam tikro momento laiko atvaizdavimą.

Šis konverteris leidžia jums paversti Unix laiko žymę į žmogaus skaitomą datą ir laiką. Jis palaiko tiek 12 valandų (AM/PM), tiek 24 valandų laiką, kad atitiktų skirtingus regioninius ir asmeninius pageidavimus.

Kaip veikia Unix laiko žymės

Unix laiko žymės skaičiuojamos kaip sekundžių skaičius nuo Unix Epoch (1970 m. sausio 1 d., 00:00:00 UTC). Tai daro jas ypač naudingas skaičiuojant laiko skirtumus ir saugant datas kompaktišku formatu.

Matematinis konvertavimas iš Unix laiko žymės į kalendoriaus datą apima kelis etapus:

Pradėkite nuo Unix Epoch (1970 m. sausio 1 d., 00:00:00 UTC)
Pridėkite laiko žymės sekundžių skaičių
Atsižvelkite į šuolio metus, skirtingus mėnesių ilgius ir kitas kalendoriaus sudėtingas problemas
Jei reikia, taikykite laiko zonos koregavimus

Pavyzdžiui, Unix laiko žymė 1609459200 atitinka penktadienį, 2021 m. sausio 1 d., 00:00:00 UTC.

Konversijos formulė gali būti išreikšta taip:

$\text{Data} = \text{Unix Epoch} + \text{Laiko žymė (sekundėmis)}$

Dauguma programavimo kalbų ir operacinių sistemų teikia įmontuotas funkcijas, kad apdorotų šią konversiją, paslėpdamos sudėtingus kalendoriaus skaičiavimus.

Laiko formato parinktys

Šis konverteris siūlo dvi laiko formato parinktis:

24 valandų formatas (kartais vadinamas "kariniu laiku"): Valandos svyruoja nuo 0 iki 23, ir nėra AM/PM žymėjimo. Pavyzdžiui, 15:00 yra atvaizduojama kaip 15:00.
12 valandų formatas: Valandos svyruoja nuo 1 iki 12, su AM (ante meridiem) laikui nuo vidurnakčio iki vidurdienio, ir PM (post meridiem) laikui nuo vidurdienio iki vidurnakčio. Pavyzdžiui, 15:00 24 valandų formatu yra atvaizduojama kaip 3:00 PM.

Pasirinkimas tarp šių formatų daugiausia priklauso nuo regioninės konvencijos ir asmeninio pageidavimo:

24 valandų formatas dažniausiai naudojamas daugumoje Europos, Lotynų Amerikos ir Azijos šalių, taip pat mokslo, kariuomenės ir medicinos kontekstuose visame pasaulyje.
12 valandų formatas yra paplitęs JAV, Kanadoje, Australijoje ir kai kuriose kitose anglakalbėse šalyse kasdieniame naudojime.

Kraštutiniai atvejai ir apribojimai

Dirbant su Unix laiko žymėmis, svarbu būti informuotam apie kelis kraštutinius atvejus ir apribojimus:

Neigiamos laiko žymės: Jos atspindi datas prieš Unix Epoch (1970 m. sausio 1 d.). Nors matematiškai tai yra galiojantis, kai kurios sistemos gali neteisingai apdoroti neigiamas laiko žymes.
2038 m. problema: Unix laiko žymės dažnai saugomos kaip 32 bitų pasirašyti sveikieji skaičiai, kurie perpildys 2038 m. sausio 19 d. Po šio taško 32 bitų sistemos negalės teisingai atvaizduoti laikų, nebent bus pakeistos, kad naudotų didesnį sveikąjį tipą.
Labai didelės laiko žymės: Labai tolimos ateities datos gali būti nesugebamos atvaizduoti kai kuriose sistemose arba gali būti apdorojamos nesuderinamai.
Šuolio sekundės: Unix laikas neatsižvelgia į šuolio sekundes, kurios kartais pridedamos prie UTC, kad kompensuotų Žemės nereguliarų sukimąsi. Tai reiškia, kad Unix laikas nėra tiksliai sinchronizuotas su astronominiu laiku.
Laiko zonos apsvarstymai: Unix laiko žymės atspindi momentus UTC. Konvertavimas į vietinį laiką reikalauja papildomos laiko zonos informacijos.
Vasaros laiko: Konvertuojant laiko žymes į vietinį laiką, reikia atsižvelgti į Vasaros laiko perėjimo sudėtingumus.

Naudojimo atvejai

Unix laiko žymės naudojamos daugybėje programų kompiuterijoje ir duomenų valdyme:

Duomenų bazės įrašai: Laiko žymės dažnai naudojamos įrašams, kada jie buvo sukurti ar modifikuoti.
Žiniatinklio kūrimas: HTTP antraštės, slapukai ir talpinimo mechanizmai dažnai naudoja Unix laiko žymes.
Žurnalo failai: Sistemos žurnalai paprastai registruoja įvykius su Unix laiko žymėmis, kad būtų užtikrintas tikslus chronologinis tvarkymas.
Versijų kontrolės sistemos: Git ir kitos VCS naudoja laiko žymes, kad užregistruotų, kada buvo atlikti įsipareigojimai.
API atsakymai: Daugelis žiniatinklio API įtraukia laiko žymes savo atsakymuose, kad nurodytų, kada duomenys buvo sugeneruoti arba kada ištekliai buvo paskutinį kartą modifikuoti.
Failų sistemos: Failų sukūrimo ir modifikavimo laikai dažnai saugomi kaip Unix laiko žymės.
Sesijų valdymas: Žiniatinklio programos naudoja laiko žymes, kad nustatytų, kada vartotojo sesijos turi pasibaigti.
Duomenų analizė: Laiko žymės suteikia standartizuotą būdą dirbti su laiko duomenimis analizės programose.

Alternatyvos

Nors Unix laiko žymės yra plačiai naudojamos, yra alternatyvių laiko atvaizdavimo formatų, kurie tam tikrose kontekstuose gali būti tinkamesni:

ISO 8601: Standartizuotas eilutės formatas (pvz., "2021-01-01T00:00:00Z"), kuris yra žmogaus skaitomas, išlaikant rūšiavimo galimybes. Jis dažnai teikiamas pirmenybė duomenų mainams ir vartotojams.
RFC 3339: ISO 8601 profiliavimas, naudojamas interneto protokoluose, su griežtesniais formatavimo reikalavimais.
Žmogaus skaitomi formatai: Lokalizuotos datos eilutės (pvz., "2021 m. sausio 1 d.") labiau tinka tiesioginiam vartotojo sąveikai, tačiau mažiau tinkamos skaičiavimams.
Microsoft FILETIME: 64 bitų vertė, atspindinti 100 nanosekundžių intervalų skaičių nuo 1601 m. sausio 1 d., naudojama Windows sistemose.
Juliano dienos numeris: Naudojamas astronomijoje ir kai kuriose mokslinėse programose, skaičiuojant dienas nuo 4713 m. pr. m. e. sausio 1 d.

Laiko formato pasirinkimas priklauso nuo tokių veiksnių kaip:

Reikalingas tikslumas
Žmogaus skaitomumo poreikiai
Saugojimo apribojimai
Suderinamumas su esamomis sistemomis
Atstumas, kurį reikia atvaizduoti

Istorija

Unix laiko sąvoka kilo iš Unix operacinės sistemos kūrimo Bell Labs vėlyvuoju 1960-ųjų ir ankstyvuoju 1970-ųjų laikotarpiu. Sprendimas naudoti 1970 m. sausio 1 d. kaip epochą buvo šiek tiek savavališkas, tačiau praktinis tuo metu – jis buvo pakankamai neseniai, kad sumažintų saugojimo reikalavimus svarbioms datoms, tačiau pakankamai toli praeityje, kad būtų naudingas istoriniams duomenims.

Pradinė įgyvendinimas naudojo 32 bitų pasirašytą sveikąjį skaičių, kad saugotų sekundžių skaičių, kuris tuo metu buvo pakankamas numatomam Unix sistemų gyvavimo laikui. Tačiau šis sprendimas sukėlė 2038 m. problemą (kartais vadinamą "Y2K38" arba "Unix tūkstantmečio klaida"), nes 32 bitų pasirašyti sveikieji skaičiai gali atspindėti datas tik iki 2038 m. sausio 19 d. (03:14:07 UTC).

Kai Unix ir Unix tipo operacinės sistemos tapo populiarios, Unix laiko žymė tapo de facto standartu laiko atvaizdavimui kompiuterijoje. Ji buvo priimta daugelio programavimo kalbų, duomenų bazių ir programų, išplėsdama savo taikymą toli už pradinės Unix aplinkos.

Šiuolaikinės sistemos vis dažniau naudoja 64 bitų sveikuosius skaičius laiko žymėms, kas išplečia atvaizduojamą diapazoną iki maždaug 292 milijardų metų abiem kryptimis nuo epochos, efektyviai išsprendžiant 2038 m. problemą. Tačiau senosios sistemos ir programos gali vis dar būti pažeidžiamos.

Unix laiko žymės paprastumas ir naudingumas užtikrino jos tęstinį aktualumą nepaisant sudėtingesnių laiko atvaizdavimo formatų kūrimo. Ji išlieka pagrindine sąvoka kompiuterijoje, sudarančia mūsų skaitmeninės infrastruktūros pagrindą.

Kodo pavyzdžiai

Štai pavyzdžiai, kaip konvertuoti Unix laiko žymes į žmogaus skaitomas datas įvairiose programavimo kalbose:

1// JavaScript laiko žymės konvertavimas
2function convertUnixTimestamp(timestamp, use12Hour = false) {
3  // Sukurkite naują Date objektą (JavaScript naudoja milisekundes)
4  const date = new Date(timestamp * 1000);
5  
6  // Formatavimo parinktys
7  const options = {
8    year: 'numeric',
9    month: 'long',
10    day: 'numeric',
11    weekday: 'long',
12    hour: use12Hour ? 'numeric' : '2-digit',
13    minute: '2-digit',
14    second: '2-digit',
15    hour12: use12Hour
16  };
17  
18  // Paverskite į eilutę naudojant lokalizuotą formatavimą
19  return date.toLocaleString(undefined, options);
20}
21
22// Pavyzdžio naudojimas
23const timestamp = 1609459200; // 2021 m. sausio 1 d. 00:00:00 UTC
24console.log(convertUnixTimestamp(timestamp, false)); // 24 valandų formatas
25console.log(convertUnixTimestamp(timestamp, true));  // 12 valandų formatas
26

1# Python laiko žymės konvertavimas
2import datetime
3
4def convert_unix_timestamp(timestamp, use_12hour=False):
5    # Konvertuoti Unix laiko žymę į datetime objektą
6    date = datetime.datetime.fromtimestamp(timestamp)
7    
8    # Formatavimo datos eilutė
9    if use_12hour:
10        format_string = "%A, %B %d, %Y %I:%M:%S %p"  # 12 valandų formatas su AM/PM
11    else:
12        format_string = "%A, %B %d, %Y %H:%M:%S"     # 24 valandų formatas
13    
14    return date.strftime(format_string)
15
16# Pavyzdžio naudojimas
17timestamp = 1609459200  # 2021 m. sausio 1 d. 00:00:00 UTC
18print(convert_unix_timestamp(timestamp, False))  # 24 valandų formatas
19print(convert_unix_timestamp(timestamp, True))   # 12 valandų formatas
20

1<?php
2// PHP laiko žymės konvertavimas
3function convertUnixTimestamp($timestamp, $use12Hour = false) {
4    // Formatavimo eilutė
5    $formatString = $use12Hour 
6        ? 'l, F j, Y g:i:s A'  // 12 valandų formatas su AM/PM
7        : 'l, F j, Y H:i:s';   // 24 valandų formatas
8    
9    // Konvertuoti ir formatuoti datą
10    return date($formatString, $timestamp);
11}
12
13// Pavyzdžio naudojimas
14$timestamp = 1609459200; // 2021 m. sausio 1 d. 00:00:00 UTC
15echo convertUnixTimestamp($timestamp, false) . "\n"; // 24 valandų formatas
16echo convertUnixTimestamp($timestamp, true) . "\n";  // 12 valandų formatas
17?>
18

1// Java laiko žymės konvertavimas
2import java.time.Instant;
3import java.time.LocalDateTime;
4import java.time.ZoneId;
5import java.time.format.DateTimeFormatter;
6
7public class UnixTimestampConverter {
8    public static String convertUnixTimestamp(long timestamp, boolean use12Hour) {
9        // Konvertuoti Unix laiko žymę į Instant, tada į LocalDateTime
10        Instant instant = Instant.ofEpochSecond(timestamp);
11        LocalDateTime dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
12        
13        // Sukurti formatavimo objektą pagal pageidaujamą formatą
14        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(
15            use12Hour ? "EEEE, MMMM d, yyyy h:mm:ss a" : "EEEE, MMMM d, yyyy HH:mm:ss"
16        );
17        
18        // Formatuoti datą
19        return dateTime.format(formatter);
20    }
21    
22    public static void main(String[] args) {
23        long timestamp = 1609459200; // 2021 m. sausio 1 d. 00:00:00 UTC
24        System.out.println(convertUnixTimestamp(timestamp, false)); // 24 valandų formatas
25        System.out.println(convertUnixTimestamp(timestamp, true));  // 12 valandų formatas
26    }
27}
28

1// C# laiko žymės konvertavimas
2using System;
3
4class UnixTimestampConverter
5{
6    public static string ConvertUnixTimestamp(long timestamp, bool use12Hour)
7    {
8        // Konvertuoti Unix laiko žymę į DateTime
9        // Unix laiko žymės yra sekundės nuo 1970-01-01
10        DateTime dateTime = DateTimeOffset.FromUnixTimeSeconds(timestamp).DateTime;
11        
12        // Formatavimo eilutė pagal 12 valandų ar 24 valandų pageidavimą
13        string formatString = use12Hour 
14            ? "dddd, MMMM d, yyyy h:mm:ss tt"  // 12 valandų formatas su AM/PM
15            : "dddd, MMMM d, yyyy HH:mm:ss";   // 24 valandų formatas
16        
17        // Grąžinti suformatuotą datos eilutę
18        return dateTime.ToString(formatString);
19    }
20    
21    static void Main()
22    {
23        long timestamp = 1609459200; // 2021 m. sausio 1 d. 00:00:00 UTC
24        Console.WriteLine(ConvertUnixTimestamp(timestamp, false)); // 24 valandų formatas
25        Console.WriteLine(ConvertUnixTimestamp(timestamp, true));  // 12 valandų formatas
26    }
27}
28

1# Ruby laiko žymės konvertavimas
2require 'time'
3
4def convert_unix_timestamp(timestamp, use_12hour = false)
5  # Konvertuoti Unix laiko žymę į Time objektą
6  time = Time.at(timestamp)
7  
8  # Formatavimo pagal 12 valandų ar 24 valandų pageidavimą
9  if use_12hour
10    time.strftime("%A, %B %d, %Y %I:%M:%S %p")  # 12 valandų formatas su AM/PM
11  else
12    time.strftime("%A, %B %d, %Y %H:%M:%S")     # 24 valandų formatas
13  end
14end
15
16# Pavyzdžio naudojimas
17timestamp = 1609459200  # 2021 m. sausio 1 d. 00:00:00 UTC
18puts convert_unix_timestamp(timestamp, false)  # 24 valandų formatas
19puts convert_unix_timestamp(timestamp, true)   # 12 valandų formatas
20

1// Go laiko žymės konvertavimas
2package main
3
4import (
5    "fmt"
6    "time"
7)
8
9func convertUnixTimestamp(timestamp int64, use12Hour bool) string {
10    // Konvertuoti Unix laiko žymę į Time
11    t := time.Unix(timestamp, 0)
12    
13    // Formatavimo eilutė pagal 12 valandų ar 24 valandų pageidavimą
14    formatString := "Monday, January 2, 2006 "
15    if use12Hour {
16        formatString += "3:04:05 PM"  // 12 valandų formatas su AM/PM
17    } else {
18        formatString += "15:04:05"    // 24 valandų formatas
19    }
20    
21    // Grąžinti suformatuotą laiką
22    return t.Format(formatString)
23}
24
25func main() {
26    timestamp := int64(1609459200) // 2021 m. sausio 1 d. 00:00:00 UTC
27    fmt.Println(convertUnixTimestamp(timestamp, false)) // 24 valandų formatas
28    fmt.Println(convertUnixTimestamp(timestamp, true))  // 12 valandų formatas
29}
30

1// Swift laiko žymės konvertavimas
2import Foundation
3
4func convertUnixTimestamp(_ timestamp: Int, use12Hour: Bool) -> String {
5    // Sukurti Date iš Unix laiko žymės
6    let date = Date(timeIntervalSince1970: TimeInterval(timestamp))
7    
8    // Sukurti DateFormatter
9    let formatter = DateFormatter()
10    formatter.dateStyle = .full
11    
12    // Nustatyti laiko stilių pagal 12 valandų ar 24 valandų pageidavimą
13    if use12Hour {
14        formatter.timeStyle = .medium
15        formatter.amSymbol = "AM"
16        formatter.pmSymbol = "PM"
17    } else {
18        formatter.timeStyle = .medium
19        formatter.dateFormat = formatter.dateFormat?.replacingOccurrences(of: "h:mm:ss a", with: "HH:mm:ss")
20    }
21    
22    // Grąžinti suformatuotą datą
23    return formatter.string(from: date)
24}
25
26// Pavyzdžio naudojimas
27let timestamp = 1609459200 // 2021 m. sausio 1 d. 00:00:00 UTC
28print(convertUnixTimestamp(timestamp, use12Hour: false)) // 24 valandų formatas
29print(convertUnixTimestamp(timestamp, use12Hour: true))  // 12 valandų formatas
30

1# R laiko žymės konvertavimas
2convert_unix_timestamp <- function(timestamp, use_12hour = FALSE) {
3  # Konvertuoti Unix laiko žymę į POSIXct datą/ laiką
4  date_time <- as.POSIXct(timestamp, origin = "1970-01-01", tz = "UTC")
5  
6  # Formatavimo pagal 12 valandų ar 24 valandų pageidavimą
7  if (use_12hour) {
8    format_string <- "%A, %B %d, %Y %I:%M:%S %p"  # 12 valandų formatas su AM/PM
9  } else {
10    format_string <- "%A, %B %d, %Y %H:%M:%S"     # 24 valandų formatas
11  }
12  
13  # Grąžinti suformatuotą datos eilutę
14  format(date_time, format_string)
15}
16
17# Pavyzdžio naudojimas
18timestamp <- 1609459200  # 2021 m. sausio 1 d. 00:00:00 UTC
19cat(convert_unix_timestamp(timestamp, FALSE), "\n")  # 24 valandų formatas
20cat(convert_unix_timestamp(timestamp, TRUE), "\n")   # 12 valandų formatas
21

1% MATLAB laiko žymės konvertavimas
2function formattedDate = convertUnixTimestamp(timestamp, use12Hour)
3    % Konvertuoti Unix laiko žymę į MATLAB datetime
4    % MATLAB datos yra dienos nuo 1900-01-01, su 1 = 1900-01-01
5    % Unix laiko žymės yra sekundės nuo 1970-01-01
6    
7    % Pirmiausia konvertuoti į Excel datos formatą
8    % 25569 yra dienų skaičius tarp 1900-01-01 ir 1970-01-01
9    excelDate = (timestamp / 86400) + 25569;
10    
11    % Formatavimo pagal 12 valandų ar 24 valandų pageidavimą
12    if use12Hour
13        formattedDate = datestr(excelDate, 'dddd, mmmm dd, yyyy h:mm:ss AM/PM');
14    else
15        formattedDate = datestr(excelDate, 'dddd, mmmm dd, yyyy hh:mm:ss');
16    end
17end
18
19% Pavyzdžio naudojimas
20timestamp = 1609459200;  % 2021 m. sausio 1 d. 00:00:00 UTC
21disp(convertUnixTimestamp(timestamp, false))  % 24 valandų formatas
22disp(convertUnixTimestamp(timestamp, true))   % 12 valandų formatas
23

1' Excel VBA laiko žymės konvertavimas
2Function ConvertUnixTimestamp(timestamp As Long, Optional use12Hour As Boolean = False) As String
3    ' Konvertuoti Unix laiko žymę į Excel datą/ laiką
4    ' Excel datos yra dienos nuo 1900-01-01, su 1 = 1900-01-01
5    ' Unix laiko žymės yra sekundės nuo 1970-01-01
6    
7    ' Pirmiausia konvertuoti į Excel datos formatą
8    ' 25569 yra dienų skaičius tarp 1900-01-01 ir 1970-01-01
9    Dim excelDate As Double
10    excelDate = (timestamp / 86400) + 25569
11    
12    ' Formatavimo pagal 12 valandų ar 24 valandų pageidavimą
13    If use12Hour Then
14        ConvertUnixTimestamp = Format(excelDate, "dddd, mmmm d, yyyy h:mm:ss AM/PM")
15    Else
16        ConvertUnixTimestamp = Format(excelDate, "dddd, mmmm d, yyyy hh:mm:ss")
17    End If
18End Function
19
20' Naudojimas darbalapyje:
21' =ConvertUnixTimestamp(1609459200, TRUE)  ' 12 valandų formatas
22' =ConvertUnixTimestamp(1609459200, FALSE) ' 24 valandų formatas
23

Kraštutinių atvejų tvarkymas

Dirbant su Unix laiko žymėmis, svarbu teisingai tvarkyti kraštutinius atvejus. Štai pavyzdžiai, kaip tvarkyti kai kuriuos dažniausiai pasitaikančius kraštutinius atvejus:

1// JavaScript kraštutinių atvejų tvarkymas
2function safeConvertTimestamp(timestamp, use12Hour = false) {
3  // Patikrinkite, ar laiko žymė yra galiojanti
4  if (timestamp === undefined || timestamp === null || isNaN(timestamp)) {
5    return "Neteisinga laiko žymė";
6  }
7  
8  // Patikrinkite neigiamas laiko žymes (datas prieš 1970)
9  if (timestamp < 0) {
10    // Kai kurie naršyklės gali neteisingai tvarkyti neigiamas laiko žymes
11    // Naudokite patikimesnį požiūrį į datas prieš 1970
12    const date = new Date(timestamp * 1000);
13    if (isNaN(date.getTime())) {
14      return "Neteisinga data (prieš 1970)";
15    }
16  }
17  
18  // Patikrinkite Y2K38 problemą (32 bitų sistemoms)
19  const maxInt32 = 2147483647; // Maksimalus 32 bitų pasirašyto sveiko skaičiaus vertė
20  if (timestamp > maxInt32) {
21    // Apsvarstykite galimybę naudoti BigInt labai didelėms laiko žymėms modernioje JavaScript
22    console.warn("Laiko žymė viršija 32 bitų sveiko skaičiaus ribą (Y2K38 problema)");
23  }
24  
25  // Tęsti normalų konvertavimą
26  try {
27    const date = new Date(timestamp * 1000);
28    const options = {
29      year: 'numeric',
30      month: 'long',
31      day: 'numeric',
32      weekday: 'long',
33      hour: use12Hour ? 'numeric' : '2-digit',
34      minute: '2-digit',
35      second: '2-digit',
36      hour12: use12Hour
37    };
38    return date.toLocaleString(undefined, options);
39  } catch (error) {
40    return "Klaida konvertuojant laiko žymę: " + error.message;
41  }
42}
43

Nuorodos

"Unix laikas." Vikipedija, Vikipedijos fondas, https://en.wikipedia.org/wiki/Unix_time
"2038 m. problema." Vikipedija, Vikipedijos fondas, https://en.wikipedia.org/wiki/Year_2038_problem
Olson, Arthur David. "Kalendrinio laiko sudėtingumai." Atvira grupė, https://www.usenix.org/legacy/events/usenix01/full_papers/olson/olson.pdf
"ISO 8601." Vikipedija, Vikipedijos fondas, https://en.wikipedia.org/wiki/ISO_8601
"RFC 3339: Datos ir laikas internete: laiko žymės." Interneto inžinerijos darbo grupė (IETF), https://tools.ietf.org/html/rfc3339
Kernighan, Brian W., ir Dennis M. Ritchie. "C programavimo kalba." Prentice Hall, 1988.

Whiz Tools

Unix laiko žymės į datą konverteris: 12/24 valandų formato palaikymas

Unix laiko žymės konverteris

Konvertuota data ir laikas

Dokumentacija

Unix laiko žymės konverteris

Įvadas

Kaip veikia Unix laiko žymės

Laiko formato parinktys

Kraštutiniai atvejai ir apribojimai

Naudojimo atvejai

Alternatyvos

Istorija

Kodo pavyzdžiai

Kraštutinių atvejų tvarkymas

Nuorodos

Atsiliepimai

Susiję įrankiai

Laiko vienetų konverteris: Metai, Dienos, Valandos, Minutės, Sekundės

JSON formatavimo ir gražinimo priemonė: gražiai atspausdinkite JSON su įtraukimu

Skaičių Bazės Konverteris: Dvejetainė, Dešimtainė, Šešiakampė ir Pasirinktinių Bazės

Dvejetainis-dešimtainis konverteris: konvertuokite tarp skaičių sistemų

Paslaugų Veikimo Laiko Skaičiuoklė: Apskaičiuokite Uptime

Senovinis Biblijos matavimo konverteris: istorinė matavimo priemonė

Metų Dienos Skaičiuoklė: Skaičiuokite dienas ir likučius

Žetonų skaitiklis: skaičiuokite žetonus su tiktoken