Unix Timestamp វិនាទី និង មីលីវិនាទី៖ ហេតុអ្វីកាលបរិច្ឆេទបង្ហាញ 1970

អ្នកបានបម្លែង timestamp ទៅកាលបរិច្ឆេទ ហើយធ្លាក់ខែមករា 1970។ នាឡិកាកម្រខូច។ លេខត្រូវបានអានជាមីលីវិនាទី ទោះរក្សាទុកជាវិនាទី—ឬផ្ទុយ។

Unix timestamp ជាអ្វី?

Unix timestamp វាស់ពេលវេលាពី Unix epoch: 1970-01-01 00:00:00 UTC។ ជាទូទៅប្រើវិនាទីពេញ។ ពេលដដែលអាចរក្សាទុកជាមីលីវិនាទីផង (វិនាទី × 1,000)។ លេខខ្លួនឯងមិនបញ្ជាក់ឯកតា។

វិនាទី និង មីលីវិនាទី៖ ភាពខុសគ្នា ×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 បូកប្រហែលពីរសប្ដាហ៍។ គុណវិនាទីនឹង 1,000 មុនផ្ញើទៅ Date។

• វិនាទី
• 1720000000
• × 1000
• ↓
• មីលីវិនាទី
• 1720000000000

• តម្លៃវិនាទី
• ↓
• ចាត់ទុកខុសជាមីលីវិនាទី
• ↓
• កាលបរិច្ឆេទជិត 1970

តើ 10 ខ្ទង់ជាវិនាទី ហើយ 13 ជាមីលីវិនាទីទេ?

សម្រាប់កាលបរិច្ឆេទទំនើប 10 ខ្ទង់ច្រើនតែជាវិនាទី និង 13 ច្រើនតែជាមីលីវិនាទី។ នេះជាការណែនាំរហ័ស មិនមែនច្បាប់ផ្ទៀងផ្ទាត់។ ចំនួនខ្ទង់ផ្លាស់តាមចន្លោះពេល ហើយ API ខ្លះរក្សាមីក្រូវិនាទី ឬ ណាណូវិនាទី។ បញ្ជាក់ឯកតាពីឯកសារ ឬកាលបរិច្ឆេទដែលមានន័យ។

ហេតុអ្វីរឿងនេះកើតញឹកក្នុង JavaScript

ក្នុង JavaScript តម្លៃ Date លេខគឺមីលីវិនាទីពី epoch។ ប្រព័ន្ធខាងក្រោយ មូលដ្ឋានទិន្នន័យ និងឧបករណ៍ 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 timestamps ជាវិនាទី ឬ មីលីវិនាទី?

ជាទូទៅវិនាទី។ API វេបជាច្រើន និង Date ក្នុង JavaScript ប្រើមីលីវិនាទី។ តែងពិនិត្យថាប្រព័ន្ធនោះកត់ត្រាអ្វី។ ប្រព័ន្ធខ្លះប្រើមីក្រូវិនាទី ឬ ណាណូវិនាទី។

បម្លែងវិនាទីទៅមីលីវិនាទីយ៉ាងណា?

គុណនឹង 1,000។ 1720000000 វិនាទីស្មើ 1720000000000 មីលីវិនាទី។ ទិសផ្ទុយ ចែកនឹង 1,000។

ហេតុអ្វី Date ក្នុង JavaScript ប្រើមីលីវិនាទី?

timestamp លេខនៃ Date ក្នុង JavaScript កំណត់ជាមីលីវិនាទីពី Unix epoch។ ដូច្នេះ new Date(unixSeconds) ខុស បើ unixSeconds ជាវិនាទី Unix។

តើ timestamp 10 ខ្ទង់តែងតែជាវិនាទីទេ?

ទេ។ សម្រាប់កាលបរិច្ឆេទទំនើបច្រើនតែជាវិនាទី ហើយ 13 ខ្ទង់ច្រើនតែជាមីលីវិនាទី។ ចំនួនខ្ទង់ជាការណែនាំ មិនមែនច្បាប់។ បញ្ជាក់ពីឯកសារ ឬកាលបរិច្ឆេទដែលមានន័យ។

តើ Unix timestamp មានតំបន់ពេលវេលាទេ?

ទេ។ Unix timestamp គឺពេលមួយរាប់ពី 1970-01-01 00:00:00 UTC។ តំបន់ប៉ះពាល់ការបង្ហាញ មិនមែនលេខខ្លួនឯង។