ตัวแปลง Unix Timestamp เป็นวันที่: รองรับรูปแบบ 12/24 ชั่วโมง
แปลง Unix timestamps เป็นวันที่และเวลาที่อ่านได้สำหรับมนุษย์ เลือกระหว่างรูปแบบเวลา 12 ชั่วโมงและ 24 ชั่วโมงด้วยเครื่องมือแปลงที่ใช้งานง่ายนี้
ตัวแปลง Unix Timestamp
วันที่และเวลาที่แปลงแล้ว
เอกสารประกอบ
ยูนิกซ์ ไทม์สแตมป์ คอนเวอร์เตอร์
บทนำ
ยูนิกซ์ไทมป์สแตมป์ (Unix timestamp) (หรือที่เรียกว่า POSIX time หรือ Epoch time) เป็นระบบสำหรับการอธิบายจุดในเวลา มันคือจำนวนวินาทีที่ผ่านไปตั้งแต่วันที่ 1 มกราคม 1970 (เที่ยงคืน UTC/GMT) โดยไม่คำนึงถึงวินาทีที่มีการเพิ่ม (leap seconds) ยูนิกซ์ไทมป์สแตมป์ถูกใช้กันอย่างแพร่หลายในระบบคอมพิวเตอร์และภาษาการเขียนโปรแกรมเนื่องจากมันให้การแทนที่เฉพาะจุดในเวลาในรูปแบบที่กระชับและไม่ขึ้นกับภาษา
ตัวแปลงนี้ช่วยให้คุณสามารถแปลงยูนิกซ์ไทมป์สแตมป์ให้เป็นวันที่และเวลาที่อ่านได้ในรูปแบบที่เข้าใจง่าย มันรองรับทั้งรูปแบบเวลา 12 ชั่วโมง (AM/PM) และ 24 ชั่วโมงเพื่อรองรับความชอบในระดับภูมิภาคและส่วนบุคคลที่แตกต่างกัน
วิธีการทำงานของยูนิกซ์ไทมป์สแตมป์
ยูนิกซ์ไทมป์สแตมป์ถูกคำนวณเป็นจำนวนวินาทีตั้งแต่ยูนิกซ์อีพอช (Unix Epoch) (วันที่ 1 มกราคม 1970, 00:00:00 UTC) ซึ่งทำให้มันมีประโยชน์โดยเฉพาะสำหรับการคำนวณความแตกต่างของเวลาและสำหรับการจัดเก็บวันที่ในรูปแบบที่กระชับ
สูตรการแปลงจากยูนิกซ์ไทมป์สแตมป์ไปยังวันที่ในปฏิทินประกอบด้วยหลายขั้นตอน:
- เริ่มต้นด้วยยูนิกซ์อีพอช (วันที่ 1 มกราคม 1970, 00:00:00 UTC)
- เพิ่มจำนวนวินาทีในไทป์สแตมป์
- คำนึงถึงปีอธิก (leap years), ความยาวเดือนที่แตกต่างกัน, และความซับซ้อนอื่น ๆ ของปฏิทิน
- ใช้การปรับเวลาเขตถ้าจำเป็น
ตัวอย่างเช่น ยูนิกซ์ไทมป์สแตมป์ 1609459200
แทนวันศุกร์ที่ 1 มกราคม 2021, 00:00:00 UTC
สูตรการแปลงสามารถแสดงได้ดังนี้:
ภาษาการเขียนโปรแกรมและระบบปฏิบัติการส่วนใหญ่มีฟังก์ชันในตัวเพื่อจัดการการแปลงนี้ โดยทำให้การคำนวณปฏิทินที่ซับซ้อนกลายเป็นเรื่องง่าย
ตัวเลือกฟอร์แมตเวลา
ตัวแปลงนี้มีตัวเลือกฟอร์แมตเวลาสองแบบ:
-
ฟอร์แมต 24 ชั่วโมง (บางครั้งเรียกว่า "เวลาแบบทหาร"): ชั่วโมงจะอยู่ในช่วง 0 ถึง 23 และไม่มีการระบุ AM/PM ตัวอย่างเช่น 15:00 แทนเวลา 3:00 PM
-
ฟอร์แมต 12 ชั่วโมง: ชั่วโมงจะอยู่ในช่วง 1 ถึง 12 โดยมี AM (ante meridiem) สำหรับเวลาตั้งแต่เที่ยงคืนถึงเที่ยงวัน และ PM (post meridiem) สำหรับเวลาตั้งแต่เที่ยงวันถึงเที่ยงคืน ตัวอย่างเช่น 15:00 ในฟอร์แมต 24 ชั่วโมงจะแทนที่เวลา 3:00 PM
การเลือกระหว่างฟอร์แมตเหล่านี้ส่วนใหญ่เป็นเรื่องของธรรมเนียมในระดับภูมิภาคและความชอบส่วนบุคคล:
- ฟอร์แมต 24 ชั่วโมงใช้กันทั่วไปในยุโรป, ละตินอเมริกา, และเอเชีย รวมถึงในบริบททางวิทยาศาสตร์, ทหาร, และการแพทย์ทั่วโลก
- ฟอร์แมต 12 ชั่วโมงเป็นที่นิยมในสหรัฐอเมริกา, แคนาดา, ออสเตรเลีย, และบางประเทศที่พูดภาษาอังกฤษสำหรับการใช้งานในชีวิตประจำวัน
ข้อพิจารณาและข้อจำกัด
เมื่อทำงานกับยูนิกซ์ไทมป์สแตมป์ สิ่งสำคัญคือต้องตระหนักถึงหลายกรณีขอบเขตและข้อจำกัด:
-
ไทป์สแตมป์เชิงลบ: แทนวันที่ก่อนยูนิกซ์อีพอช (วันที่ 1 มกราคม 1970) แม้ว่าจะถูกต้องทางคณิตศาสตร์ แต่บางระบบอาจไม่จัดการไทป์สแตมป์เชิงลบอย่างถูกต้อง
-
ปัญหาปี 2038: ยูนิกซ์ไทมป์สแตมป์มักถูกจัดเก็บเป็นจำนวนเต็ม 32 บิตที่มีเครื่องหมาย ซึ่งจะเกินขีดจำกัดในวันที่ 19 มกราคม 2038 หลังจากจุดนี้ ระบบ 32 บิตจะไม่สามารถแทนเวลาที่ถูกต้องได้ เว้นแต่จะมีการปรับปรุงเพื่อใช้ประเภทจำนวนเต็มที่ใหญ่กว่า
-
ไทป์สแตมป์ที่มีขนาดใหญ่มาก: วันที่ในอนาคตที่ไกลมากอาจไม่สามารถแทนได้ในบางระบบ หรืออาจถูกจัดการอย่างไม่สอดคล้องกัน
-
วินาทีอธิก: ยูนิกซ์เวลาไม่คำนึงถึงวินาทีอธิก ซึ่งถูกเพิ่มเข้ามาใน UTC เพื่อชดเชยการหมุนที่ไม่สม่ำเสมอของโลก ซึ่งหมายความว่ายูนิกซ์เวลาไม่ถูกซิงโครไนซ์อย่างแม่นยำกับเวลาเชิงดาราศาสตร์
-
การพิจารณาเขตเวลา: ยูนิกซ์ไทมป์สแตมป์แทนช่วงเวลาใน UTC การแปลงเป็นเวลาท้องถิ่นต้องการข้อมูลเขตเวลาเพิ่มเติม
-
เวลาออมแสง: เมื่อแปลงไทป์สแตมป์เป็นเวลาท้องถิ่น ความซับซ้อนของการเปลี่ยนแปลงเวลาออมแสงต้องถูกพิจารณา
กรณีการใช้งาน
ยูนิกซ์ไทมป์สแตมป์ถูกใช้ในหลายแอปพลิเคชันทั่วทั้งการประมวลผลและการจัดการข้อมูล:
-
บันทึกในฐานข้อมูล: ไทป์สแตมป์มักถูกใช้เพื่อบันทึกเมื่อมีการสร้างหรือแก้ไขรายการ
-
การพัฒนาเว็บ: HTTP headers, cookies, และกลไกการแคชมักใช้ยูนิกซ์ไทมป์สแตมป์
-
ไฟล์บันทึก: บันทึกระบบมักบันทึกเหตุการณ์ด้วยยูนิกซ์ไทมป์สแตมป์เพื่อให้การจัดลำดับเวลาอย่างแม่นยำ
-
ระบบควบคุมเวอร์ชัน: Git และระบบ VCS อื่น ๆ ใช้ไทป์สแตมป์เพื่อบันทึกเมื่อมีการทำ commit
-
การตอบสนอง API: API เว็บหลายแห่งรวมไทป์สแตมป์ในคำตอบของพวกเขาเพื่อบ่งชี้ว่าเมื่อใดที่ข้อมูลถูกสร้างขึ้นหรือเมื่อทรัพยากรถูกแก้ไขล่าสุด
-
ระบบไฟล์: เวลาในการสร้างและแก้ไขไฟล์มักถูกจัดเก็บเป็นยูนิกซ์ไทมป์สแตมป์
-
การจัดการเซสชัน: แอปพลิเคชันเว็บใช้ไทป์สแตมป์เพื่อตัดสินใจว่าเมื่อใดที่เซสชันของผู้ใช้ควรหมดอายุ
-
การวิเคราะห์ข้อมูล: ไทป์สแตมป์ให้วิธีการมาตรฐานในการทำงานกับข้อมูลเชิงเวลาในแอปพลิเคชันการวิเคราะห์
ทางเลือก
แม้ว่ายูนิกซ์ไทมป์สแตมป์จะถูกใช้กันอย่างแพร่หลาย แต่ก็มีรูปแบบการแทนที่เวลาอื่น ๆ ที่อาจเหมาะสมกว่าในบางบริบท:
-
ISO 8601: รูปแบบสตริงมาตรฐาน (เช่น "2021-01-01T00:00:00Z") ที่อ่านได้ง่ายในขณะที่ยังคงสามารถเรียงลำดับได้ มักจะถูกเลือกใช้สำหรับการแลกเปลี่ยนข้อมูลและแอปพลิเคชันที่มีการแสดงผลต่อผู้ใช้
-
RFC 3339: โปรไฟล์ของ ISO 8601 ที่ใช้ในโปรโตคอลอินเทอร์เน็ต โดยมีข้อกำหนดการจัดรูปแบบที่เข้มงวดกว่า
-
รูปแบบที่อ่านได้ง่าย: สตริงวันที่ที่มีการระบุในท้องถิ่น (เช่น "1 มกราคม 2021") เหมาะสำหรับการโต้ตอบกับผู้ใช้โดยตรง แต่ไม่เหมาะสำหรับการคำนวณ
-
Microsoft FILETIME: ค่าที่มีขนาด 64 บิตที่แทนจำนวนช่วงเวลา 100 นาโนวินาทีตั้งแต่วันที่ 1 มกราคม 1601 ใช้ในระบบ Windows
-
หมายเลขวันจูเลียน: ใช้ในดาราศาสตร์และแอปพลิเคชันทางวิทยาศาสตร์บางอย่าง โดยนับวันตั้งแต่วันที่ 1 มกราคม 4713 ก่อนคริสต์ศักราช
การเลือกใช้รูปแบบเวลา ขึ้นอยู่กับปัจจัยต่าง ๆ เช่น:
- ความแม่นยำที่ต้องการ
- ความต้องการในการอ่านของมนุษย์
- ข้อจำกัดในการจัดเก็บ
- ความเข้ากันได้กับระบบที่มีอยู่
- ช่วงวันที่ที่ต้องการแทนที่
ประวัติศาสตร์
แนวคิดของเวลาแบบยูนิกซ์เกิดขึ้นจากการพัฒนาระบบปฏิบัติการยูนิกซ์ที่ Bell Labs ในช่วงปลายทศวรรษ 1960 และต้นทศวรรษ 1970 การตัดสินใจใช้วันที่ 1 มกราคม 1970 เป็นอีพอชนั้นค่อนข้างจะเป็นการเลือกที่สุ่ม แต่ก็มีความเหมาะสมในขณะนั้น—มันเป็นวันที่ใกล้เคียงพอที่จะลดความต้องการในการจัดเก็บสำหรับวันที่ที่น่าสนใจ แต่ก็ห่างไกลพอที่จะมีประโยชน์สำหรับข้อมูลทางประวัติศาสตร์
การใช้งานเดิมใช้จำนวนเต็ม 32 บิตที่มีเครื่องหมายเพื่อจัดเก็บจำนวนวินาที ซึ่งเพียงพอสำหรับอายุการใช้งานที่คาดการณ์ไว้ของระบบยูนิกซ์ในขณะนั้น อย่างไรก็ตาม การตัดสินใจนี้นำไปสู่ปัญหาปี 2038 (บางครั้งเรียกว่า "Y2K38" หรือ "Unix Millennium Bug") เนื่องจากจำนวนเต็ม 32 บิตสามารถแทนวันที่ได้สูงสุดจนถึงวันที่ 19 มกราคม 2038 (03:14:07 UTC)
เมื่อยูนิกซ์และระบบที่คล้ายกันได้รับความนิยม ยูนิกซ์ไทมป์สแตมป์จึงกลายเป็นมาตรฐานที่ไม่เป็นทางการในการแทนที่เวลาในคอมพิวเตอร์ มันถูกนำไปใช้โดยภาษาการเขียนโปรแกรม, ฐานข้อมูล, และแอปพลิเคชันจำนวนมาก ซึ่งขยายออกไปไกลกว่าบริบทยูนิกซ์เดิม
ระบบสมัยใหม่เริ่มใช้จำนวนเต็ม 64 บิตสำหรับไทป์สแตมป์ ซึ่งขยายช่วงที่สามารถแทนได้ประมาณ 292 พันล้านปีในทั้งสองทิศทางจากอีพอช ซึ่งแก้ไขปัญหาปี 2038 อย่างมีประสิทธิภาพ อย่างไรก็ตาม ระบบและแอปพลิเคชันที่เก่าแก่ยังคงอาจมีความเสี่ยง
ความเรียบง่ายและความมีประโยชน์ของยูนิกซ์ไทมป์สแตมป์ทำให้มันยังคงมีความเกี่ยวข้องแม้จะมีการพัฒนารูปแบบการแทนที่เวลาที่ซับซ้อนมากขึ้น มันยังคงเป็นแนวคิดพื้นฐานในการประมวลผลคอมพิวเตอร์ ซึ่งเป็นรากฐานของโครงสร้างพื้นฐานดิจิทัลของเรา
ตัวอย่างโค้ด
นี่คือตัวอย่างของการแปลงยูนิกซ์ไทมป์สแตมป์เป็นวันที่ที่อ่านได้ในภาษาการเขียนโปรแกรมต่าง ๆ:
1// การแปลงไทป์สแตมป์ใน JavaScript
2function convertUnixTimestamp(timestamp, use12Hour = false) {
3 // สร้างวัตถุ Date ใหม่ (JavaScript ใช้หน่วยมิลลิวินาที)
4 const date = new Date(timestamp * 1000);
5
6 // ตัวเลือกการจัดรูปแบบ
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 // แปลงเป็นสตริงโดยใช้การจัดรูปแบบตามภูมิภาค
19 return date.toLocaleString(undefined, options);
20}
21
22// การใช้งานตัวอย่าง
23const timestamp = 1609459200; // วันที่ 1 มกราคม 2021 00:00:00 UTC
24console.log(convertUnixTimestamp(timestamp, false)); // ฟอร์แมต 24 ชั่วโมง
25console.log(convertUnixTimestamp(timestamp, true)); // ฟอร์แมต 12 ชั่วโมง
26
1# การแปลงไทป์สแตมป์ใน Python
2import datetime
3
4def convert_unix_timestamp(timestamp, use_12hour=False):
5 # แปลงยูนิกซ์ไทมป์สแตมป์เป็นวัตถุ datetime
6 date = datetime.datetime.fromtimestamp(timestamp)
7
8 # จัดรูปแบบสตริงวันที่
9 if use_12hour:
10 format_string = "%A, %B %d, %Y %I:%M:%S %p" # ฟอร์แมต 12 ชั่วโมงพร้อม AM/PM
11 else:
12 format_string = "%A, %B %d, %Y %H:%M:%S" # ฟอร์แมต 24 ชั่วโมง
13
14 return date.strftime(format_string)
15
16# การใช้งานตัวอย่าง
17timestamp = 1609459200 # วันที่ 1 มกราคม 2021 00:00:00 UTC
18print(convert_unix_timestamp(timestamp, False)) # ฟอร์แมต 24 ชั่วโมง
19print(convert_unix_timestamp(timestamp, True)) # ฟอร์แมต 12 ชั่วโมง
20
1<?php
2// การแปลงไทป์สแตมป์ใน PHP
3function convertUnixTimestamp($timestamp, $use12Hour = false) {
4 // จัดรูปแบบสตริง
5 $formatString = $use12Hour
6 ? 'l, F j, Y g:i:s A' // ฟอร์แมต 12 ชั่วโมงพร้อม AM/PM
7 : 'l, F j, Y H:i:s'; // ฟอร์แมต 24 ชั่วโมง
8
9 // แปลงและจัดรูปแบบวันที่
10 return date($formatString, $timestamp);
11}
12
13// การใช้งานตัวอย่าง
14$timestamp = 1609459200; // วันที่ 1 มกราคม 2021 00:00:00 UTC
15echo convertUnixTimestamp($timestamp, false) . "\n"; // ฟอร์แมต 24 ชั่วโมง
16echo convertUnixTimestamp($timestamp, true) . "\n"; // ฟอร์แมต 12 ชั่วโมง
17?>
18
1// การแปลงไทป์สแตมป์ใน Java
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 // แปลงยูนิกซ์ไทมป์สแตมป์เป็น Instant แล้วไปยัง LocalDateTime
10 Instant instant = Instant.ofEpochSecond(timestamp);
11 LocalDateTime dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
12
13 // สร้างตัวจัดรูปแบบตามฟอร์แมตที่ต้องการ
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 // จัดรูปแบบวันที่
19 return dateTime.format(formatter);
20 }
21
22 public static void main(String[] args) {
23 long timestamp = 1609459200; // วันที่ 1 มกราคม 2021 00:00:00 UTC
24 System.out.println(convertUnixTimestamp(timestamp, false)); // ฟอร์แมต 24 ชั่วโมง
25 System.out.println(convertUnixTimestamp(timestamp, true)); // ฟอร์แมต 12 ชั่วโมง
26 }
27}
28
1// การแปลงไทป์สแตมป์ใน C#
2using System;
3
4class UnixTimestampConverter
5{
6 public static string ConvertUnixTimestamp(long timestamp, bool use12Hour)
7 {
8 // แปลงยูนิกซ์ไทมป์สแตมป์เป็น DateTime
9 // ยูนิกซ์ไทมป์สแตมป์คือวินาทีตั้งแต่ 1970-01-01
10 DateTime dateTime = DateTimeOffset.FromUnixTimeSeconds(timestamp).DateTime;
11
12 // จัดรูปแบบสตริงตามความชอบ 12 ชั่วโมงหรือ 24 ชั่วโมง
13 string formatString = use12Hour
14 ? "dddd, MMMM d, yyyy h:mm:ss tt" // ฟอร์แมต 12 ชั่วโมงพร้อม AM/PM
15 : "dddd, MMMM d, yyyy HH:mm:ss"; // ฟอร์แมต 24 ชั่วโมง
16
17 // ส่งคืนสตริงวันที่ที่จัดรูปแบบ
18 return dateTime.ToString(formatString);
19 }
20
21 static void Main()
22 {
23 long timestamp = 1609459200; // วันที่ 1 มกราคม 2021 00:00:00 UTC
24 Console.WriteLine(ConvertUnixTimestamp(timestamp, false)); // ฟอร์แมต 24 ชั่วโมง
25 Console.WriteLine(ConvertUnixTimestamp(timestamp, true)); // ฟอร์แมต 12 ชั่วโมง
26 }
27}
28
1# การแปลงไทป์สแตมป์ใน Ruby
2require 'time'
3
4def convert_unix_timestamp(timestamp, use_12hour = false)
5 # แปลงยูนิกซ์ไทมป์สแตมป์เป็นวัตถุ Time
6 time = Time.at(timestamp)
7
8 # จัดรูปแบบตามความชอบ 12 ชั่วโมงหรือ 24 ชั่วโมง
9 if use_12hour
10 time.strftime("%A, %B %d, %Y %I:%M:%S %p") # ฟอร์แมต 12 ชั่วโมงพร้อม AM/PM
11 else
12 time.strftime("%A, %B %d, %Y %H:%M:%S") # ฟอร์แมต 24 ชั่วโมง
13 end
14end
15
16# การใช้งานตัวอย่าง
17timestamp = 1609459200 # วันที่ 1 มกราคม 2021 00:00:00 UTC
18puts convert_unix_timestamp(timestamp, false) # ฟอร์แมต 24 ชั่วโมง
19puts convert_unix_timestamp(timestamp, true) # ฟอร์แมต 12 ชั่วโมง
20
1// การแปลงไทป์สแตมป์ใน Go
2package main
3
4import (
5 "fmt"
6 "time"
7)
8
9func convertUnixTimestamp(timestamp int64, use12Hour bool) string {
10 // แปลงยูนิกซ์ไทมป์สแตมป์เป็น Time
11 t := time.Unix(timestamp, 0)
12
13 // จัดรูปแบบสตริงตามความชอบ 12 ชั่วโมงหรือ 24 ชั่วโมง
14 formatString := "Monday, January 2, 2006 "
15 if use12Hour {
16 formatString += "3:04:05 PM" // ฟอร์แมต 12 ชั่วโมงพร้อม AM/PM
17 } else {
18 formatString += "15:04:05" // ฟอร์แมต 24 ชั่วโมง
19 }
20
21 // ส่งคืนเวลาที่จัดรูปแบบ
22 return t.Format(formatString)
23}
24
25func main() {
26 timestamp := int64(1609459200) // วันที่ 1 มกราคม 2021 00:00:00 UTC
27 fmt.Println(convertUnixTimestamp(timestamp, false)) // ฟอร์แมต 24 ชั่วโมง
28 fmt.Println(convertUnixTimestamp(timestamp, true)) // ฟอร์แมต 12 ชั่วโมง
29}
30
1// การแปลงไทป์สแตมป์ใน Swift
2import Foundation
3
4func convertUnixTimestamp(_ timestamp: Int, use12Hour: Bool) -> String {
5 // สร้าง Date จากยูนิกซ์ไทป์สแตมป์
6 let date = Date(timeIntervalSince1970: TimeInterval(timestamp))
7
8 // สร้าง DateFormatter
9 let formatter = DateFormatter()
10 formatter.dateStyle = .full
11
12 // ตั้งค่ารูปแบบเวลาโดยขึ้นอยู่กับความชอบ 12 ชั่วโมงหรือ 24 ชั่วโมง
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 // ส่งคืนวันที่ที่จัดรูปแบบ
23 return formatter.string(from: date)
24}
25
26// การใช้งานตัวอย่าง
27let timestamp = 1609459200 // วันที่ 1 มกราคม 2021 00:00:00 UTC
28print(convertUnixTimestamp(timestamp, use12Hour: false)) // ฟอร์แมต 24 ชั่วโมง
29print(convertUnixTimestamp(timestamp, use12Hour: true)) // ฟอร์แมต 12 ชั่วโมง
30
1# การแปลงไทป์สแตมป์ใน R
2convert_unix_timestamp <- function(timestamp, use_12hour = FALSE) {
3 # แปลงยูนิกซ์ไทป์สแตมป์เป็นวันที่ POSIXct
4 date_time <- as.POSIXct(timestamp, origin = "1970-01-01", tz = "UTC")
5
6 # จัดรูปแบบตามความชอบ 12 ชั่วโมงหรือ 24 ชั่วโมง
7 if (use_12hour) {
8 format_string <- "%A, %B %d, %Y %I:%M:%S %p" # ฟอร์แมต 12 ชั่วโมงพร้อม AM/PM
9 } else {
10 format_string <- "%A, %B %d, %Y %H:%M:%S" # ฟอร์แมต 24 ชั่วโมง
11 }
12
13 # ส่งคืนสตริงวันที่ที่จัดรูปแบบ
14 format(date_time, format_string)
15}
16
17# การใช้งานตัวอย่าง
18timestamp <- 1609459200 # วันที่ 1 มกราคม 2021 00:00:00 UTC
19cat(convert_unix_timestamp(timestamp, FALSE), "\n") # ฟอร์แมต 24 ชั่วโมง
20cat(convert_unix_timestamp(timestamp, TRUE), "\n") # ฟอร์แมต 12 ชั่วโมง
21
1% การแปลงไทป์สแตมป์ใน MATLAB
2function formattedDate = convertUnixTimestamp(timestamp, use12Hour)
3 % แปลงยูนิกซ์ไทป์สแตมป์เป็น datetime ของ MATLAB
4 % วันที่ใน MATLAB คือวันที่ตั้งแต่ 1900-01-01 โดย 1 = 1900-01-01
5 % ยูนิกซ์ไทป์สแตมป์คือวินาทีตั้งแต่ 1970-01-01
6
7 % แปลงเป็นรูปแบบวันที่ของ MATLAB
8 % 25569 คือจำนวนวันระหว่าง 1900-01-01 และ 1970-01-01
9 excelDate = (timestamp / 86400) + 25569;
10
11 % จัดรูปแบบตามความชอบ 12 ชั่วโมงหรือ 24 ชั่วโมง
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% การใช้งานตัวอย่าง
20timestamp = 1609459200; % วันที่ 1 มกราคม 2021 00:00:00 UTC
21disp(convertUnixTimestamp(timestamp, false)) % ฟอร์แมต 24 ชั่วโมง
22disp(convertUnixTimestamp(timestamp, true)) % ฟอร์แมต 12 ชั่วโมง
23
1' การแปลงไทป์สแตมป์ใน Excel VBA
2Function ConvertUnixTimestamp(timestamp As Long, Optional use12Hour As Boolean = False) As String
3 ' แปลงยูนิกซ์ไทป์สแตมป์เป็นวันที่/เวลาใน Excel
4 ' วันที่ใน Excel คือวันตั้งแต่ 1900-01-01 โดย 1 = 1900-01-01
5 ' ยูนิกซ์ไทป์สแตมป์คือวินาทีตั้งแต่ 1970-01-01
6
7 ' แปลงเป็นรูปแบบวันที่ของ Excel
8 ' 25569 คือจำนวนวันระหว่าง 1900-01-01 และ 1970-01-01
9 Dim excelDate As Double
10 excelDate = (timestamp / 86400) + 25569
11
12 ' จัดรูปแบบวันที่ตามความชอบ 12 ชั่วโมงหรือ 24 ชั่วโมง
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' การใช้งานในเวิร์กชีต:
21' =ConvertUnixTimestamp(1609459200, TRUE) ' ฟอร์แมต 12 ชั่วโมง
22' =ConvertUnixTimestamp(1609459200, FALSE) ' ฟอร์แมต 24 ชั่วโมง
23
การจัดการกรณีขอบเขต
เมื่อทำงานกับยูนิกซ์ไทมป์สแตมป์ สิ่งสำคัญคือต้องจัดการกรณีขอบเขตอย่างถูกต้อง นี่คือตัวอย่างการจัดการกรณีขอบเขตทั่วไป:
1// การจัดการกรณีขอบเขตใน JavaScript
2function safeConvertTimestamp(timestamp, use12Hour = false) {
3 // ตรวจสอบว่าไทป์สแตมป์ถูกต้องหรือไม่
4 if (timestamp === undefined || timestamp === null || isNaN(timestamp)) {
5 return "ไทป์สแตมป์ไม่ถูกต้อง";
6 }
7
8 // ตรวจสอบไทป์สแตมป์เชิงลบ (วันที่ก่อนปี 1970)
9 if (timestamp < 0) {
10 // บางเบราว์เซอร์อาจไม่จัดการไทป์สแตมป์เชิงลบอย่างถูกต้อง
11 // ใช้วิธีที่มีความแข็งแกร่งมากขึ้นสำหรับวันที่ก่อนปี 1970
12 const date = new Date(timestamp * 1000);
13 if (isNaN(date.getTime())) {
14 return "วันที่ไม่ถูกต้อง (ก่อนปี 1970)";
15 }
16 }
17
18 // ตรวจสอบปัญหา Y2K38 (สำหรับระบบ 32 บิต)
19 const maxInt32 = 2147483647; // ค่าสูงสุดสำหรับจำนวนเต็ม 32 บิตที่มีเครื่องหมาย
20 if (timestamp > maxInt32) {
21 // พิจารณาใช้ BigInt สำหรับไทป์สแตมป์ที่มีขนาดใหญ่ใน JavaScript สมัยใหม่
22 console.warn("ไทป์สแตมป์เกินขีดจำกัดของจำนวนเต็ม 32 บิต (ปัญหา Y2K38)");
23 }
24
25 // ดำเนินการแปลงตามปกติ
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 "เกิดข้อผิดพลาดในการแปลงไทป์สแตมป์: " + error.message;
41 }
42}
43
อ้างอิง
-
"Unix Time." Wikipedia, Wikimedia Foundation, https://en.wikipedia.org/wiki/Unix_time
-
"Year 2038 Problem." Wikipedia, Wikimedia Foundation, https://en.wikipedia.org/wiki/Year_2038_problem
-
Olson, Arthur David. "The Complexities of Calendrical Time." The Open Group, https://www.usenix.org/legacy/events/usenix01/full_papers/olson/olson.pdf
-
"ISO 8601." Wikipedia, Wikimedia Foundation, https://en.wikipedia.org/wiki/ISO_8601
-
"RFC 3339: Date and Time on the Internet: Timestamps." Internet Engineering Task Force (IETF), https://tools.ietf.org/html/rfc3339
-
Kernighan, Brian W., and Dennis M. Ritchie. "The C Programming Language." Prentice Hall, 1988.
ข้อเสนอแนะแสดงความคิดเห็น
คลิกที่ข้อเสนอแนะแสดงความคิดเห็นเพื่อเริ่มให้ข้อเสนอแนะแก่เครื่องมือนี้
เครื่องมือที่เกี่ยวข้อง
ค้นพบเครื่องมือเพิ่มเติมที่อาจมีประโยชน์สำหรับการทำงานของคุณ