Unix Timestamp-იდან თარიღამდე: წამები, მილიწამები და UTC ახსნილი

ეს გარდაქმნის სახელმძღვანელოა: timestamp-იდან თარიღამდე, თარიღიდან timestamp-ამდე, UTC ადგილობრივის წინააღმდეგ და ISO 8601. თუ მნიშვნელობა მოულოდნელად 1970 წლის თარიღად იქცევა, ჩვეულებრივ წამების/მილიწამების შეუსაბამობაა—ნახეთ Unix Timestamp წამები vs მილიწამები: რატომ აჩვენებს თარიღი 1970-ს.

რა არის Unix Timestamp?

Unix timestamp, Unix time და epoch time ჩვეულებრივ ნიშნავს დროს, რომელიც გავიდა 1970-01-01 00:00:00 UTC-იდან. რიცხვი არ არის ფორმატირებული თარიღის სტრიქონი დროის სარტყლის ეტიკეტით. იგივე წამი შეიძლება სხვადასხვა საათის სახით გამოჩნდეს UTC-ში, ნიუ-იორკში, ტოკიოში ან სეულში. Unix timestamp-ები ყოველთვის წამები არ არის—პრაქტიკაში მილიწამები ხშირია.

რა არის Unix Epoch?

Unix epoch არის 1970-01-01 00:00:00 UTC. timestamp 0 არის ეს წამი. დადებითი timestamp epoch-ის შემდეგაა. ზოგი სისტემა უარყოფით timestamp-ს უშვებს epoch-მდე დროისთვის, მაგრამ ენის და თარიღის დიაპაზონის მხარდაჭერა იცვლება.

ჩემი timestamp წამებშია თუ მილიწამებში?

1720000000 წამებია; 1720000000000 მილიწამებია; იგივე წამია. პრაქტიკული მინიშნება: დაახლოებით 10 ციფრი ხშირად წამებია, დაახლოებით 13 მილიწამები. ციფრების რაოდენობა მხოლოდ ევრისტიკაა. წარსული ან მომავალი თარიღები, სხვა ერთეულები ან მორგებული epoch შეიძლება სხვანაირად გამოიყურებოდეს. თარიღისა და დროის გადამყვანი-ს შეუძლია გარდაქმნა წამებით, მილიწამებით ან ავტოთი (≤10 ციფრი წამებად, ≥13 მილიწამებად)—აირჩიეთ ერთეული, როცა იცით.

რატომ იძლევა არასწორი ერთეული არასწორ თარიღს?

JavaScript Date მილიწამებს ელის. 1720000000-ის მილიწამებად გადაცემა იძლევა 1970-01-20 21:46:40 UTC. მილიწამების წამებად მიჩნევა, ან პირიქით, ძალიან სხვა თარიღზე ეცემა. 1970-ის დიაგნოსტიკის გზისთვის ნახეთ Unix Timestamp წამები vs მილიწამები: რატომ აჩვენებს თარიღი 1970-ს.

new Date(1720000000);
// 1970-01-20T21:46:40.000Z

როგორ გარდავქმნა Unix timestamp წამებში

გაამრავლეთ წამები 1000-ზე მილიწამების მისაღებად. JavaScript Date მილიწამებზეა დაფუძნებული, ამიტომ გამოიყენეთ new Date(timestamp * 1000).

const timestamp = 1720000000;
const date = new Date(timestamp * 1000);
date.toISOString();
// 2024-07-03T09:46:40.000Z

როგორ გარდავქმნა მილიწამების timestamp

მილიწამები პირდაპირ გადაეცით Date-ს. ნუ გაამრავლებთ კვლავ 1000-ზე timestamp-ს, რომელიც უკვე მილიწამებშია.

const timestamp = 1720000000000;
const date = new Date(timestamp);
date.toISOString();
// 2024-07-03T09:46:40.000Z

რატომ აჩვენებს ერთი და იგივე timestamp სხვა საათს?

Unix timestamp ერთი წამია. მისი ჩვენება UTC-ში, ადგილობრივ დროში ან არჩეულ IANA სარტყელში საათის სახეს ცვლის. 1720000000000-ისთვის UTC არის 2024-07-03 09:46:40. America/New_York იმ თარიღზე არის 2024-07-03 05:46:40 (EDT). Asia/Seoul არის 2024-07-03 18:46:40 (UTC+9). ნიუ-იორკისა და სეულის ეს მნიშვნელობები Intl-იდან მოდის, არა ფიქსირებული ძვრის ლოზუნგიდან.

Unix timestamp შეიცავს დროის სარტყელს?

