• UTC: เวลาบนเส้นเมริเดียนที่สำคัญเรียกว่าเวลาพิกัดสากล ความไม่ตรงกันของตัวย่อเกิดจากความต้องการความเป็นสากลในทุกภาษา
• GMT: ก่อนหน้านี้ เวลามาตรฐานกรีนิช (GMT) ถูกใช้แทน UTC เนื่องจากเส้นเมริเดียนที่สำคัญได้รับเลือกให้ผ่านหอดูดาวหลวงแห่งกรีนิช
• เขตเวลาอื่นสามารถเขียนเป็นออฟเซ็ตจาก UTC ได้ ตัวอย่างเช่น เวลามาตรฐานทางตะวันออกของออสเตรเลีย (EST) เขียนเป็น UTC + 1000 ซึ่งหมายความว่า 10:00 UTC คือ 20:00 EST ในวันเดียวกัน
• เวลาฤดูร้อนไม่กระทบ UTC นี่เป็นเพียงการตัดสินใจทางการเมืองเพื่อเปลี่ยนเขตเวลา (ออฟเซ็ตจาก UTC) ตัวอย่างเช่น GMT ยังคงใช้งานอยู่: เป็นเวลาประจำชาติของอังกฤษในฤดูหนาว ในฤดูร้อนจะกลายเป็น BST
• วินาทีกระโดด: ตามอนุสัญญาระหว่างประเทศ UTC จะถูกเก็บไว้ไม่เกิน 0.9 วินาทีจากความเป็นจริงทางกายภาพ (UT1 ซึ่งวัดในเวลาสุริยะ) โดยแนะนำ "วินาทีกระโดด" เมื่อสิ้นสุดนาทีสุดท้ายของปีใน UTC หรือนาทีสุดท้าย ของเดือนมิถุนายน
• วินาทีอธิกสุรทินไม่จำเป็นต้องประกาศ (โดยนักดาราศาสตร์) นานกว่า 6 เดือนก่อนที่จะมีการแนะนำ นี่เป็นปัญหาหากคุณต้องการการวางแผนประเภทใดก็ตามที่มีความแม่นยำเพียง 1 วินาทีเป็นเวลานานกว่า 6 เดือน
• เวลายูนิกซ์: วัดโดยจำนวนวินาทีตั้งแต่ “ยุค” (ต้นปี 1970 UTC) เวลา Unix ไม่ได้รับผลกระทบจากโซนเวลาหรือเวลาออมแสง
• ตามมาตรฐาน POSIX.1 เวลา Unix ควรจัดการกับวินาทีกระโดดโดยทำซ้ำวินาทีก่อนหน้าเช่น: 59.00 59.25 59.50 59.75 59.00 ← ทำซ้ำ 59.25 59.50 59.75 00.00 ←เพิ่มขึ้น 00.25 นี่คือการแลกเปลี่ยน: คุณไม่สามารถแสดงวินาทีกระโดด ในนาฬิการะบบของคุณและรับประกันว่าเวลาของคุณจะย้อนกลับ ในทางกลับกัน ทุกวันคือ 86,400 วินาที และคุณไม่จำเป็นต้องมีตารางวินาทีอธิกวินาทีในอดีตและในอนาคตเพื่อแปลงเวลา Unix เป็นชั่วโมง นาที วินาทีที่มนุษย์อ่านได้
• คาดว่า ntpd จะลองใหม่อีกครั้งหลังจากได้รับ leap bits จากเซิร์ฟเวอร์ upstream time แต่ฉันไม่เห็นว่ามันทำอะไรเลย: ระบบจะไปหนึ่งวินาทีในอนาคต จากนั้นค่อย ๆ คืบคลานกลับไปยังเวลาที่ถูกต้อง

สิ่งที่โปรแกรมเมอร์ทุกคนควรรู้เกี่ยวกับเวลา

• เขตเวลาหมายถึงระดับการนำเสนอ
  รหัสส่วนใหญ่ของคุณไม่ควรจัดการกับเขตเวลาหรือเวลาท้องถิ่น มันควรผ่านเวลา Unix เหมือนเดิม
