Unix laika zīmoga uz datuma pārvēršanas rīks: 12/24 stundu formāta atbalsts
Pārvērst Unix laika zīmogus cilvēkam saprotamos datumos un laikos. Izvēlieties starp 12 stundu un 24 stundu laika formātiem ar šo vienkāršo, lietotājam draudzīgo pārvēršanas rīku.
Unix laika zīmju pārveidotājs
Pārveidotā datums un laiks
Dokumentācija
Unix laika pārvēršana
Ievads
Unix laiks (pazīstams arī kā POSIX laiks vai Epoch laiks) ir sistēma, kas apraksta laika punktu. Tas ir sekunžu skaits, kas pagājis kopš 1970. gada 1. janvāra (pusstundā UTC/GMT), neiekļaujot lēciena sekundes. Unix laiki plaši tiek izmantoti datoru sistēmās un programmēšanas valodās, jo tie nodrošina kompakta, valodu neatkarīgu laika brīža attēlojumu.
Šis pārvēršanas rīks ļauj jums pārvērst Unix laiku cilvēkam lasāmā datuma un laika formātā. Tas atbalsta gan 12 stundu (AM/PM), gan 24 stundu laika formātus, lai apmierinātu dažādas reģionālās un personiskās preferences.
Kā darbojas Unix laiki
Unix laiki tiek aprēķināti kā sekunžu skaits kopš Unix Epoch (1970. gada 1. janvāra, 00:00:00 UTC). Tas padara tos īpaši noderīgus laika atšķirību aprēķināšanai un datu glabāšanai kompakta formātā.
Matemātiskā pārvēršana no Unix laika uz kalendāra datumu ietver vairākus soļus:
- Sākt ar Unix Epoch (1970. gada 1. janvāra, 00:00:00 UTC)
- Pievienot laika zīmē esošo sekunžu skaitu
- Ņemt vērā lēciena gadus, mainīgus mēnešu garumus un citas kalendāra sarežģītības
- Ja nepieciešams, piemērot laika joslas pielāgojumus
Piemēram, Unix laiks 1609459200 attēlo piektdienu, 2021. gada 1. janvāri, 00:00:00 UTC.
Pārvēršanas formulu var izteikt kā:
Lielākā daļa programmēšanas valodu un operētājsistēmu nodrošina iebūvētas funkcijas, lai apstrādātu šo pārvēršanu, slēpjot sarežģītās kalendāra aprēķinus.
Laika formātu opcijas
Šis pārvēršanas rīks piedāvā divas laika formāta opcijas:
-
24 stundu formāts (dažreiz saukts par "militāro laiku"): Stundas svārstās no 0 līdz 23, un nav AM/PM apzīmējuma. Piemēram, 15:00 tiek attēlots kā 15:00.
-
12 stundu formāts: Stundas svārstās no 1 līdz 12, ar AM (ante meridiem) laikiem no pusnakts līdz pusdienlaikam un PM (post meridiem) laikiem no pusdienlaika līdz pusnaktij. Piemēram, 15:00 24 stundu formātā tiek attēlots kā 3:00 PM.
Izvēle starp šiem formātiem galvenokārt ir reģionāla konvencija un personiska preference:
- 24 stundu formāts ir plaši izmantots lielākajā daļā Eiropas, Latīņamerikas un Āzijas, kā arī zinātniskos, militāros un medicīnas kontekstos visā pasaulē.
- 12 stundu formāts ir izplatīts Amerikas Savienotajās Valstīs, Kanādā, Austrālijā un dažās citās angliski runājošās valstīs ikdienas lietošanai.
Malu gadījumi un ierobežojumi
Strādājot ar Unix laikiem, ir svarīgi būt uzmanīgam pret vairākiem malu gadījumiem un ierobežojumiem:
-
Negatīvi laiki: Šie attēlo datumus pirms Unix Epoch (1970. gada 1. janvāra). Lai gan matemātiski tie ir derīgi, dažas sistēmas var nepareizi apstrādāt negatīvus laikus.
-
2038. gada problēma: Unix laiki bieži tiek glabāti kā 32 bitu parakstīti veseli skaitļi, kas pārsniegs 19. janvāra 2038. gadu. Pēc šī brīža 32 bitu sistēmas nespēs pareizi attēlot laikus, ja vien tās netiks modificētas, lai izmantotu lielāku veselu skaitļu tipu.
-
Ļoti lieli laiki: Ļoti tālu nākotnes datumi var nebūt attēlojami dažās sistēmās vai var tikt apstrādāti nesakritīgi.
-
Lēciena sekundes: Unix laiks neņem vērā lēciena sekundes, kas reizēm tiek pievienotas UTC, lai kompensētu Zemes neregulāro rotāciju. Tas nozīmē, ka Unix laiks nav precīzi sinhronizēts ar astronomisko laiku.
-
Laika joslas apsvērumi: Unix laiki attēlo mirkļus UTC. Pārvēršana uz vietējo laiku prasa papildu laika joslas informāciju.
-
Vasaras laiks: Pārvēršot laikus uz vietējo laiku, jāņem vērā Vasaras laika pārejas sarežģītības.
Lietošanas gadījumi
Unix laiki tiek izmantoti daudzās lietojumprogrammās datoru un datu pārvaldībā:
-
Datu bāzes ieraksti: Laiki parasti tiek izmantoti, lai reģistrētu, kad ieraksti tika izveidoti vai mainīti.
-
Tīmekļa izstrāde: HTTP galvenes, sīkfaili un kešatmiņas mehānismi bieži izmanto Unix laikus.
-
Žurnālu faili: Sistēmas žurnāli parasti reģistrē notikumus ar Unix laikiem precīzai hronoloģiskai secībai.
-
Versiju kontroles sistēmas: Git un citas VCS izmanto laikus, lai reģistrētu, kad tika veikti komitejas.
-
API atbildes: Daudzi tīmekļa API iekļauj laikus savās atbildēs, lai norādītu, kad dati tika ģenerēti vai kad resursi tika pēdējo reizi modificēti.
-
Failu sistēmas: Failu izveides un modificēšanas laiki bieži tiek glabāti kā Unix laiki.
-
Sesiju pārvaldība: Tīmekļa lietojumprogrammas izmanto laikus, lai noteiktu, kad lietotāja sesijas jābeidz.
-
Datu analīze: Laiki nodrošina standartizētu veidu, kā strādāt ar laika datiem analītikas lietojumprogrammās.
Alternatīvas
Lai gan Unix laiki ir plaši izmantoti, ir alternatīvi laika attēlojuma formāti, kas var būt piemērotāki noteiktos kontekstos:
-
ISO 8601: Standartizēts virknes formāts (piemēram, "2021-01-01T00:00:00Z"), kas ir cilvēkam lasāms, saglabājot kārtību. Tas bieži tiek izvēlēts datu apmaiņai un lietotāja saskarnēm.
-
RFC 3339: ISO 8601 profils, ko izmanto interneta protokolos, ar stingrākām formatēšanas prasībām.
-
Cilvēkam lasāmi formāti: Lokalizēti datuma virknējumi (piemēram, "2021. gada 1. janvāris") ir piemērotāki tiešai lietotāju mijiedarbībai, bet ir mazāk piemēroti aprēķiniem.
-
Microsoft FILETIME: 64 bitu vērtība, kas attēlo 100 nanosekundi intervālus kopš 1601. gada 1. janvāra, ko izmanto Windows sistēmās.
-
Jūlija dienas numurs: Izmanto astronomijā un dažās zinātniskās lietojumprogrammās, skaitot dienas kopš 4713. gada p.m.ē. 1. janvāra.
Laika formāta izvēle ir atkarīga no tādiem faktoriem kā:
- Nepieciešamā precizitāte
- Cilvēku lasāmības vajadzības
- Glabāšanas ierobežojumi
- Saderība ar esošajām sistēmām
- Datumu diapazons, kas jāattēlo
Vēsture
Unix laika koncepts radās, izstrādājot Unix operētājsistēmu Bell Labs 1960. gadu beigās un 1970. gadu sākumā. Lēmums izmantot 1970. gada 1. janvāri kā epoch bija nedaudz patvaļīgs, bet praktisks tajā laikā - tas bija pietiekami nesens, lai samazinātu datu glabāšanas prasības interesējošiem datumiem, bet pietiekami tālu pagātnē, lai būtu noderīgs vēsturiskajiem datiem.
Sākotnējā īstenošana izmantoja 32 bitu parakstītu veselu skaitli, lai glabātu sekunžu skaitu, kas bija pietiekams gaidāmajam Unix sistēmu mūža ilgumam tajā laikā. Tomēr šis lēmums noveda pie 2038. gada problēmas (dažreiz sauktas par "Y2K38" vai "Unix milēnija kļūda"), jo 32 bitu parakstīti veseli skaitļi var attēlot laikus tikai līdz 1970. gada 1. janvāra 19. janvārim (03:14:07 UTC).
Kad Unix un Unix līdzīgas operētājsistēmas ieguva popularitāti, Unix laiks kļuva par de facto standartu laika attēlošanai datoru jomā. To pieņēma daudzas programmēšanas valodas, datu bāzes un lietojumprogrammas, paplašinot tā pielietojumu tālu ārpus sākotnējās Unix vides.
Mūsdienu sistēmas arvien biežāk izmanto 64 bitu veselos skaitļus laikiem, kas paplašina attēlojamā diapazona robežas līdz aptuveni 292 miljardiem gadu abos virzienos no epoch, efektīvi atrisinot 2038. gada problēmu. Tomēr mantojuma sistēmas un lietojumprogrammas var joprojām būt neaizsargātas.
Unix laika vienkāršība un lietderība ir nodrošinājusi tā turpmāku nozīmīgumu, neskatoties uz sarežģītāku laika attēlojuma formātu izstrādi. Tas joprojām ir pamatjēdziens datorzinātnēs, kas veido pamatu lielākajai daļai mūsu digitālās infrastruktūras.
Koda piemēri
Šeit ir piemēri, kā pārvērst Unix laikus cilvēkam lasāmā datumā dažādās programmēšanas valodās:
1// JavaScript laika pārvēršana
2function convertUnixTimestamp(timestamp, use12Hour = false) {
3 // Izveido jaunu Date objektu (JavaScript izmanto milisekundes)
4 const date = new Date(timestamp * 1000);
5
6 // Formatēšanas opcijas
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 // Pārvērš uz virkni, izmantojot lokalizētu formatēšanu
19 return date.toLocaleString(undefined, options);
20}
21
22// Piemēra izmantošana
23const timestamp = 1609459200; // 2021. gada 1. janvāris 00:00:00 UTC
24console.log(convertUnixTimestamp(timestamp, false)); // 24 stundu formāts
25console.log(convertUnixTimestamp(timestamp, true)); // 12 stundu formāts
261# Python laika pārvēršana
2import datetime
3
4def convert_unix_timestamp(timestamp, use_12hour=False):
5 # Pārvērš Unix laiku uz datetime objektu
6 date = datetime.datetime.fromtimestamp(timestamp)
7
8 # Formatē datuma virkni
9 if use_12hour:
10 format_string = "%A, %B %d, %Y %I:%M:%S %p" # 12 stundu formāts ar AM/PM
11 else:
12 format_string = "%A, %B %d, %Y %H:%M:%S" # 24 stundu formāts
13
14 return date.strftime(format_string)
15
16# Piemēra izmantošana
17timestamp = 1609459200 # 2021. gada 1. janvāris 00:00:00 UTC
18print(convert_unix_timestamp(timestamp, False)) # 24 stundu formāts
19print(convert_unix_timestamp(timestamp, True)) # 12 stundu formāts
201<?php
2// PHP laika pārvēršana
3function convertUnixTimestamp($timestamp, $use12Hour = false) {
4 // Formatēšanas virkne
5 $formatString = $use12Hour
6 ? 'l, F j, Y g:i:s A' // 12 stundu formāts ar AM/PM
7 : 'l, F j, Y H:i:s'; // 24 stundu formāts
8
9 // Pārvērš un formatē datumu
10 return date($formatString, $timestamp);
11}
12
13// Piemēra izmantošana
14$timestamp = 1609459200; // 2021. gada 1. janvāris 00:00:00 UTC
15echo convertUnixTimestamp($timestamp, false) . "\n"; // 24 stundu formāts
16echo convertUnixTimestamp($timestamp, true) . "\n"; // 12 stundu formāts
17?>
181// Java laika pārvēršana
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 // Pārvērš Unix laiku uz Instant, tad uz LocalDateTime
10 Instant instant = Instant.ofEpochSecond(timestamp);
11 LocalDateTime dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
12
13 // Izveido formatētāju atkarībā no vēlamā formāta
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 // Formatē datumu
19 return dateTime.format(formatter);
20 }
21
22 public static void main(String[] args) {
23 long timestamp = 1609459200; // 2021. gada 1. janvāris 00:00:00 UTC
24 System.out.println(convertUnixTimestamp(timestamp, false)); // 24 stundu formāts
25 System.out.println(convertUnixTimestamp(timestamp, true)); // 12 stundu formāts
26 }
27}
281// C# laika pārvēršana
2using System;
3
4class UnixTimestampConverter
5{
6 public static string ConvertUnixTimestamp(long timestamp, bool use12Hour)
7 {
8 // Pārvērš Unix laiku uz DateTime
9 // Unix laiks ir sekundes kopš 1970-01-01
10 DateTime dateTime = DateTimeOffset.FromUnixTimeSeconds(timestamp).DateTime;
11
12 // Formatēšanas virkne atkarībā no 12 stundu vai 24 stundu preferences
13 string formatString = use12Hour
14 ? "dddd, MMMM d, yyyy h:mm:ss tt" // 12 stundu formāts ar AM/PM
15 : "dddd, MMMM d, yyyy HH:mm:ss"; // 24 stundu formāts
16
17 // Atgriež formatētu datumu
18 return dateTime.ToString(formatString);
19 }
20
21 static void Main()
22 {
23 long timestamp = 1609459200; // 2021. gada 1. janvāris 00:00:00 UTC
24 Console.WriteLine(ConvertUnixTimestamp(timestamp, false)); // 24 stundu formāts
25 Console.WriteLine(ConvertUnixTimestamp(timestamp, true)); // 12 stundu formāts
26 }
27}
281# Ruby laika pārvēršana
2require 'time'
3
4def convert_unix_timestamp(timestamp, use_12hour = false)
5 # Pārvērš Unix laiku uz Time objektu
6 time = Time.at(timestamp)
7
8 # Formatē atkarībā no 12 stundu vai 24 stundu preferences
9 if use_12hour
10 time.strftime("%A, %B %d, %Y %I:%M:%S %p") # 12 stundu formāts ar AM/PM
11 else
12 time.strftime("%A, %B %d, %Y %H:%M:%S") # 24 stundu formāts
13 end
14end
15
16# Piemēra izmantošana
17timestamp = 1609459200 # 2021. gada 1. janvāris 00:00:00 UTC
18puts convert_unix_timestamp(timestamp, false) # 24 stundu formāts
19puts convert_unix_timestamp(timestamp, true) # 12 stundu formāts
201// Go laika pārvēršana
2package main
3
4import (
5 "fmt"
6 "time"
7)
8
9func convertUnixTimestamp(timestamp int64, use12Hour bool) string {
10 // Pārvērš Unix laiku uz Time
11 t := time.Unix(timestamp, 0)
12
13 // Formatēšanas virkne atkarībā no 12 stundu vai 24 stundu preferences
14 formatString := "Monday, January 2, 2006 "
15 if use12Hour {
16 formatString += "3:04:05 PM" // 12 stundu formāts ar AM/PM
17 } else {
18 formatString += "15:04:05" // 24 stundu formāts
19 }
20
21 // Atgriež formatētu laiku
22 return t.Format(formatString)
23}
24
25func main() {
26 timestamp := int64(1609459200) // 2021. gada 1. janvāris 00:00:00 UTC
27 fmt.Println(convertUnixTimestamp(timestamp, false)) // 24 stundu formāts
28 fmt.Println(convertUnixTimestamp(timestamp, true)) // 12 stundu formāts
29}
301// Swift laika pārvēršana
2import Foundation
3
4func convertUnixTimestamp(_ timestamp: Int, use12Hour: Bool) -> String {
5 // Izveido Date no Unix laika
6 let date = Date(timeIntervalSince1970: TimeInterval(timestamp))
7
8 // Izveido DateFormatter
9 let formatter = DateFormatter()
10 formatter.dateStyle = .full
11
12 // Iestata laika stilu atkarībā no 12 stundu vai 24 stundu preferences
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 // Atgriež formatētu datumu
23 return formatter.string(from: date)
24}
25
26// Piemēra izmantošana
27let timestamp = 1609459200 // 2021. gada 1. janvāris 00:00:00 UTC
28print(convertUnixTimestamp(timestamp, use12Hour: false)) // 24 stundu formāts
29print(convertUnixTimestamp(timestamp, use12Hour: true)) // 12 stundu formāts
301# R laika pārvēršana
2convert_unix_timestamp <- function(timestamp, use_12hour = FALSE) {
3 # Pārvērš Unix laiku uz POSIXct datumu
4 date_time <- as.POSIXct(timestamp, origin = "1970-01-01", tz = "UTC")
5
6 # Formatē atkarībā no 12 stundu vai 24 stundu preferences
7 if (use_12hour) {
8 format_string <- "%A, %B %d, %Y %I:%M:%S %p" # 12 stundu formāts ar AM/PM
9 } else {
10 format_string <- "%A, %B %d, %Y %H:%M:%S" # 24 stundu formāts
11 }
12
13 # Atgriež formatētu datumu
14 format(date_time, format_string)
15}
16
17# Piemēra izmantošana
18timestamp <- 1609459200 # 2021. gada 1. janvāris 00:00:00 UTC
19cat(convert_unix_timestamp(timestamp, FALSE), "\n") # 24 stundu formāts
20cat(convert_unix_timestamp(timestamp, TRUE), "\n") # 12 stundu formāts
211% MATLAB laika pārvēršana
2function formattedDate = convertUnixTimestamp(timestamp, use12Hour)
3 % Pārvērš Unix laiku uz MATLAB datetime
4 % MATLAB datumi ir dienas kopš 1900-01-01, ar 1 = 1900-01-01
5 % Unix laiki ir sekundes kopš 1970-01-01
6
7 % Vispirms pārvērš uz Excel datuma formātu
8 % 25569 ir dienu skaits starp 1900-01-01 un 1970-01-01
9 excelDate = (timestamp / 86400) + 25569;
10
11 % Formatē atkarībā no 12 stundu vai 24 stundu preferences
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% Piemēra izmantošana
20timestamp = 1609459200; % 2021. gada 1. janvāris 00:00:00 UTC
21disp(convertUnixTimestamp(timestamp, false)) % 24 stundu formāts
22disp(convertUnixTimestamp(timestamp, true)) % 12 stundu formāts
231' Excel VBA laika pārvēršana
2Function ConvertUnixTimestamp(timestamp As Long, Optional use12Hour As Boolean = False) As String
3 ' Pārvērš Unix laiku uz Excel datumu/laiku
4 ' Excel datumi ir dienas kopš 1900-01-01, ar 1 = 1900-01-01
5 ' Unix laiki ir sekundes kopš 1970-01-01
6
7 ' Vispirms pārvērš uz Excel datuma formātu
8 ' 25569 ir dienu skaits starp 1900-01-01 un 1970-01-01
9 Dim excelDate As Double
10 excelDate = (timestamp / 86400) + 25569
11
12 ' Formatēšanas virkne atkarībā no 12 stundu vai 24 stundu preferences
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' Lietošana darba lapā:
21' =ConvertUnixTimestamp(1609459200, TRUE) ' 12 stundu formāts
22' =ConvertUnixTimestamp(1609459200, FALSE) ' 24 stundu formāts
23Malu gadījumu apstrāde
Strādājot ar Unix laikiem, ir svarīgi pareizi apstrādāt malu gadījumus. Šeit ir piemēri, kā apstrādāt dažus kopīgus malu gadījumus:
1// JavaScript malu gadījumu apstrāde
2function safeConvertTimestamp(timestamp, use12Hour = false) {
3 // Pārbauda, vai laiks ir derīgs
4 if (timestamp === undefined || timestamp === null || isNaN(timestamp)) {
5 return "Nederīgs laiks";
6 }
7
8 // Pārbauda negatīvus laikus (datumus pirms 1970)
9 if (timestamp < 0) {
10 // Dažas pārlūkprogrammas var nepareizi apstrādāt negatīvus laikus
11 // Izmanto robustāku pieeju datumiem pirms 1970
12 const date = new Date(timestamp * 1000);
13 if (isNaN(date.getTime())) {
14 return "Nederīgs datums (pirms 1970)";
15 }
16 }
17
18 // Pārbauda Y2K38 problēmu (32 bitu sistēmām)
19 const maxInt32 = 2147483647; // Maksimālā vērtība 32 bitu parakstītam veselam skaitlim
20 if (timestamp > maxInt32) {
21 // Apsver iespēju izmantot BigInt ļoti lieliem laikiem modernajā JavaScript
22 console.warn("Laiks pārsniedz 32 bitu veselā skaitļa robežu (Y2K38 problēma)");
23 }
24
25 // Turpina ar parasto pārvēršanu
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 "Kļūda, pārvēršot laiku: " + error.message;
41 }
42}
43Atsauces
-
"Unix laiks." Vikipēdija, Wikimedia Foundation, https://en.wikipedia.org/wiki/Unix_time
-
"2038. gada problēma." Vikipēdija, Wikimedia Foundation, https://en.wikipedia.org/wiki/Year_2038_problem
-
Olson, Arthur David. "Kalendāra laika sarežģītības." The Open Group, https://www.usenix.org/legacy/events/usenix01/full_papers/olson/olson.pdf
-
"ISO 8601." Vikipēdija, Wikimedia Foundation, https://en.wikipedia.org/wiki/ISO_8601
-
"RFC 3339: Datums un laiks internetā: Laiki." Interneta inženierijas darba grupa (IETF), https://tools.ietf.org/html/rfc3339
-
Kernighan, Brian W., un Dennis M. Ritchie. "C programmēšanas valoda." Prentice Hall, 1988.
Atsauksmes
Noklikšķiniet uz atsauksmju paziņojuma, lai sāktu sniegt atsauksmes par šo rīku
Saistītie rīki
Atklājiet vairāk rīku, kas varētu būt noderīgi jūsu darba plūsmā