არა. არ ინახავს America/New_York-ს ან Asia/Seoul-ს. Timestamp ერთ წამს განსაზღვრავს. დროის სარტყელი გამოიყენება ამ წამის ადამიანისთვის წაკითხვადი თარიღისა და საათის სახით დაფორმატებისას. Epoch UTC-თან მიმართებითაა განსაზღვრული; თავად რიცხვი არ არის «UTC დროის სარტყლის ველი».

Unix Timestamp ISO 8601-ის წინააღმდეგ

1720000000 და 2024-07-03T09:46:40Z შეიძლება ერთსა და იმავე წამს წარმოადგენდეს. Unix გასული დროის რიცხვითი მნიშვნელობაა. ISO 8601 წაკითხვადი თარიღ-დროის სტრიქონია და შეიძლება დასრულდეს Z-ით (UTC) ან რიცხვითი ძვრით. Z ნიშნავს UTC-ს; ზოგჯერ Zulu ჰქვია. ერთი და იგივე ფორმატი არ არის.

როგორ მივიღო მიმდინარე Unix timestamp?

JavaScript-ში Date.now() მილიწამებია. Math.floor(Date.now() / 1000) წამებია. ნუ ჩააკრავთ «ახლა»-ს სტატიაში; ის მოძრაობს.

Date.now();
Math.floor(Date.now() / 1000);

შეიძლება თარიღის უკან Unix timestamp-ად გარდაქმნა?

დიახ. ცხადი UTC ISO სტრიქონიდან getTime() აბრუნებს მილიწამებს; წამებისთვის გაყავით 1000-ზე და ჩამოამრგვალეთ ქვემოთ.

const date = new Date("2024-07-03T09:46:40Z");
date.getTime();
// 1720000000000
Math.floor(date.getTime() / 1000);
// 1720000000

ფრთხილად იყავით ორაზროვან თარიღის ფორმატებთან

03/07/2024 შეიძლება იყოს 7 მარტი ან 3 ივლისი რეგიონის მიხედვით. უპირატესობა მიანიჭეთ ISO-სტილის თარიღსა და დროს სარტყლით ან ძვრით. თარიღისა და დროის გადამყვანი უარყოფს ორაზროვან რიცხვით თარიღებს როგორიცაა 01/02/2026 და ითხოვს თარიღის ამრჩევს ან ISO-სტილის მნიშვნელობას.

რაც შეეხება ზაფხულის დროს?

Unix timestamp ზაფხულის დროის ნიშანს არ ინახავს. ადგილობრივი ჩვენება სარტყლის წესებს იყენებს. America/New_York სხვადასხვა ძვრს იყენებს ზამთარში და ზაფხულში, ამიტომ «ნიუ-იორკი UTC-5-ია» ყოველთვის სიმართლე არ არის.

Unix timestamp-ები მოიცავს ნახტომ წამებს?

ტიპიური POSIX/Unix დრო ნახტომ წამებს უწყვეტ შკალაზე დამატებით SI წამებად არ ითვლის. პლატფორმები შეიძლება განსხვავდებოდეს. ყოველდღიურ გარდაქმნაზე ამ დეტალს შეგიძლიათ უგულებელყოთ.

Unix timestamp-ის გარდაქმნის ხშირი შეცდომები

ეს არეულობები იძლევა არასწორ თარიღს ან არასწორ საათის სახეს:

წამები მილიწამებად მიჩნეული
თანამედროვე წამების მნიშვნელობა JavaScript Date-ში 1970-თან ახლოს რჩება.

მილიწამები წამებად მიჩნეული
თარიღი შორს მომავალში ხტება.

10 ან 13 ციფრის კანონად მიჩნევა
ციფრების რაოდენობა მინიშნებაა, არა გარანტია.

UTC-ის ადგილობრივ დროსთან აბნევა
წამი ერთია; ნაჩვენები საათი შეიძლება განსხვავდებოდეს.

რიცხვში დროის სარტყლის არსებობის ვარაუდი
IANA სახელები ჩვენებისას გამოიყენება, timestamp-ში არ ინახება.

ორაზროვანი თარიღები, ზაფხულის დროის ლოზუნგები ან ზედმეტი ×1000
გამოიყენეთ ISO-სტილის შეყვანა. ნუ გაამრავლებთ კვლავ მილიწამების timestamp-ს.

შემოწმებული UTC მაგალითები

ეს UTC საათები გამოთვლილია, არა გამოცნობილი:

შეყვანა	ერთეული	UTC
0	წამები	1970-01-01 00:00:00
1720000000	წამები	2024-07-03 09:46:40
1720000000000	მილიწამები	2024-07-03 09:46:40
1720000000	მილიწამები	1970-01-20 21:46:40

