Unix ajastamise muundur: 12/24-tunnise formaadi tugi
Muuda Unix ajastikke inimloetavateks kuupäevadeks ja kellaaegadeks. Valige selle lihtsa ja kasutajasõbraliku muunduriga 12-tunnine või 24-tunnine ajavormaat.
Unix Timestampi Konverter
Muudetud Kuupäev ja Aeg
Dokumentatsioon
Unix Timestamp Converter
Sissejuhatus
Unix timestamp (tuntud ka kui POSIX aeg või Epoch aeg) on süsteem ajapunkti kirjeldamiseks. See on sekundite arv, mis on möödunud 1. jaanuarist 1970 (kes öö UTC/GMT), arvestamata lisasekundeid. Unix timestamp'e kasutatakse laialdaselt arvutisüsteemides ja programmeerimiskeeltes, kuna need pakuvad kompaktset, keele sõltumatut esitamist kindlast ajamomendist.
See konverter võimaldab teil muuta Unix timestamp'i inimloetavasse kuupäeva ja kellaaja formaati. See toetab nii 12-tunnist (AM/PM) kui ka 24-tunnist ajavormingut, et arvestada erinevaid piirkondlikke ja isiklikke eelistusi.
Kuidas Unix Timestamp'id Töötavad
Unix timestamp'id arvutatakse kui sekundite arv alates Unix Epoch'ist (1. jaanuar 1970, 00:00:00 UTC). See teeb neist eriti kasulikud ajavahemike arvutamiseks ja kuupäevade kompaktseks salvestamiseks.
Matemaatiline konversioon Unix timestamp'ist kalendriaega hõlmab mitmeid samme:
- Alustage Unix Epoch'ist (1. jaanuar 1970, 00:00:00 UTC)
- Lisage timestamp'is olevate sekundite arv
- Arvestage liigaastaid, erinevaid kuupäeva pikkusi ja muid kalendri keerukusi
- Rakendage vajadusel ajavööndi kohandusi
Näiteks Unix timestamp 1609459200 tähistab reede, 1. jaanuar 2021, 00:00:00 UTC.
Konversioonivalemit saab väljendada järgmiselt:
Enamik programmeerimiskeeli ja operatsioonisüsteeme pakuvad sisseehitatud funktsioone selle konversiooni käsitlemiseks, varjates keerulisi kalendriarvutusi.
Aja Vormindamise Valikud
See konverter pakub kahte ajavormingu valikut:
-
24-tunnine formaat (mõnikord nimetatakse "sõjaväe ajaks"): Tunnid ulatuvad vahemikku 0 kuni 23, ning AM/PM tähistust ei ole. Näiteks 15:00 tähistab 3:00 PM.
-
12-tunnine formaat: Tunnid ulatuvad vahemikku 1 kuni 12, AM (ante meridiem) ajad on keskööst kuni keskpäevani, ja PM (post meridiem) ajad on keskpäevast kesööni. Näiteks 15:00 24-tunnises formaadis on esitatud kui 3:00 PM.
Valik nende vormingute vahel on suuresti piirkondlike tavade ja isiklike eelistuste küsimus:
- 24-tunnist formaati kasutatakse laialdaselt enamikus Euroopas, Ladina-Ameerikas ja Aasias, samuti teaduslikes, sõjaväelistes ja meditsiinilistes kontekstides üle kogu maailma.
- 12-tunnine formaat on levinud Ameerika Ühendriikides, Kanadas, Austraalias ja mõnedes teistes ingliskeelsetes riikides igapäevases kasutuses.
Äärmuslikud Juhud ja Piirangud
Unix timestamp'idega töötamisel on oluline olla teadlik mitmetest äärmuslikest juhtudest ja piirangutest:
-
Negatiivsed timestamp'id: Need tähistavad kuupäevi enne Unix Epoch'i (1. jaanuar 1970). Kuigi matemaatiliselt kehtivad, ei pruugi mõned süsteemid negatiivseid timestamp'e õigesti käsitleda.
-
Aasta 2038 probleem: Unix timestamp'e salvestatakse sageli kui 32-bitised allkirjastatud täisarvud, mis ületavad 19. jaanuaril 2038. Ajal, mil 32-bitised süsteemid ei suuda aegu õigesti esindada, kui neid ei muudetud suurema täisarvu tüübi kasutamiseks.
-
Äärmiselt suured timestamp'id: Väga kauged tuleviku kuupäevad ei pruugi mõnedes süsteemides olla esitatavad või võivad neid käsitleda ebaühtlaselt.
-
Lisasekundid: Unix aeg ei arvestata lisasekundeid, mis lisatakse UTC-sse, et kompenseerida Maa ebaühtlast pöörlemist. See tähendab, et Unix aeg ei ole täpselt sünkroonitud astronoomilise ajaga.
-
Ajavööndi kaalutlused: Unix timestamp'id esindavad hetki UTC-s. Kohalikku aega konverteerimiseks on vajalik täiendav ajavööndi teave.
-
Suveaja: Timestamp'ide konverteerimisel kohalikku aega tuleb arvesse võtta suveaja üleminekute keerukusi.
Kasutusalad
Unix timestamp'e kasutatakse paljudes rakendustes arvutamise ja andmehalduse valdkonnas:
-
Andmebaasi Kirjed: Timestamp'e kasutatakse sageli selleks, et registreerida, millal kirjed loodi või muudeti.
-
Veebiarendus: HTTP päised, küpsised ja vahemälu mehhanismid kasutavad sageli Unix timestamp'e.
-
Logifailid: Süsteemi logid registreerivad tavaliselt sündmusi Unix timestamp'idega, et tagada täpne kronoloogiline järjestus.
-
Versioonihaldussüsteemid: Git ja teised VCS kasutavad timestamp'e, et registreerida, millal commit'id tehti.
-
API Vastused: Paljud veeb API-d sisaldavad oma vastustes timestamp'e, et näidata, millal andmed genereeriti või millal ressursse viimati muudeti.
-
Failisüsteemid: Failide loomise ja muutmise ajad salvestatakse sageli Unix timestamp'idena.
-
Seansi Halduse: Veebirakendused kasutavad timestamp'e, et määrata, millal kasutaja seansid peaksid aeguma.
-
Andmeanalüüs: Timestamp'id pakuvad standardiseeritud viisi ajalisest andmestikust töötamiseks analüütika rakendustes.
Alternatiivid
Kuigi Unix timestamp'id on laialdaselt kasutusel, on olemas alternatiivsed aj esitamisse vormingud, mis võivad teatud kontekstides olla sobivamad:
-
ISO 8601: Standardiseeritud stringiformaat (nt "2021-01-01T00:00:00Z"), mis on inimloetav, säilitades samas sorteeritavuse. Seda eelistatakse sageli andmevahetuses ja kasutajaliidese rakendustes.
-
RFC 3339: ISO 8601 profiil, mida kasutatakse interneti protokollides, rangemate vormindamisnõuetega.
-
Inimloetavad vormingud: Lokaliseeritud kuupäeva stringid (nt "1. jaanuar 2021") on otsese kasutajaga suhtlemiseks sobivamad, kuid vähem sobivad arvutamiseks.
-
Microsoft FILETIME: 64-bitine väärtus, mis esindab 100-nanosekundiliste intervallide arvu alates 1. jaanuarist 1601, mida kasutatakse Windows süsteemides.
-
Juliani Päevanumber: Kasutatakse astronoomias ja mõnedes teaduslikes rakendustes, loendades päevi alates 1. jaanuarist 4713 eKr.
Ajavormingu valik sõltub sellistest teguritest nagu:
- Vajalik täpsus
- Inimloetavuse vajadused
- Salvestuspiirangud
- Ühilduvus olemasolevate süsteemidega
- Kuupäevade vahemik, mida tuleb esindada
Ajalugu
Unix aja kontseptsioon sai alguse Unix operatsioonisüsteemi arendamisest Bell Labs'is 1960ndate ja 1970ndate alguses. Otsus kasutada 1. jaanuari 1970 kui epoch oli mõnevõrra meelevaldne, kuid praktiline tol ajal - see oli piisavalt hiline, et minimeerida huvipakkuvate kuupäevade salvestusnõudeid, kuid piisavalt kaugel minevikus, et olla kasulik ajalooliste andmete jaoks.
Algne rakendus kasutas 32-bitist allkirjastatud täisarvu, et salvestada sekundite arvu, mis oli piisav Unix süsteemide oodatava eluea jaoks tol ajal. Kuid see otsus viis Aasta 2038 probleemini (mõnikord nimetatakse "Y2K38" või "Unixi aastatuhande viga"), kuna 32-bitised allkirjastatud täisarvud suudavad esindada kuupäevi kuni 19. jaanuarini 2038 (03:14:07 UTC).
Kuna Unix ja Unix-sarnased operatsioonisüsteemid said populaarsust, muutus Unix timestamp de facto standardiks aja esitlemiseks arvutites. Seda võtsid kasutusele paljud programmeerimiskeeled, andmebaasid ja rakendused, ulatudes kaugemale oma algsest Unix keskkonnast.
Kaasaegsed süsteemid kasutavad üha enam 64-bitiseid täisarve timestamp'ide jaoks, mis pikendab esitatava vahemiku umbes 292 miljardi aasta võrra mõlemas suunas epoch'ist, lahendades tõhusalt Aasta 2038 probleemi. Kuid pärand süsteemid ja rakendused võivad endiselt olla haavatavad.
Unix timestamp'i lihtsus ja kasulikkus on taganud selle jätkuva tähtsuse vaatamata keerukamate ajas esitlemise vormingute arengule. See jääb arvutamise aluseks, toetades suurt osa meie digitaalsest infrastruktuurist.
Koodi Näited
Siin on näited, kuidas konverteerida Unix timestamp'e inimloetavatesse kuupäevadesse erinevates programmeerimiskeeltes:
1// JavaScript timestamp'i konversioon
2function convertUnixTimestamp(timestamp, use12Hour = false) {
3 // Looge uus Date objekt (JavaScript kasutab millisekundeid)
4 const date = new Date(timestamp * 1000);
5
6 // Vormindamisvalikud
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 // Muutke stringiks, kasutades lokaalset vormindamist
19 return date.toLocaleString(undefined, options);
20}
21
22// Näite kasutamine
23const timestamp = 1609459200; // 1. jaanuar 2021 00:00:00 UTC
24console.log(convertUnixTimestamp(timestamp, false)); // 24-tunnine formaat
25console.log(convertUnixTimestamp(timestamp, true)); // 12-tunnine formaat
261# Python timestamp'i konversioon
2import datetime
3
4def convert_unix_timestamp(timestamp, use_12hour=False):
5 # Muutke Unix timestamp datetime objektiks
6 date = datetime.datetime.fromtimestamp(timestamp)
7
8 # Vormindage kuupäeva string
9 if use_12hour:
10 format_string = "%A, %B %d, %Y %I:%M:%S %p" # 12-tunnine formaat AM/PM
11 else:
12 format_string = "%A, %B %d, %Y %H:%M:%S" # 24-tunnine formaat
13
14 return date.strftime(format_string)
15
16# Näite kasutamine
17timestamp = 1609459200 # 1. jaanuar 2021 00:00:00 UTC
18print(convert_unix_timestamp(timestamp, False)) # 24-tunnine formaat
19print(convert_unix_timestamp(timestamp, True)) # 12-tunnine formaat
201<?php
2// PHP timestamp'i konversioon
3function convertUnixTimestamp($timestamp, $use12Hour = false) {
4 // Vormindamisstring
5 $formatString = $use12Hour
6 ? 'l, F j, Y g:i:s A' // 12-tunnine formaat AM/PM
7 : 'l, F j, Y H:i:s'; // 24-tunnine formaat
8
9 // Muutke ja vormindage kuupäev
10 return date($formatString, $timestamp);
11}
12
13// Näite kasutamine
14$timestamp = 1609459200; // 1. jaanuar 2021 00:00:00 UTC
15echo convertUnixTimestamp($timestamp, false) . "\n"; // 24-tunnine formaat
16echo convertUnixTimestamp($timestamp, true) . "\n"; // 12-tunnine formaat
17?>
181// Java timestamp'i konversioon
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 // Muutke Unix timestamp Instant'iks, seejärel LocalDateTime'iks
10 Instant instant = Instant.ofEpochSecond(timestamp);
11 LocalDateTime dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
12
13 // Looge vormindaja soovitud vormingu põhjal
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 // Vormindage kuupäev
19 return dateTime.format(formatter);
20 }
21
22 public static void main(String[] args) {
23 long timestamp = 1609459200; // 1. jaanuar 2021 00:00:00 UTC
24 System.out.println(convertUnixTimestamp(timestamp, false)); // 24-tunnine formaat
25 System.out.println(convertUnixTimestamp(timestamp, true)); // 12-tunnine formaat
26 }
27}
281// C# timestamp'i konversioon
2using System;
3
4class UnixTimestampConverter
5{
6 public static string ConvertUnixTimestamp(long timestamp, bool use12Hour)
7 {
8 // Muutke Unix timestamp DateTime'iks
9 // Unix timestamp on sekundid alates 1970-01-01
10 DateTime dateTime = DateTimeOffset.FromUnixTimeSeconds(timestamp).DateTime;
11
12 // Vormindamisstring 12-tunnise või 24-tunnise eelistuse põhjal
13 string formatString = use12Hour
14 ? "dddd, MMMM d, yyyy h:mm:ss tt" // 12-tunnine formaat AM/PM
15 : "dddd, MMMM d, yyyy HH:mm:ss"; // 24-tunnine formaat
16
17 // Tagastage vormindatud kuupäev
18 return dateTime.ToString(formatString);
19 }
20
21 static void Main()
22 {
23 long timestamp = 1609459200; // 1. jaanuar 2021 00:00:00 UTC
24 Console.WriteLine(ConvertUnixTimestamp(timestamp, false)); // 24-tunnine formaat
25 Console.WriteLine(ConvertUnixTimestamp(timestamp, true)); // 12-tunnine formaat
26 }
27}
281# Ruby timestamp'i konversioon
2require 'time'
3
4def convert_unix_timestamp(timestamp, use_12hour = false)
5 # Muutke Unix timestamp Time objektiks
6 time = Time.at(timestamp)
7
8 # Vormindage 12-tunnise või 24-tunnise eelistuse põhjal
9 if use_12hour
10 time.strftime("%A, %B %d, %Y %I:%M:%S %p") # 12-tunnine formaat AM/PM
11 else
12 time.strftime("%A, %B %d, %Y %H:%M:%S") # 24-tunnine formaat
13 end
14end
15
16# Näite kasutamine
17timestamp = 1609459200 # 1. jaanuar 2021 00:00:00 UTC
18puts convert_unix_timestamp(timestamp, false) # 24-tunnine formaat
19puts convert_unix_timestamp(timestamp, true) # 12-tunnine formaat
201// Go timestamp'i konversioon
2package main
3
4import (
5 "fmt"
6 "time"
7)
8
9func convertUnixTimestamp(timestamp int64, use12Hour bool) string {
10 // Muutke Unix timestamp Time'iks
11 t := time.Unix(timestamp, 0)
12
13 // Vormindamisstring 12-tunnise või 24-tunnise eelistuse põhjal
14 formatString := "Monday, January 2, 2006 "
15 if use12Hour {
16 formatString += "3:04:05 PM" // 12-tunnine formaat AM/PM
17 } else {
18 formatString += "15:04:05" // 24-tunnine formaat
19 }
20
21 // Tagastage vormindatud aeg
22 return t.Format(formatString)
23}
24
25func main() {
26 timestamp := int64(1609459200) // 1. jaanuar 2021 00:00:00 UTC
27 fmt.Println(convertUnixTimestamp(timestamp, false)) // 24-tunnine formaat
28 fmt.Println(convertUnixTimestamp(timestamp, true)) // 12-tunnine formaat
29}
301// Swift timestamp'i konversioon
2import Foundation
3
4func convertUnixTimestamp(_ timestamp: Int, use12Hour: Bool) -> String {
5 // Looge kuupäev Unix timestamp'ist
6 let date = Date(timeIntervalSince1970: TimeInterval(timestamp))
7
8 // Looge DateFormatter
9 let formatter = DateFormatter()
10 formatter.dateStyle = .full
11
12 // Seadke ajastiil 12-tunnise või 24-tunnise eelistuse põhjal
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 // Tagastage vormindatud kuupäev
23 return formatter.string(from: date)
24}
25
26// Näite kasutamine
27let timestamp = 1609459200 // 1. jaanuar 2021 00:00:00 UTC
28print(convertUnixTimestamp(timestamp, use12Hour: false)) // 24-tunnine formaat
29print(convertUnixTimestamp(timestamp, use12Hour: true)) // 12-tunnine formaat
301# R timestamp'i konversioon
2convert_unix_timestamp <- function(timestamp, use_12hour = FALSE) {
3 # Muutke Unix timestamp POSIXct datetime'ks
4 date_time <- as.POSIXct(timestamp, origin = "1970-01-01", tz = "UTC")
5
6 # Vormindage 12-tunnise või 24-tunnise eelistuse põhjal
7 if (use_12hour) {
8 format_string <- "%A, %B %d, %Y %I:%M:%S %p" # 12-tunnine formaat AM/PM
9 } else {
10 format_string <- "%A, %B %d, %Y %H:%M:%S" # 24-tunnine formaat
11 }
12
13 # Tagastage vormindatud kuupäeva string
14 format(date_time, format_string)
15}
16
17# Näite kasutamine
18timestamp <- 1609459200 # 1. jaanuar 2021 00:00:00 UTC
19cat(convert_unix_timestamp(timestamp, FALSE), "\n") # 24-tunnine formaat
20cat(convert_unix_timestamp(timestamp, TRUE), "\n") # 12-tunnine formaat
211% MATLAB timestamp'i konversioon
2function formattedDate = convertUnixTimestamp(timestamp, use12Hour)
3 % Muutke Unix timestamp MATLAB datetime'iks
4 % MATLAB kuupäevad on päevad alates 1900-01-01, kus 1 = 1900-01-01
5 % Unix timestamp'id on sekundid alates 1970-01-01
6
7 % Esiteks konverteerige Exceli kuupäeva formaati
8 % 25569 on päevade arv 1900-01-01 ja 1970-01-01 vahel
9 excelDate = (timestamp / 86400) + 25569;
10
11 % Vormindage kuupäev 12-tunnise või 24-tunnise eelistuse põhjal
12 if use12Hour
13 formattedDate = datestr(excelDate, 'dddd, mmmm d, yyyy h:mm:ss AM/PM');
14 else
15 formattedDate = datestr(excelDate, 'dddd, mmmm d, yyyy hh:mm:ss');
16 end
17end
18
19% Näite kasutamine
20timestamp = 1609459200; % 1. jaanuar 2021 00:00:00 UTC
21disp(convertUnixTimestamp(timestamp, false)) % 24-tunnine formaat
22disp(convertUnixTimestamp(timestamp, true)) % 12-tunnine formaat
231' Excel VBA timestamp'i konversioon
2Function ConvertUnixTimestamp(timestamp As Long, Optional use12Hour As Boolean = False) As String
3 ' Muutke Unix timestamp Exceli kuupäeva/aega
4 ' Exceli kuupäevad on päevad alates 1900-01-01, kus 1 = 1900-01-01
5 ' Unix timestamp'id on sekundid alates 1970-01-01
6
7 ' Esiteks konverteerige Exceli kuupäeva formaati
8 ' 25569 on päevade arv 1900-01-01 ja 1970-01-01 vahel
9 Dim excelDate As Double
10 excelDate = (timestamp / 86400) + 25569
11
12 ' Vormindage kuupäev 12-tunnise või 24-tunnise eelistuse põhjal
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' Kasutamine töölehe sees:
21' =ConvertUnixTimestamp(1609459200, TRUE) ' 12-tunnine formaat
22' =ConvertUnixTimestamp(1609459200, FALSE) ' 24-tunnine formaat
23Äärmuslike Juhtude Käsitlemine
Unix timestamp'idega töötamisel on oluline õigesti käsitleda äärmuslikke juhtumeid. Siin on näited, kuidas käsitleda mõningaid levinud äärmuslikke juhtumeid:
1// JavaScript äärmuslike juhtumite käsitlemine
2function safeConvertTimestamp(timestamp, use12Hour = false) {
3 // Kontrollige, kas timestamp on kehtiv
4 if (timestamp === undefined || timestamp === null || isNaN(timestamp)) {
5 return "Kehtetu timestamp";
6 }
7
8 // Kontrollige negatiivseid timestamp'e (kuupäevad enne 1970)
9 if (timestamp < 0) {
10 // Mõned brauserid ei pruugi negatiivseid timestamp'e õigesti käsitleda
11 // Kasutage enne 1970. aastat kindlamat lähenemist
12 const date = new Date(timestamp * 1000);
13 if (isNaN(date.getTime())) {
14 return "Kehtetu kuupäev (enne 1970)";
15 }
16 }
17
18 // Kontrollige Y2K38 probleemi (32-bitiste süsteemide jaoks)
19 const maxInt32 = 2147483647; // 32-bitise allkirjastatud täisarvu maksimaalne väärtus
20 if (timestamp > maxInt32) {
21 // Kaaluge BigInt'i kasutamist väga suurte timestamp'ide jaoks kaasaegses JavaScriptis
22 console.warn("Timestamp ületab 32-bitise täisarvu piiri (Y2K38 probleem)");
23 }
24
25 // Jätkake normaalse konversiooniga
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 "Viga timestamp'i konverteerimisel: " + error.message;
41 }
42}
43Viidatud Allikad
-
"Unix Aeg." Wikipedia, Wikimedia Foundation, https://en.wikipedia.org/wiki/Unix_time
-
"Aasta 2038 Probleem." Wikipedia, Wikimedia Foundation, https://en.wikipedia.org/wiki/Year_2038_problem
-
Olson, Arthur David. "Kalendriaja Keerukused." The Open Group, https://www.usenix.org/legacy/events/usenix01/full_papers/olson/olson.pdf
-
"ISO 8601." Wikipedia, Wikimedia Foundation, https://en.wikipedia.org/wiki/ISO_8601
-
"RFC 3339: Interneti Aja ja Kuupäeva Templid." Internet Engineering Task Force (IETF), https://tools.ietf.org/html/rfc3339
-
Kernighan, Brian W., ja Dennis M. Ritchie. "C Programmeerimiskeel." Prentice Hall, 1988.
Tagasiside
Klõpsake tagasiside teatele, et alustada tagasiside andmist selle tööriista kohta
Seotud tööriistad
Avasta rohkem tööriistu, mis võivad olla kasulikud teie töövoos