Unix Timestamp წამები vs მილიწამები: რატომ აჩვენებს თარიღი 1970-ს

timestamp თარიღად გარდაქმენით და 1970 წლის იანვარში აღმოჩნდით. საათი თითქმის არასდროს არის გაფუჭებული. რიცხვი მილიწამებად წაიკითხეს, როცა წამებში იყო შენახული—ან პირიქით.

რა არის Unix timestamp?

Unix timestamp დროს ზომავს Unix epoch-იდან: 1970-01-01 00:00:00 UTC. ჩვეულებრივ მთელი წამებია. იგივე წამი მილიწამებშიც შეიძლება შეინახოს (წამები × 1 000). თავად რიცხვი ერთეულს არ წერს.

წამები vs მილიწამები: განსხვავება ×1 000

ერთი წამი არის 1 000 მილიწამი. შეადარეთ 1720000000 და 1720000000000. თუ პირველი წამებია და მეორე მილიწამები, ეს ერთი წამია. პირველი მილიწამებად წაიკითხეთ და თარიღი 1970-ისკენ ხტება.

ეს UTC შედეგები ზემოთა რიცხვებიდანაა გამოთვლილი, არა გამოცნობილი.

მნიშვნელობა	სავარაუდო ერთეული	ინტერპრეტაცია (UTC)
1720000000	წამები	თანამედროვე თარიღი წამებად: 2024-07-03 09:46:40 UTC
1720000000000	მილიწამები	იგივე წამი მილიწამებად: 2024-07-03 09:46:40 UTC
1720000000 როგორც მილიწამები	არასწორი ერთეული	თარიღი 1970-თან ახლოს: 1970-01-20 21:46:40 UTC

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

თუ წამების მნიშვნელობა მილიწამებად განიხილება, რიცხვი 1 000-ჯერ პატარაა საჭიროზე. JavaScript მაშინ Unix epoch-ის შემდეგ მხოლოდ მოკლე მონაკვეთს ითვლის და თარიღი 1970-ში რჩება:

const seconds = 1720000000;

new Date(seconds);
// 1970-01-20 21:46:40 UTC

new Date(seconds * 1000);
// 2024-07-03 09:46:40 UTC

ეს 1970 წლის თარიღი არის epoch პლუს დაახლოებით ორი კვირა. Date-ს გადაცემამდე წამები 1 000-ზე გაამრავლეთ.

• წამები
• 1720000000
• × 1000
• ↓
• მილიწამები
• 1720000000000

• წამების მნიშვნელობა
• ↓
• შეცდომით მილიწამებად მიჩნეული
• ↓
• თარიღი 1970-თან ახლოს

10 ციფრი წამებია და 13 მილიწამები?

თანამედროვე თარიღებზე 10 ციფრი ხშირად წამებია, 13 ხშირად მილიწამები. ეს სწრაფი მინიშნებაა, არა შემოწმების წესი. ციფრების რაოდენობა დროის დიაპაზონთან იცვლება; ზოგი API მიკროწამებს ან ნანოწამებს ინახავს. ერთეული დაადასტურეთ დოკუმენტაციით ან აზრიანი თარიღით.

რატომ ხდება ეს ასე ხშირად JavaScript-ში

JavaScript-ში რიცხვითი Date არის მილიწამები epoch-იდან. ბევრი backend, ბაზა და Unix ინსტრუმენტი ჯერ კიდევ წამებს ინახავს. წამების პირდაპირ Date-ში გადაცემა ხშირი შეცდომაა:

const unixSeconds = 1720000000;

const wrong = new Date(unixSeconds);
const correct = new Date(unixSeconds * 1000);

wrong 1970-თან ახლოსაა (1970-01-20 21:46:40 UTC). correct თანამედროვე წამია (2024-07-03 09:46:40 UTC).

სხვა სისტემები სხვა ერთეულებს იყენებენ

სხვა ენები, API და ბაზები შეიძლება წამებს ან მილიწამებს იყენებდნენ. ზოგი მიკროწამებს ან ნანოწამებს ინახავს. ნუ ჩათვლით, რომ ენა ყოველთვის ერთ ერთეულს იყენებს—ნახეთ დოკუმენტაცია. თუ რიცხვი JSON-შია, JSON-ის ფორმატირება / Diff ველს კითხვადს ხდის; ერთეულს მაინც არ გეტყვით.

როგორ გავიგო, რომელი ერთეულია ჩემი timestamp?

გაიარეთ ეს შემოწმებები რიგით. მხოლოდ ციფრების რაოდენობა არ კმარა.