მარტივი გარდაქმნის გადაწყვეტილების სახელმძღვანელო

თუ წყარო ერთეულს ასახელებს, გამოიყენეთ. თუ არა, ციფრების რაოდენობა მინიშნებაა—შემდეგ შეამოწმეთ, რომ თარიღი დამაჯერებელი ჩანს. გადაიყვანეთ წამები მილიწამებში, როცა API-ს ms სჭირდება. ჩვენებისთვის აირჩიეთ UTC, ადგილობრივი ან IANA სარტყელი. ISO 8601 სასარგებლოა შენახვისა და გაცვლისთვის.

• გაქვთ Unix timestamp
• ↓
• ერთეული მითითებულია? გამოიყენეთ; თუ არა, შეხედეთ სიდიდეს
• წამები? ×1000 თუ API-ს მილიწამები სჭირდება
• მილიწამები? გამოიყენეთ პირდაპირ ms-ზე დაფუძნებულ API-ში
• აჩვენეთ როგორც UTC, ადგილობრივი ან IANA სარტყელი
• ↓
• სტრიქონი გჭირდებათ? ISO 8601 შეიძლება მოერგოს

გარდაქმენით Unix timestamp-ები ბრაუზერში

NEXNARA თარიღისა და დროის გადამყვანი გარდაქმნის Unix წამებსა და მილიწამებს, აჩვენებს UTC-ს, ადგილობრივ დროს და ISO 8601-ს, და გარდაქმნის IANA დროის სარტყლებს შორის.

Unix რეჟიმი მხარს უჭერს წამებს, მილიწამებს, ავტო ერთეულს, მიმდინარე დროს და თარიღიდან timestamp-ს. დროის სარტყლის რეჟიმი ეძებს IANA სახელებს, იყენებს ბრაუზერის სარტყელს და იყენებს ზაფხულის დროის გათვალისწინებულ Intl ძვრებს. ფორმატის რეჟიმს აქვს რეგიონის მიხედვით წაკითხვადი გამოსავალი, 12/24 საათიანი ჩვენება და ორაზროვანი თარიღის დაცვა. თარიღების სხვაობა ცალკე რეჟიმია.

გარდაქმნა იყენებს ბრაუზერის Date და Intl API-ებს. Date-ის წარმოდგენის მიღმა მნიშვნელობები უარყოფილია. ავტო ერთეული 11–12 ციფრიან მნიშვნელობებს არ გამოიცნობს; აირჩიეთ წამები ან მილიწამები.

თარიღისა და timestamp-ის გარდაქმნა თქვენს ბრაუზერში ხდება. შეყვანები გარდაქმნისთვის NEXNARA სერვერზე არ იგზავნება. რეკლამები და საიტის სხვა ფუნქციები კვლავ იყენებს ქსელს.

ჩასვით timestamp თარიღისა და დროის გადამყვანი-ში და შეადარეთ UTC, ადგილობრივი დრო და ISO 8601 ერთეულის არჩევამდე.

FAQ

როგორ გადავიყვანო Unix timestamp თარიღად?

იცოდეთ ერთეული. JavaScript-ში წამებისთვის გამოიყენეთ new Date(n * 1000). მილიწამებისთვის new Date(n). შემდეგ დააფორმატეთ როგორც UTC, ადგილობრივი ან სარტყელი.

Unix timestamp წამებშია თუ მილიწამებში?

შეიძლება ორივე. დაახლოებით 10 ციფრი ხშირად წამებია და დაახლოებით 13 მილიწამები, მაგრამ ეს ევრისტიკაა, არა წესი.

რატომ აჩვენებს ჩემი timestamp 1970-ს?

ჩვეულებრივ წამების მნიშვნელობა მილიწამებად წაიკითხეს. ნახეთ Unix Timestamp წამები vs მილიწამები: რატომ აჩვენებს თარიღი 1970-ს.

Unix timestamp ყოველთვის UTC-ია?

Epoch UTC-თან მიმართებითაა განსაზღვრული და რიცხვი ერთ წამს განსაზღვრავს. ჩვენების დროის სარტყელი ცალკეა. ეს არ არის შენახული «UTC დროის სარტყლის ველი».

Unix timestamp შეიცავს დროის სარტყელს?

არა. IANA იდენტიფიკატორს არ ატარებს. დროის სარტყელი წამის დაფორმატებისას გამოიყენება.

როგორ გადავიყვანო თარიღი Unix timestamp-ად?

UTC ISO სტრიქონიდან date.getTime() მილიწამებია; Math.floor(date.getTime() / 1000) წამებია.