• เมื่อวัดเวลา ให้วัดเวลา Unix นี่คือ UTC ง่ายที่จะได้รับมัน (โดยฟังก์ชั่นระบบ) ไม่มีโซนเวลาหรือเวลาออมแสง (และวินาทีกระโดด)
• เมื่อคุณจัดเก็บเวลา ให้จัดเก็บเวลา Unix นี่คือตัวเลขหนึ่ง
• หากคุณต้องการรักษาเวลาที่มนุษย์อ่านได้ (เช่น ในบันทึก) ให้พยายามเก็บไว้ ด้วยกันด้วยเวลา Unix ไม่ใช่ แทน.
• เมื่อแสดงเวลา ให้รวมการชดเชยเขตเวลาเสมอ รูปแบบเวลาที่ไม่มีออฟเซ็ตนั้นไร้ประโยชน์
• นาฬิกาของระบบไม่ถูกต้อง
• คุณออนไลน์? นาฬิการะบบของเครื่องอื่น ๆ ทั้งหมดไม่ถูกต้องในทางที่ต่างกัน
• นาฬิกาของระบบสามารถและจะกระโดดไปมาในเวลาอันเนื่องมาจากสิ่งที่อยู่นอกเหนือการควบคุมของคุณ โปรแกรมของคุณต้องได้รับการออกแบบเพื่อความอยู่รอด
• อัตราส่วนของจำนวนวินาที นาฬิการะบบถึงปริมาณ จริงวินาทีไม่ถูกต้องและอาจแตกต่างกันไป ส่วนใหญ่ขึ้นอยู่กับอุณหภูมิ
• อย่าสุ่มสี่สุ่มห้าใช้ gettimeofday () หากคุณต้องการนาฬิกาที่ซ้ำซากจำเจ (เพิ่มขึ้นเรื่อยๆ) ให้ดูที่ clock_gettime () [ตัวเลือก Java: ใช้ System.nanoTime () แทน System.currentTimeMillis ()]
• ntpd สามารถเปลี่ยนเวลาของระบบได้สองวิธี:
  • ขั้นตอน: นาฬิกากระโดดไปข้างหน้าหรือย้อนกลับไปยังเวลาที่ถูกต้องทันที
  • ข้อเหวี่ยง: เปลี่ยนความถี่ของนาฬิการะบบเพื่อให้เคลื่อนไปยังเวลาที่ถูกต้องอย่างช้าๆ
  การบิดจะดีกว่าเพราะจะสร้างความเสียหายน้อยกว่า แต่มีประโยชน์สำหรับการแก้ไขส่วนต่างเล็กน้อยเท่านั้น

กรณีพิเศษ

• เวลาผ่านไปในอัตราหนึ่งวินาทีต่อวินาทีสำหรับผู้สังเกตทั้งหมด ความถี่ของนาฬิการะยะไกลที่สัมพันธ์กับผู้สังเกตขึ้นอยู่กับความเร็วและแรงโน้มถ่วง นาฬิกาภายในดาวเทียม GPS ถูกปรับเพื่อเอาชนะผลกระทบของสัมพัทธภาพ
• MySQL เก็บคอลัมน์ DATETIME เป็นค่าที่บรรจุด้วยตัวเลข "YYYYMMDD HHMMSS" หากคุณกังวลเกี่ยวกับการจัดเก็บการประทับเวลา ให้เก็บไว้เป็นจำนวนเต็มและใช้ฟังก์ชัน UNIX_TIMESTAMP () และ FROM_UNIXTIME () เพื่อแปลง

เพราะ ไม่มีเครื่องมือในตัวในน้ำมันดีเซล เราสร้างสคริปต์ต่อไปนี้: #! / bin / sh truss date 2> & 1 | grep ^ time | awk "(print $ 3;)" exit $? หรือ nawk "BEGIN (พิมพ์ srand ())" หรือใน perl: perl -e "print time" \ n ";" ค้นหาวันที่แก้ไขไฟล์: truss -v lstat -t lstat ls -l file.txt 2> & 1 1> / dev / null | grep "mt \ = \" | awk "(พิมพ์ $ 9;)"

วิธีรับเวลา Unix ใน ...

Perl	เวลา
PHP	เวลา ()
ทับทิม	Time.now (หรือ Time.new) การส่งออก: Time.now.to_i
Python	นำเข้าเวลาก่อน จากนั้น time.time ()
Java	ยุคยาว = System.currentTimeMillis () / 1000;
Microsoft .NET C #	ยุค = (DateTime.Now.ToUniversalTime () เห็บ - 621355968000000000) / 10000000;
VBScript / ASP	DateDiff ("s", "01/01/1970 00:00:00", ตอนนี้ ())
แอร์ลัง	ปฏิทิน: datetime_to_gregorian_seconds (ปฏิทิน: now_to_universal_time (ตอนนี้ ())) - 719528 * 24 * 3600
MySQL	เลือก unix_timestamp (ตอนนี้ ())
PostgreSQL	แยก SELECT (ยุคจากตอนนี้ ());
SQL Server	เลือก DATEDIFF (s, " 1970-01-01 00:00:00", GETUTCDATE ())
JavaScript	Math.round (วันที่ใหม่ () GetTime () / 1000.0) getTime () ส่งกลับเวลาเป็นมิลลิวินาที
Unix / Linux	วันที่ +% s
OS . อื่นๆ	บรรทัดคำสั่ง: perl -e "เวลาพิมพ์" (หากติดตั้ง Perl ในระบบของคุณ)

การแปลงวันที่เป็นเวลา Unix เป็น ...