1. ნახეთ API-ის ან მონაცემთა ბაზის დოკუმენტაცია.
2. შეხედეთ ციფრების სავარაუდო რაოდენობას.
3. შეადარეთ მნიშვნელობა სარწმუნო თანამედროვე timestamp-ს.
4. გამოცადეთ მნიშვნელობა წამებად და მილიწამებად.
5. შეამოწმეთ, აქვს თუ არა მიღებულ თარიღს აზრი.

თუ ერთი ინტერპრეტაცია 1970-ზე ეცემა და მეორე — თარიღზე, რომელსაც იცნობთ, მიზეზი ერთეულების შეუსაბამობაა.

ხშირი შეცდომები Unix timestamp-თან

• წამები მილიწამებად წაკითხული. თარიღი 1970-ისკენ იშლება, როგორც ზემოთ მაგალითში.
• მილიწამები წამებად წაკითხული. თარიღი შორს მომავალში ხტება, ან გარდაქმნა ვერ ხერხდება.
• 1 000-ზე ორჯერ გამრავლება. უკვე მილიწამებიანი მნიშვნელობა უზარმაზარი ხდება და თარიღი საუკუნეებით წინ მიდის.
• 1 000-ზე ორჯერ გაყოფა. წამების მნიშვნელობა ისევ იკუმშება, ისევ 1970-თან ახლოს.
• დროის სარტყლის დადანაშაულება. სარტყელი შეიძლება საათები ან კალენდრის დღე გადაანაცვლოს. თანამედროვე timestamp-ს 1970-ში არ გადაიყვანს.
• ფორმატირებული თარიღის Unix timestamp-ად მიჩნევა. მნიშვნელობა როგორიცაა 2024-07-03T09:46:40Z არ არის epoch რიცხვი. გარჩიეთ როგორც თარიღი, არა როგორც წამები.

დროის სარტყელი იწვევს 1970-ის პრობლემას?

ჩვეულებრივ არა. სარტყელი შეიძლება შეცვალოს ნაჩვენები საათი და შუაღამესთან კალენდრის თარიღი. თანამედროვე Unix timestamp-ს 1970-ად არ აქცევს. თუ შედეგი 1970-ია, ჯერ წამები მილიწამების წინააღმდეგ შეამოწმეთ.

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

NEXNARA თარიღისა და დროის გადამყვანი შეუძლია Unix timestamp-ის გარდაქმნა ბრაუზერში.

ჩასვით Unix წამები ან მილიწამები, გამოიყენეთ მიმდინარე timestamp, ნახეთ UTC და ადგილობრივი დრო, გარდაქმენით სარტყლები და დააფორმატეთ თარიღი. ავტომატური ამოცნობა ხშირად 10 ციფრს წამებად და 13-ს მილიწამებად იღებს; ერთეული მაინც შეგიძლიათ აირჩიოთ.

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

Unix timestamp უნდა შეამოწმოთ? გახსენით თარიღისა და დროის გადამყვანი და შეადარეთ წამები მილიწამებს.

FAQ

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

ხშირად ეს წამებია, რომლებიც მილიწამებად წაიკითხეს. JavaScript გაცილებით პატარა რიცხვს ამუშავებს, ამიტომ თარიღი 1970-01-01 00:00:00 UTC-ის შემდეგ ეცემა. წამები 1 000-ზე გაამრავლეთ და ისევ გარდაქმენით.

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

ჩვეულებრივ წამები. ბევრი ვებ-API და JavaScript Date მილიწამებს იყენებს. ყოველთვის ნახეთ, რას აფიქსირებს ის სისტემა. ზოგი მიკროწამებს ან ნანოწამებს იყენებს.

როგორ გადავიყვანო წამები მილიწამებში?

გაამრავლეთ 1 000-ზე. 1720000000 წამი არის 1720000000000 მილიწამი. პირიქით, გაყავით 1 000-ზე.

რატომ იყენებს JavaScript Date მილიწამებს?

JavaScript-ში Date-ის რიცხვითი timestamp განსაზღვრულია როგორც მილიწამები Unix epoch-იდან. ამიტომ new Date(unixSeconds) არასწორია, როცა unixSeconds Unix წამებია.

10-ნიშნა timestamp ყოველთვის წამებია?

არა. თანამედროვე თარიღებზე ხშირად კი, და 13 ციფრი ხშირად მილიწამებია. ციფრების რაოდენობა მინიშნებაა, არა წესი. დაადასტურეთ დოკუმენტაციით ან აზრიანი თარიღით.

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

არა. Unix timestamp არის წამი, დათვლილი 1970-01-01 00:00:00 UTC-იდან. სარტყლები ჩვენებას ცვლიან, არა თავად რიცხვს.