PHP	mktime ( นาฬิกา, นาที, วินาที, เดือน, วัน, ปี)
ทับทิม	เวลาท้องถิ่น ( ปี, เดือน, วัน, นาฬิกา, นาที, วินาที, ใช้c) (หรือ Time.gm สำหรับเอาต์พุต GMT / UTC) เพื่อแสดงให้เพิ่ม .to_i
Python	นำเข้าเวลาก่อน จากนั้น int (time.mktime (time.strptime ("2000-01-01 12:34:00", "% Y-% m-% d% H:% M:% S"))
Java	ยุคยาว = java.text.SimpleDateFormat ใหม่ ("dd / MM / yyyy HH: mm: ss") parse ("01/01/1970 01:00:00");
VBScript / ASP	DateDiff ("s", "01/01/1970 00:00:00", ช่องวันที่)
MySQL	เลือก unix_timestamp ( เวลา) รูปแบบเวลา: YYYY-MM-DD HH: MM: SS หรือ YYMMDD หรือ YYYYMMDD
PostgreSQL	แยก SELECT (ยุคจากวันที่ ("2000-01-01 12:34")); ด้วยการประทับเวลา: SELECT EXTRACT (EPOCH จาก TIMESTAMP พร้อมโซนเวลา "2001-02-16 20: 38: 40-08"); ด้วยช่วงเวลา: SELECT EXTRACT (EPOCH FROM INTERVAL "5 วัน 3 ชั่วโมง");
SQL Server	เลือกวันที่ (s, " 1970-01-01 00:00:00", ช่องวันที่)
Unix / Linux	วันที่ +% s -d "1 ม.ค. 2523 00:00:01"

การแปลงเวลา Unix เป็นวันที่มนุษย์สามารถอ่านได้ ...

PHP	วันที่ ( รูปแบบ, เวลายูนิกซ์);
ทับทิม	เวลา.at ( เวลายูนิกซ์)
Python	เวลานำเข้าก่อน จากนั้น time.strftime ("% a,% d% b% Y% H:% M:% S +0000", time.localtime ( เวลายูนิกซ์)) แทนที่ time.localtime ด้วย time.gmtime สำหรับวันที่ GMT
Java	วันที่สตริง = java.text.SimpleDateFormat ใหม่ ("dd / MM / yyyy HH: mm: ss") รูปแบบ (java.util.Date ใหม่ ( เวลายูนิกซ์*1000));
VBScript / ASP	วันที่เพิ่ม ("s", เวลายูนิกซ์, "01/01/1970 00:00:00")
PostgreSQL	เลือกการประทับเวลาด้วยเขตเวลา "ยุค" + เวลายูนิกซ์* ช่วงเวลา "1 วินาที";
MySQL	from_unixtime ( เวลายูนิกซ์, ไม่จำเป็น, รูปแบบเอาต์พุต) รูปแบบเอาต์พุตมาตรฐาน YYY-MM-DD HH: MM: SS
SQL Server	วันที่ (s, เวลายูนิกซ์, "1970-01-01 00:00:00")
Microsoft Excel	= (A1/86400) + 25569 ผลลัพธ์จะอยู่ในเขตเวลา GMT สำหรับเขตเวลาอื่น: = ((A1 +/- ความแตกต่างของเวลาสำหรับโซน) / 86400) + 25569
ลินุกซ์	วันที่ -d @ 1190000000
OS . อื่นๆ	บรรทัดคำสั่ง: perl -e "พิมพ์สเกลาร์ (เวลาท้องถิ่น ( เวลายูนิกซ์)) "(หากติดตั้ง Perl) แทนที่" เวลาท้องถิ่น "ด้วย" gmtime "สำหรับเขตเวลา GMT / UTC

Unix time หรือ Unix epoch คืออะไร (Unix epoch หรือ Unix time หรือ POSIX time หรือ Unix timestamp)

เวลา UNIX หรือ POSIX-time (เวลา Unix ภาษาอังกฤษ) - วิธีการเข้ารหัสเวลา ยอมรับใน UNIX และระบบปฏิบัติการอื่นๆ ที่เข้ากันได้กับ POSIX
จุดเริ่มต้นของการนับถอยหลังถือเป็นเวลาเที่ยงคืน (UTC) ตั้งแต่วันที่ 31 ธันวาคม 2512 ถึง 1 มกราคม 2513 เวลาจากช่วงเวลานั้นเรียกว่า "ยุค UNIX" (English Unix Epoch)
เวลา UNIX นั้นสอดคล้องกับ UTC โดยเฉพาะอย่างยิ่ง เมื่อมีการประกาศวินาทีอธิกสุรทิน UTC ตัวเลขที่สองที่สอดคล้องกันจะถูกทำซ้ำ
วิธีการจัดเก็บเวลาในรูปแบบจำนวนวินาทีนั้นสะดวกมากในการเปรียบเทียบวันที่ (แม่นยำถึงวินาที) เช่นเดียวกับการจัดเก็บวันที่: หากจำเป็น พวกเขาสามารถแปลงเป็นรูปแบบที่อ่านได้ วันที่และเวลาในรูปแบบนี้ใช้พื้นที่น้อยมาก (4 หรือ 8 ไบต์ ขึ้นอยู่กับขนาดของคำในเครื่อง) ดังนั้นจึงเหมาะสมที่จะใช้สำหรับจัดเก็บวันที่จำนวนมาก ข้อเสียด้านประสิทธิภาพอาจเกิดขึ้นได้หากคุณเข้าถึงองค์ประกอบวันที่บ่อยมาก เช่น หมายเลขเดือน และอื่นๆ แต่ในกรณีส่วนใหญ่ การจัดเก็บเวลาเป็นค่าเดียวจะมีประสิทธิภาพมากกว่าชุดของฟิลด์

แปลงยุค Unix เป็นวันที่มนุษย์อ่านได้

Unix วันที่เริ่มต้นและสิ้นสุดของปี เดือน หรือวัน

แปลงวินาทีเป็นวัน ชั่วโมง และนาที

วิธีรับเวลา Unix ใน ...

Perl	เวลา
PHP	เวลา ()
ทับทิม	Time.now (หรือ Time.new) การส่งออก: Time.now.to_i
Python	นำเข้าเวลาก่อน จากนั้น time.time ()
Java	ยุคยาว = System.currentTimeMillis () / 1000;
Microsoft .NET C #	ยุค = (DateTime.Now.ToUniversalTime () เห็บ - 621355968000000000) / 10000000;
VBScript / ASP	DateDiff ("s", "01/01/1970 00:00:00", ตอนนี้ ())
แอร์ลัง	ปฏิทิน: datetime_to_gregorian_seconds (ปฏิทิน: now_to_universal_time (ตอนนี้ ())) - 719528 * 24 * 3600
MySQL	เลือก unix_timestamp (ตอนนี้ ())
PostgreSQL	แยก SELECT (ยุคจากตอนนี้ ());
SQL Server	เลือก DATEDIFF (s, " 1970-01-01 00:00:00", GETUTCDATE ())
JavaScript	Math.round (วันที่ใหม่ () GetTime () / 1000.0) getTime () ส่งกลับเวลาเป็นมิลลิวินาที
Unix / Linux	วันที่ +% s
OS . อื่นๆ	บรรทัดคำสั่ง: perl -e "เวลาพิมพ์" (หากติดตั้ง Perl ในระบบของคุณ)

การแปลงวันที่เป็นเวลา Unix เป็น ...

PHP	mktime ( นาฬิกา, นาที, วินาที, เดือน, วัน, ปี)
ทับทิม	เวลาท้องถิ่น ( ปี, เดือน, วัน, นาฬิกา, นาที, วินาที, ใช้c) (หรือ Time.gm สำหรับเอาต์พุต GMT / UTC) เพื่อแสดงให้เพิ่ม .to_i
Python	นำเข้าเวลาก่อน จากนั้น int (time.mktime (time.strptime ("2000-01-01 12:34:00", "% Y-% m-% d% H:% M:% S"))
Java	ยุคยาว = java.text.SimpleDateFormat ใหม่ ("dd / MM / yyyy HH: mm: ss") parse ("01/01/1970 01:00:00");
VBScript / ASP	DateDiff ("s", "01/01/1970 00:00:00", ช่องวันที่)
MySQL	เลือก unix_timestamp ( เวลา) รูปแบบเวลา: YYYY-MM-DD HH: MM: SS หรือ YYMMDD หรือ YYYYMMDD
PostgreSQL	แยก SELECT (ยุคจากวันที่ ("2000-01-01 12:34")); ด้วยการประทับเวลา: SELECT EXTRACT (EPOCH จาก TIMESTAMP พร้อมโซนเวลา "2001-02-16 20: 38: 40-08"); ด้วยช่วงเวลา: SELECT EXTRACT (EPOCH FROM INTERVAL "5 วัน 3 ชั่วโมง");
SQL Server	เลือกวันที่ (s, " 1970-01-01 00:00:00", ช่องวันที่)
Unix / Linux	วันที่ +% s -d "1 ม.ค. 2523 00:00:01"

การแปลงเวลา Unix เป็นวันที่มนุษย์สามารถอ่านได้ ...

PHP	วันที่ ( รูปแบบ, เวลายูนิกซ์);
ทับทิม	เวลา.at ( เวลายูนิกซ์)
Python	เวลานำเข้าก่อน จากนั้น time.strftime ("% a,% d% b% Y% H:% M:% S +0000", time.localtime ( เวลายูนิกซ์)) แทนที่ time.localtime ด้วย time.gmtime สำหรับวันที่ GMT
Java	วันที่สตริง = java.text.SimpleDateFormat ใหม่ ("dd / MM / yyyy HH: mm: ss") รูปแบบ (java.util.Date ใหม่ ( เวลายูนิกซ์*1000));
VBScript / ASP	วันที่เพิ่ม ("s", เวลายูนิกซ์, "01/01/1970 00:00:00")
PostgreSQL	เลือกการประทับเวลาด้วยเขตเวลา "ยุค" + เวลายูนิกซ์* ช่วงเวลา "1 วินาที";
MySQL	from_unixtime ( เวลายูนิกซ์, ไม่จำเป็น, รูปแบบเอาต์พุต) รูปแบบเอาต์พุตมาตรฐาน YYY-MM-DD HH: MM: SS
SQL Server	วันที่ (s, เวลายูนิกซ์, "1970-01-01 00:00:00")
Microsoft Excel	= (A1/86400) + 25569 ผลลัพธ์จะอยู่ในเขตเวลา GMT สำหรับเขตเวลาอื่น: = ((A1 +/- ความแตกต่างของเวลาสำหรับโซน) / 86400) + 25569
ลินุกซ์	วันที่ -d @ 1190000000
OS . อื่นๆ	บรรทัดคำสั่ง: perl -e "พิมพ์สเกลาร์ (เวลาท้องถิ่น ( เวลายูนิกซ์)) "(หากติดตั้ง Perl) แทนที่" เวลาท้องถิ่น "ด้วย" gmtime "สำหรับเขตเวลา GMT / UTC

เครื่องมือ "Unixtime Converter" มีไว้เพื่ออะไร?

อย่างแรกเลย เครื่องมือนี้จะเป็นประโยชน์สำหรับผู้ดูแลเว็บที่จัดการกับวันที่จำนวนมากหรือมักจะอ้างถึงองค์ประกอบในงานของตน การใช้เครื่องมือ "Unixtime Converter" คุณสามารถแปลงเวลา Unix เป็นวันที่ที่ใช้งานง่าย (และในทางกลับกัน) ค้นหาเวลายุค Unix ปัจจุบันและรับเวลา Unix ใน ภาษาที่แตกต่างกันการเขียนโปรแกรม DBMS และระบบปฏิบัติการ

Unix Time คืออะไร?

ยุค Unix (ยุค Unix) เริ่มขึ้นในคืนวันที่ 31 ธันวาคม พ.ศ. 2512 ถึง 1 มกราคม พ.ศ. 2513 เป็นวันที่ที่ใช้เป็นจุดเริ่มต้นสำหรับเวลา "คอมพิวเตอร์" ซึ่งคำนวณเป็นวินาทีและใช้พื้นที่ดิสก์น้อยมาก - เพียง 4 หรือ 8 ไบต์ ด้วยวิธีการเข้ารหัสนี้ โปรแกรมเมอร์สามารถ "ซ่อน" วันที่ใดก็ได้ในตัวเลขเดียว และแปลงกลับเป็นรูปแบบที่ผู้ใช้เข้าใจได้อย่างง่ายดาย

เวลา Unix (เรียกอีกอย่างว่าเวลา Unix หรือเวลา POSIX) สะดวกในการใช้งานในระบบปฏิบัติการต่างๆ และภาษาโปรแกรมมิ่ง เนื่องจากจะแสดงเป็นค่าเดียว ไม่ใช่จำนวนฟิลด์ที่แน่นอนซึ่งกินพื้นที่ นอกจากนี้ เวลา UNIX ยังสอดคล้องกับมาตรฐาน UTC อย่างสมบูรณ์ (รวมถึงในปีอธิกสุรทิน) - ในกรณีนี้ ค่าวินาทีที่สอดคล้องกันจะทำซ้ำได้ง่ายๆ

คำศัพท์ยูนิกซ์

คำสองสามคำเกี่ยวกับเงื่อนไข

ดังนั้น, เวลายูนิกซ์(หรือเวลา POSIX) คือจำนวนวินาทีที่ผ่านไปตั้งแต่เที่ยงคืนของวันที่ 1 มกราคม 1970 จนถึงปัจจุบัน

Unix Timestamp(การประทับเวลา) คือเวลาที่ "คงที่" หรืออีกนัยหนึ่งคือวันที่ที่ระบุเป็นตัวเลข

UTC(เวลาสากลเชิงพิกัด) คือเวลาสากลเชิงพิกัดซึ่ง "คงที่" ที่เส้นเมริเดียนที่สำคัญและนับเขตเวลาทางภูมิศาสตร์

ระบบ "ทนทาน" แค่ไหน?

ในเวลาเพียงไม่กี่ทศวรรษ คือในวันที่ 19 มกราคม 2038 เวลา 03:14:08 UTC เวลา Unix จะถึงค่า 2147483648 และระบบคอมพิวเตอร์สามารถตีความตัวเลขนี้เป็นค่าลบได้ กุญแจสำคัญในการแก้ปัญหานี้อยู่ที่การใช้ตัวแปร 64 บิต (แทนที่จะเป็น 32 บิต) เพื่อจัดเก็บเวลา ในกรณีนี้ สต็อคค่าตัวเลขของเวลา Unix จะเพียงพอสำหรับมนุษยชาติอีก 292 พันล้านปี ไม่เลวใช่มั้ย

เวลา Unix เป็นหนึ่งเดียวสำหรับทุกคน

หากคุณอาศัยอยู่ในลอนดอนหรือซานฟรานซิสโก และเพื่อนของคุณอยู่ในมอสโก คุณสามารถ "ซิงโครไนซ์นาฬิกา" โดยใช้เวลา Unix: ระบบนี้อยู่ใน ช่วงเวลานี้เวลาเป็นหนึ่งเดียวสำหรับทั้งโลก โดยธรรมชาติแล้วหากตั้งเวลาบนเซิร์ฟเวอร์ถูกต้อง และด้วยเครื่องมือ "ตัวแปลง Unixtime"การแปลงนี้จะใช้เวลาเสี้ยววินาที

เครื่องมือนี้จำเป็นในการแปลงวันที่จากรูปแบบ Unix TimeStamp เป็นวันที่มนุษย์สามารถอ่านได้ และในทางกลับกัน

เวลา Unix คืออะไรและใช้ทำอะไร?เพื่อให้เข้าใจว่าสิ่งนี้ใช้สำหรับอะไร ฉันจะเริ่มด้วย แนวคิดทั่วไปเวลา Unix คืออะไร

เวลายูนิกซ์ (หรือ TimeStamp ซึ่งแปลเป็นภาษารัสเซียแปลว่า "ประทับเวลา" และมีความหมายเหมือนกัน)คือจำนวนวินาทีตั้งแต่วันที่ 1 มกราคม พ.ศ. 2513 นั่นคือ Unix TimeStamp ที่ 01/01/1970 00:00:00 น. เท่ากับ 0 หลังจาก 2 นาที (120 วินาที) เวลา Unix จะเท่ากับ 120 แล้ว ตัวอย่างเช่น วันต่อมา (01/02/1970 00:00:00) เวลา Unix เท่ากับ 86400 เนื่องจากผ่านไป 60 * 60 * 24 = 86400 วินาที ขณะนี้ Unix Time Stamp อยู่ที่ 1566148027 และจำนวนเพิ่มขึ้นอย่างต่อเนื่องเนื่องจากวินาทีที่ติ๊กอย่างต่อเนื่อง

แต่ทำไมใช้มัน?ประเด็นคือ Unix TimeStamp สะดวกในการใช้สำหรับจัดเก็บและจัดการวันที่ระหว่างการเขียนโปรแกรม ฉันจะไม่ลงรายละเอียด แต่ในระยะสั้น ตัวเลขจะสะดวกกว่าในการอ่านและเปรียบเทียบมากกว่าสตริงที่มีอักขระ "ซ้าย" นั่นคือเหตุผลที่นักพัฒนาส่วนใหญ่ใช้ Unix TimeStamp เพื่อทำงานกับวันที่ในโปรเจ็กต์ของพวกเขา และในฐานข้อมูล เรามักจะเห็นตัวเลขจำนวนมากในช่อง "วันที่" ซึ่งดูไม่เหมือนวันที่เลย

นี่คือที่ที่เครื่องมือนี้มีประโยชน์ ด้วยสิ่งนี้ คุณสามารถแปล "จำนวนมากจากฐานข้อมูล" นี้เป็นวันที่ที่มนุษย์อ่านได้ นอกจากนี้ คุณยังสามารถทำสิ่งที่ตรงกันข้ามและเปลี่ยนวันที่ใดๆ ให้เป็น Unix TimeStamp ได้อีกด้วย นี่คือความเป็นไปได้ของตัวแปลงนี้

ปัญหาปี 2038

อย่างที่บอก ตัวเลข Unix TimeStampทุกวินาทีจะเพิ่มขึ้น 1 ไม่ช้าก็เร็ว ขีดจำกัดของตัวเลขนี้น่าจะมาและจะถึงในปี 2038 เท่านั้น ประเด็นคือจำนวนสูงสุดในระบบปฏิบัติการ 32 บิตที่แพร่หลายในช่วงต้นศตวรรษที่ 21 คือ 2 31 นี่คือตัวเลขที่ Unix TimeStamp จะไปถึงในปี 2038

→ พบวิธีแก้ไขปัญหานี้แล้ว เพื่อให้แน่ใจว่าในปี 2038 ไซต์จะไม่หยุดการนับเวลาอย่างถูกต้อง ก็เพียงพอแล้วที่จะใช้ 64-บิต ระบบปฏิบัติการบนโฮสต์ / VDS / เซิร์ฟเวอร์เฉพาะไม่ใช่ 32 บิต ด้วยขีดความสามารถของคอมพิวเตอร์ที่เพิ่มขึ้นอย่างแข็งขันและต้นทุนที่ลดลง ทุกอย่างเป็นไปตามข้อเท็จจริงที่ว่าภายในปี 2038 บริการส่วนใหญ่อย่างท่วมท้นในด้านการจัดหาพื้นที่สำหรับไซต์จะให้บริการบนพื้นฐานของระบบปฏิบัติการ 64 บิต อย่างไรก็ตาม ในระบบ 64 บิต ปัญหาดังกล่าวจะไม่ส่งผลกระทบต่อเราอย่างน้อย 292 พันล้านปี ซึ่งเพียงพอสำหรับการนับ ปัญหาปี 2038แก้ไข

สำหรับผู้อ่าน Lifeexample เท่านั้นที่เป็นไปได้ที่จะเปิดร้านค้าออนไลน์บน Moguta.CMS พร้อมส่วนลด 15%

เวลา Unix และ Unix Timestamp (MySQL, PHP, JavaScript)

สวัสดีผู้อ่านบล็อกที่รัก ในบทความนี้ฉันอยากจะบอกคุณว่าคืออะไร เวลายูนิกซ์และ Unix Timestamp... โปรแกรมเมอร์มักจะรวมแนวคิดเหล่านี้เป็นหนึ่งเดียว แต่สิ่งนี้ไม่เป็นความจริงทั้งหมด นอกจากนี้ บทความนี้ยังมีหมายเหตุที่มีประโยชน์มากมายเกี่ยวกับการทำงานกับ Unix Timestamp ใน PHP, MySQL และ JavaScript

ทำไม Unix Time ถึงเริ่มในวันที่ 1 มกราคม 1970

ประเด็นคือเวลา Unix เริ่มนับยุค Unix ด้วยการเปิดตัวครั้งแรก ระบบ UNIX... ระบบแรกของประเภทนี้ถูกสร้างขึ้นในปี พ.ศ. 2512 ดังนั้นนักพัฒนาจึงใช้วันที่ตั้งแต่วันที่ 1 มกราคม พ.ศ. 2513 เวลาเที่ยงคืน UTC ( UTC).

มาทำความเข้าใจว่าเวลา Unix และ Unix Timestamp มีไว้เพื่ออะไร และให้แนวคิดที่ชัดเจน

Unix Timestampเป็นการประทับเวลาซึ่งเป็นลำดับของอักขระแทนจำนวนวินาทีที่ผ่านไปตั้งแต่วันที่ 1 มกราคม พ.ศ. 2513

ฉันจะพยายามยกตัวอย่างเพื่อชี้แจงความแตกต่างระหว่างแนวคิดทั้งสองนี้

ในขณะที่ฉันเขียนโพสต์นี้ เวลายูนิกซ์มันเท่ากัน 1346765877 .

ในขณะที่อ่าน โดยคุณ ข้อมูลนี้ บันทึกของเวลา ( 1346765877 ) เป็นป้ายกำกับอยู่แล้ว - Unix Timestamp! โดยการแปลงการประทับเวลานี้ให้อยู่ในรูปแบบที่อ่านได้ เราจะได้วันที่ 04-09-2012 และเวลา 17:37:57 น.

บอกตามตรงว่าไม่มีความรู้สึกพิเศษในการแยกแนวคิดทั้งสองในความคิดของฉัน แต่ก็ยังมีประโยชน์ที่จะมีความคิดว่าอะไรเป็นองค์ประกอบ เวลายูนิกซ์และยังมีประโยชน์ที่จะเข้าใจว่าจำนวนวินาทีสูงสุดที่เป็นไปได้ตั้งแต่ปี 1970 มีขีดจำกัด!

จุดจบของยุค Unix จะมาถึงในปี 2038

ข้อเท็จจริง:ขีดสุด เลขฐานสองบนระบบ 32 บิตเป็นตัวเลข 01111111 11111111 11111111 11111111 แปลงเป็นระบบทศนิยม เราได้หมายเลข 2147483647

19 มกราคม 2038 03:14:08 เวลาจะมาถึงเมื่อจำนวนวินาทีที่ผ่านไปตั้งแต่เริ่มต้นยุค Unix จะเกินจำนวนสูงสุดที่มีอยู่ในระบบ 32 บิตจำนวน = 2147483647 หากบิตล้นวันที่จะเป็น รีเซ็ต

มันง่ายมากที่จะทดสอบทฤษฎีนี้ด้วยตัวอย่าง:

• เปิดเครื่องคิดเลข Windows มาตรฐาน กด ALT + 3 ซึ่งจะแปลงเป็นมุมมองทางวิศวกรรม
• ตั้งค่าโหมด 4 ไบต์และประเภทอินพุตทศนิยม
• เขียนหมายเลข 2147483647;

• สังเกตการแสดงเลขฐานสองของตัวเลข
• เพิ่มหนึ่งหมายเลข;

• บวกจะส่งผลให้จำนวนลบ!

หากเราเพิ่มต่อไป เราจะได้การปิดแบบวนซ้ำ

เสียงเรียกเข้าของวันที่ประเภทนี้จะเกิดขึ้นตั้งแต่วันที่ 19 มกราคม 2038 ในทุกระบบที่ใช้สถาปัตยกรรมแบบ 32 บิต

อันที่จริง ไม่จำเป็นต้องเศร้าเพราะนักพัฒนาระบบคอมพิวเตอร์กำลังแนะนำสถาปัตยกรรม 64 บิตให้แพร่หลายมากขึ้น เชื่อเถอะว่าพวกเขาจะทันเวลาภายในปี 2038

ทีนี้มาพูดถึงการใช้การประทับเวลายูนิกซ์ใน php, mysqlและแม้กระทั่งใน จาวาสคริปต์.

การทำงานกับการประทับเวลายูนิกซ์

จุดสำคัญมากเมื่อทำงานกับ unix timestamp ใน php หรือ mysql คือต้องเข้าใจข้อดีและข้อเสียของรูปแบบวันที่นี้อย่างชัดเจน

ตัวอย่างเช่น, การประทับเวลาไม่สามารถใช้ระบุเหตุการณ์ทางประวัติศาสตร์หรือเหตุการณ์ในอนาคตอันไกลโพ้นได้ วันที่ทั้งชุดจำกัดเฉพาะช่วงเวลาตั้งแต่ปี 1970 ถึงต้นปี 2038 หากคุณตั้งวันที่เกิน 2038 ระบบ 32 บิตจะตีความวันที่นั้นไม่ถูกต้อง

เมื่อตระหนักถึงข้อ จำกัด นี้จึงเกิดคำถามเชิงตรรกะ: " ทำไมต้องกังวลกับการแสดงวันที่เป็นวินาที?"

เมื่อใดควรใช้ Unix Timestamp

เพื่อแสดงเวลาในระบบการวัดปกติของเรา ต้องใช้ 8 ไบต์ และสำหรับการประทับเวลายูนิกซ์ จะใช้เวลาเพียงครึ่งเดียว - 4 ไบต์

ในความคิดของฉันการประหยัดปริมาณข้อมูลเป็นข้อดีหลักและไม่อาจโต้แย้งได้ในการใช้ Unix Time

นอกจากนี้ยังมีความแตกต่างที่มีประโยชน์มากมายเมื่อทำงานกับ การประทับเวลา UNIX ใน mysql... และเนื่องจากข้อมูลทั้งหมดต้องถูกจัดเก็บไว้บนเซิร์ฟเวอร์ฐานข้อมูล และมีข้อดีหลายประการเมื่อทำงานกับ Unix timestamps ทางเลือกในการประทับเวลา unix สามารถปรับให้เหมาะสมได้อย่างถูกต้องตามข้อกำหนดต่อไปนี้

MySQL จัดเตรียมประเภทข้อมูล Timestamp ที่เหมาะสมสำหรับการทำงานกับรูปแบบ unix-time ซึ่งเราจะได้รับประโยชน์จากรูปแบบมาตรฐานทันที วันที่และ วันเวลา... ข้อดีคือโดยดำเนินการเพิ่ม รายการใหม่ในตาราง คอลัมน์ที่มีชนิดข้อมูลนี้จะถูกเติมโดยอัตโนมัติ ซึ่งหมายความว่าเราสามารถบันทึกได้ไม่เพียงแค่ปริมาณข้อมูลเท่านั้น แต่ยังรวมถึงเวลาของตัวประมวลผลของเว็บเซิร์ฟเวอร์ด้วย

เพื่อเสริมคำพูดด้วยการกระทำ เราได้กำหนดภารกิจต่อไปนี้: เมื่อลงทะเบียนผู้ใช้ใหม่ในระบบ คุณต้องป้อนวันที่ที่เขาเพิ่มลงในฐานข้อมูล

ถ้าชนิดของเขตข้อมูลที่เก็บวันที่ในตารางคือ วันเวลาแล้วมีการร้องขอจาก สคริปต์ PHPจะมีลักษณะดังนี้:

ประโยชน์ชัดเจน!

นอกจากนี้ยังมีเครื่องหมายลบ: หากมีฟิลด์ TIMESTAMP หลายฟิลด์ เฉพาะฟิลด์แรกเท่านั้นที่จะได้รับการอัปเดตโดยอัตโนมัติ

เหมาะสมหรือไม่ที่จะใช้ INT แทนการประทับเวลา

โปรแกรมเมอร์หลายคนเมื่อทำงานกับ unix timestamp ให้ใช้รูปแบบจำนวนเต็ม int (11) นี่เป็นแนวทางที่ไม่สมเหตุสมผลอย่างสมบูรณ์สำหรับคำถาม เนื่องจาก MySQL มีฟังก์ชันที่มีประโยชน์มากมายสำหรับประเภทการประทับเวลาที่ส่งผลต่อความเร็วในการทำงาน ดังนั้น ด้วยการจัดเก็บการประทับเวลาใน INT เราจึงขาดการสนับสนุนเซิร์ฟเวอร์ทั้งหมดสำหรับรูปแบบนี้ สิ่งนี้เหมือนกับการจัดเก็บ id ในประเภท varchar (11)

อย่างไรก็ตาม มีข้ออ้างอย่างหนึ่งในการรักษา การประทับเวลา unix เป็น INT... เมื่อถ่ายโอนฐานข้อมูลระหว่าง DBMS ที่แตกต่างกัน อาจเกิดข้อขัดแย้งเกี่ยวกับประเภท เช่น สำหรับ DBMS ตัวใดตัวหนึ่ง ประเภทการประทับเวลาอาจไม่คุ้นเคย ในกรณีนี้ การใช้ int จะมีความสำคัญมากกว่าเนื่องจาก รูปแบบนี้อยู่ใน DBMS ทั้งหมด

คำอธิบายสั้น ๆ ของประเภทปฏิทิน MySQL

การประทับเวลา- ชนิดข้อมูลสำหรับจัดเก็บวันที่และเวลา ข้อมูลจะถูกเก็บไว้เป็นจำนวนวินาทีตั้งแต่เริ่มต้น "ยุค Unix" ช่วงของค่าคือ 1970-01-01 00:00:00 - 2038-12-31 00:00:00 ใช้เวลา 4 ไบต์

วันที่- ชนิดข้อมูลสำหรับจัดเก็บวันที่ ช่วงของค่าคือ 1000-01-01 ถึง 9999-12-31 ใช้เวลา 3 ไบต์

วันเวลา- ชนิดข้อมูลสำหรับจัดเก็บวันที่และเวลา ช่วงของค่าคือ 1000-01-01 00:00:00 - 9999-12-31 00:00:00 โดยใช้เวลา 8 ไบต์และจัดเก็บเป็นตัวเลข YYYYMMDDHHMMSS./p>

ปี- ชนิดข้อมูลสำหรับจัดเก็บปี ช่วงของค่าคือ 1901 - 2155 มีขนาด 1 ไบต์

เวลา- ชนิดข้อมูลสำหรับจัดเก็บเวลา ช่วงคือ −828: 59: 59 - 828: 59: 59 ใช้เวลา 3 ไบต์

แปลวันที่ในยูนิกซ์

ได้เวลาจัดวางฟังก์ชันที่มีประโยชน์สำหรับการแปลวันที่เป็น การประทับเวลายูนิกซ์และกลับจาก เวลายูนิกซ์ในวันที่อ่านได้

วิธีรับเวลา UNIX ปัจจุบัน

• PHP:

  เวลา ();

• จาวาสคริปต์:

  Math.round (วันที่ใหม่ () .getTime () / 1000.0);

• MySQL:

  เลือก unix_timestamp (ตอนนี้ ());