เวิร์กเบนช์เวลา Epoch

ติดตามนาฬิกา Unix Epoch แบบเรียลไทม์ สร้างค่าเวลาจากปี/เดือน/วัน/ชั่วโมง/นาที/วินาที ตรวจสอบขอบเขตช่วงเวลา และคำนวณส่วนต่างระยะเวลาในเบราว์เซอร์

ไม่ต้องอัปโหลดไม่ต้องลงทะเบียนผลลัพธ์ทันที
วัน / สัปดาห์ / เดือน / ปีคำนวณส่วนต่าง EpochSQL, JS, Python, Go และ Bash
เปิด Epoch Workbench
ระบบออฟไลน์พร้อมใช้งานพื้นที่ทำงานบนเบราว์เซอร์ส่วนตัว 100% • ไม่มีการอัปโหลดลงคลาวด์
ส่วนตัว 100% • ไม่อัปโหลดไฟล์ขึ้นเซิร์ฟเวอร์

ทำไมต้องใช้ เวิร์กเบนช์เวลา Epoch ฟรีของ Utiliome?

ออกแบบมาเพื่อความเป็นส่วนตัวสูงสุด ทำงานได้ทันที ไม่มีสะดุด ไม่ต้องสมัครสมาชิก ไม่ต้องเสียเงิน และไม่ต้องลงทะเบียน

นาฬิกาเวลาจริงและตัวสร้างวันที่ Y/M/D/H/M/S

ติดตามนาฬิกา Unix Epoch แบบเรียลไทม์ที่สามารถหยุดชั่วคราวได้ทั้งระดับวินาทีและมิลลิวินาที พร้อมประกอบค่าจำนวนเต็ม Epoch ที่แม่นยำจากช่องข้อมูลปี เดือน วัน ชั่วโมง นาที และวินาทีแยกกันตามเวลา UTC หรือเขตเวลา IANA ใดก็ได้

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

สร้างค่าเวลา Epoch ณ จุดเริ่มต้นและจุดสิ้นสุดของช่วงเวลาสำหรับวันที่ที่เลือกครอบคลุมทั้ง UTC และเขตเวลา IANA พร้อมคัดลอกไปวางในคำสั่ง SQL WHERE คิวรี Prometheus หรือตัวกรองระบบวิเคราะห์ข้อมูล

เครื่องคำนวณส่วนต่างระยะเวลา (Delta) ระหว่างสองค่าเวลา

คำนวณระยะเวลาที่ผ่านไปทั้งแบบมีเครื่องหมายและค่าสัมบูรณ์ระหว่างจำนวนเต็ม Epoch สองค่าใดๆ โดยแจกแจงรายละเอียดออกเป็นวัน ชั่วโมง นาที วินาที มิลลิวินาที และสตริงระยะเวลาตามมาตรฐาน ISO-8601 (PnDTnHnMnS)

โค้ดสำเร็จรูปหลายภาษาพร้อมคัดลอก

คัดลอกสคริปต์มาตรฐานสำหรับดึงค่า Epoch ปัจจุบันและแปลงค่าเวลาสำหรับ JavaScript, Python, Go, Rust, PostgreSQL/MySQL และ Bash ซึ่งคำนวณภายในเบราว์เซอร์ของคุณทั้งหมดโดยไม่มีการส่งคำขอผ่านเครือข่าย

Utiliome เปรียบเทียบกับทางเลือกคลาวด์แบบเดิม

เปรียบเทียบขีดความสามารถของเอนจิน WebAssembly ภายในเครื่อง กับเครื่องมือคลาวด์แบบเก่า

ฟีเจอร์ Utiliome (ประมวลผลในเบราว์เซอร์) เครื่องมือแปลงไฟล์บนคลาวด์แบบเดิม
นาฬิกาเวลาจริงและตัวสร้างวันที่ Y/M/D/H/M/S ติดตามนาฬิกา Unix Epoch แบบเรียลไทม์ที่สามารถหยุดชั่วคราวได้ทั้งระดับวินาทีและมิลลิวินาที พร้อมประกอบค่าจำนวนเต็ม Epoch ที่แม่นยำจากช่องข้อมูลปี เดือน วัน ชั่วโมง นาที และวินาทีแยกกันตามเวลา UTC หรือเขตเวลา IANA ใดก็ได้ ตัวเลือกจำกัดและไม่มีการปรับแต่งขั้นสูง
ตารางขอบเขตเริ่มต้นและสิ้นสุดของวัน สัปดาห์ เดือน และปี สร้างค่าเวลา Epoch ณ จุดเริ่มต้นและจุดสิ้นสุดของช่วงเวลาสำหรับวันที่ที่เลือกครอบคลุมทั้ง UTC และเขตเวลา IANA พร้อมคัดลอกไปวางในคำสั่ง SQL WHERE คิวรี Prometheus หรือตัวกรองระบบวิเคราะห์ข้อมูล ต้องใช้โปรแกรมเสริมหรือแก้ไขด้วยตนเอง
ความเป็นส่วนตัวและการประมวลผล ประมวลผลในเบราว์เซอร์ 100% (ไม่อัปโหลดขึ้นเซิร์ฟเวอร์) อัปโหลดข้อมูลไปยังเซิร์ฟเวอร์คลาวด์ภายนอก
ราคาและการสมัครสมาชิก ฟรี 100% ตลอดชีพโดยไม่ต้องสมัครสมาชิก บังคับสมัครสมาชิกหรือต้องจ่ายค่าบริการรายเดือน
วิธีใช้งาน

วิธีใช้งาน เวิร์กเบนช์เวลา Epoch ใน 3 ขั้นตอนง่ายๆ

ไม่ต้องติดตั้งโปรแกรม ทุกอย่างทำงานได้โดยตรงผ่านเว็บเบราว์เซอร์ของคุณ

1

จับเวลาปัจจุบันหรือสร้างค่าจาก Y/M/D/H/M/S

หยุดนาฬิกา Unix Epoch แบบสด ณ วินาทีปัจจุบัน กรอกค่าปี เดือน วัน ชั่วโมง นาที และวินาทีแยกตามช่อง หรือโหลดค่าจำนวนเต็ม Epoch อ้างอิงในรูปแบบ UTC หรือเขตเวลา IANA

2

ตรวจสอบขอบเขตช่วงเวลาและคำนวณส่วนต่าง Delta

ดูค่าจำนวนเต็ม Epoch เริ่มต้นและสิ้นสุดของวัน สัปดาห์ ISO เดือน และปีที่ครอบคลุมอยู่ หรือระบุค่าเวลาที่สองเพื่อคำนวณหาระยะเวลาที่แตกต่างกันอย่างแม่นยำ

3

คัดลอกช่วงคิวรีหรือโค้ดตัวอย่างแต่ละภาษา

คัดลอกค่าจำนวนเต็มขอบเขตระดับวินาทีหรือมิลลิวินาทีไปใส่ในตัวกรอง SQL หรือระบบ Observability ได้โดยตรง หรือเลือกคัดลอกโค้ดจัดการ Epoch พร้อมใช้งานสำหรับ JavaScript, Python, Go, Rust, SQL และ Bash

การสร้างช่วงเวลา Epoch ขอบเขตปฏิทิน และการคำนวณส่วนต่างระยะเวลา (Delta)

คำตอบโดยย่อ: ประกอบค่าจำนวนเต็ม Unix Epoch จากช่องข้อมูล Y/M/D/H/M/S แยกกันตามเวลา UTC หรือเขตเวลา IANA เพื่อรับค่าขอบเขตเริ่มต้นและสิ้นสุดของวัน สัปดาห์ ISO เดือน และปีได้ทันที พร้อมทั้งคำนวณส่วนต่างระยะเวลาระหว่างสองจุดเวลาและคัดลอกโค้ดสำเร็จรูปไปใช้งาน

เมื่อต้องเขียนสคริปต์ย้ายฐานข้อมูล (Database Migrations) กำหนดเวลาตัดรอบ Cron หรือจำกัดช่วงเวลาในการคิวรีระบบ Observability คุณแทบจะไม่ได้เริ่มต้นด้วยตัวเลขจำนวนเต็ม 10 หลักแบบดิบๆ แต่คุณมักจะเริ่มจากวันที่ตามปฏิทิน เขตเวลา และกรอบเวลาที่ต้องการทำรายงาน การป้อนค่า 2026-07-15 14:30:00 ในเขตเวลา UTC ลงใน ตัวสร้าง Y/M/D/H/M/S จะช่วยแปลงจุดเวลาเป้าหมายและสร้างตารางขอบเขตช่วงเวลาโดยรอบทั้งหมดออกมาทั้งในหน่วยวินาทีและมิลลิวินาที:

{
  "builtInput": "2026-07-15 14:30:00 (UTC)",
  "epochSeconds": 1784125800,
  "epochMilliseconds": 1784125800000,
  "boundariesUtc": {
    "day": {
      "start": 1784073600,
      "end": 1784159999,
      "rangeIso": "2026-07-15T00:00:00Z .. 2026-07-15T23:59:59Z"
    },
    "isoWeek": {
      "week": "2026-W29",
      "start": 1783900800,
      "end": 1784505599,
      "rangeIso": "2026-07-13T00:00:00Z .. 2026-07-19T23:59:59Z"
    },
    "month": {
      "start": 1782864000,
      "end": 1785542399,
      "rangeIso": "2026-07-01T00:00:00Z .. 2026-07-31T23:59:59Z"
    },
    "year": {
      "start": 1767225600,
      "end": 1798761599,
      "rangeIso": "2026-01-01T00:00:00Z .. 2026-12-31T23:59:59Z"
    }
  }
}

หากต้องการวัดค่าเฉลี่ยเวลาในการกู้คืนระบบ (MTTR) กรอบเวลา SLA หรืออายุของโทเค็น (TTL) ให้ป้อนค่าเวลาสองจุดลงใน เครื่องคำนวณ Delta และคัดลอกนิพจน์สำหรับดึงค่า Epoch ปัจจุบันจาก คลังโค้ดตัวอย่างแต่ละภาษา:

# การคำนวณส่วนต่างระยะเวลาระหว่างสองค่าเวลา (Delta)
Timestamp A (Start):  1784125800 (2026-07-15T14:30:00Z)
Timestamp B (End):    1784310325 (2026-07-17T17:45:25Z)
Signed Delta:         +184525 s (+184525000 ms)
Human Breakdown:      2 days, 3 hours, 15 minutes, 25 seconds (51h 15m 25s)
ISO-8601 Duration:    P2DT3H15M25S

# โค้ดดึงค่า Unix Epoch ปัจจุบันพร้อมคัดลอก
JavaScript (s / ms):  Math.floor(Date.now() / 1000)  |  Date.now()
Python 3 (s / ns):    int(time.time())               |  time.time_ns()
Go (s / ns):          time.Now().Unix()              |  time.Now().UnixNano()
Rust (std):           SystemTime::now().duration_since(UNIX_EPOCH)?.as_secs()
PostgreSQL / MySQL:   SELECT EXTRACT(EPOCH FROM NOW())::bigint;  |  SELECT UNIX_TIMESTAMP();
Bash (GNU / macOS):   date +%s  |  date -u -d @1784125800  |  date -u -r 1784125800

คณิตศาสตร์การแปลงปฏิทินเป็น Epoch การเปลี่ยนเวลา DST และการออกแบบคิวรีแบบช่วง

คำตอบโดยย่อ: การแปลงช่องข้อมูลปฏิทินสากล Y/M/D/H/M/S และขอบเขตช่วงเวลาตามปฏิทินให้เป็นจำนวนเต็ม Unix Epoch ต้องอาศัยคณิตศาสตร์การนับวันตามปฏิทินเกรกอเรียนแบบย้อนหลัง (Proleptic Gregorian) เงื่อนไข SQL แบบช่วงครึ่งเปิด [start, nextStart) ที่ช่วยรักษาเศษของวินาทีสุดท้ายไว้ รวมถึงการจัดการช่วงเวลาที่ข้ามไป (Gap) และช่วงเวลาที่ซ้ำกัน (Fold) จากการปรับเวลาออมแสง (DST) ตามฐานข้อมูล IANA

คณิตศาสตร์การแปลงปฏิทินเกรกอเรียนเป็นค่า Epoch

การแปลงค่าข้อมูลเวลาสากลแบบแยกช่อง (Y, M, D, H, Min, S) ในเขตเวลา UTC ให้เป็นจำนวนเต็ม Unix Epoch จะใช้วิธีนับจำนวนวันที่แน่นอนตั้งแต่วันที่ 1970-01-01 ภายใต้วัฏจักรปีอธิกสุรทิน 400 ปีของปฏิทินเกรกอเรียน (ปีที่หารด้วย 4 ลงตัวจะเป็นปีอธิกสุรทินที่มี 366 วัน ยกเว้นปีครบรอบศตวรรษที่หารด้วย 400 ไม่ลงตัว ซึ่งทำให้ปี 2000 เป็นปีอธิกสุรทิน ในขณะที่ปี 2100 มีเพียง 365 วัน) จากนั้นนำมาคูณด้วย 86,400:

epoch_utc = days_from_civil(Y, M, D) * 86400 + H * 3600 + Min * 60 + S

เมื่อข้อมูลที่ป้อนเข้ามาเป็นเวลาท้องถิ่นตามหน้าปัดนาฬิกาในเขตเวลา IANA แทนที่จะเป็น UTC ค่าออฟเซ็ตจาก UTC จะแปรผันตามวันที่เป้าหมายด้วย เนื่องจากแต่ละภูมิภาคมีการปรับเปลี่ยนค่าออฟเซ็ตมาตรฐานและกฎการปรับเวลาออมแสง (Daylight Saving Time) ไปตามยุคสมัย

ขอบเขตแบบปิด `23:59:59` เทียบกับช่วงคิวรีแบบครึ่งเปิด `[start, nextStart)`

ตารางขอบเขตทั่วไปมักแสดงวินาทีเต็มสุดท้ายของวันตามเวลา UTC แบบรวมค่าขอบ (เช่น 1784159999 สำหรับ 2026-07-15T23:59:59Z) คู่กับค่าระดับมิลลิวินาที (1784159999999 สำหรับ 23:59:59.999Z) ในฐานข้อมูลใช้งานจริงที่จัดเก็บคอลัมน์ระดับมิลลิวินาที ไมโครวินาที หรือ TIMESTAMPTZ การกรองข้อมูลด้วยคำสั่ง WHERE created_at BETWEEN 1784073600 AND 1784159999 จะทำให้เหตุการณ์ที่ถูกบันทึกในช่วง 999 มิลลิวินาทีสุดท้ายของวัน (เช่น 23:59:59.450Z) ตกหล่นไปโดยไม่รู้ตัว

เพื่อป้องกันปัญหาข้อมูลระดับเศษเสี้ยววินาทีตกหล่นที่ขอบเขตโดยไม่ต้องผูกคิวรีติดกับความละเอียดของคอลัมน์ ควรเลือกใช้เงื่อนไขช่วงครึ่งเปิดที่ยึดจุดเริ่มต้น 00:00:00 ของช่วงเวลาถัดไปเป็นหลัก (1784160000 ซึ่งได้มาจาก 1784159999 + 1):

-- ช่วงครึ่งเปิด (ครอบคลุมทุกเศษเสี้ยววินาทีไปจนถึง 23:59:59.999999...)
WHERE epoch_sec >= 1784073600 AND epoch_sec < 1784160000
WHERE epoch_ms  >= 1784073600000 AND epoch_ms < 1784160000000

ช่วงเวลาที่หายไป (Gaps) ช่วงเวลาซ้ำ (Folds) จาก DST และวันท้องถิ่นที่ไม่ได้มี 86,400 วินาที

อย่าคำนวณหาขอบเขตวันตามเวลาท้องถิ่นด้วยการบวก 86400 เข้ากับเวลาเที่ยงคืนท้องถิ่นโดยเด็ดขาด ในเขตเวลา IANA ที่มีการใช้เวลาออมแสงหรือ Daylight Saving Time (เช่น America/New_York หรือ Europe/London) จะมีสองวันในแต่ละปีที่ไม่ได้มีระยะเวลายาวนาน 86,400 วินาที:

  • ช่วงกระโดดไปข้างหน้าในฤดูใบไม้ผลิ (Spring-forward gap วันละ 23 ชั่วโมง = 82,800 วินาที): เมื่อเข็มนาฬิกาข้ามจาก 01:59:59 ไปเป็น 03:00:00 ทันที เวลาหน้าปัดอย่าง 02:30:00 จะไม่มีอยู่จริงในวันปฏิทินนั้น
  • ช่วงเวลาซ้ำจากการหมุนย้อนในฤดูใบไม้ร่วง (Fall-back fold วันละ 25 ชั่วโมง = 90,000 วินาที): เมื่อเข็มนาฬิกาเดินซ้ำในช่วง 01:00:00 ถึง 01:59:59 เวลาท้องถิ่นอย่าง 01:30:00 จะสามารถแปลงเป็นจำนวนเต็ม Unix Epoch ได้สองค่าที่ต่างกันอยู่ 3,600 วินาที (ครั้งแรกอยู่ในช่วงเวลาออมแสง และครั้งที่สองอยู่ในช่วงเวลามาตรฐาน)

การคำนวณจุดเวลา 00:00:00 ของแต่ละขอบเขตผ่านฐานข้อมูลเขตเวลา IANA จะช่วยให้ค่า Epoch เริ่มต้นวันและเริ่มต้นเดือนมีความแม่นยำเสมอแม้จะข้ามช่วงการปรับเวลา DST ก็ตาม

ค่า Epoch ตามนาฬิกาจริงเทียบกับตัวจับเวลาแบบ Monotonic

การเรียกฟังก์ชันรันไทม์อย่าง Date.now(), time.time(), time.Now().Unix() และ SystemTime::now() เป็นการอ่านค่าจากนาฬิกาเวลาจริงของระบบปฏิบัติการ (CLOCK_REALTIME) ซึ่งจำเป็นอย่างยิ่งสำหรับการบันทึกเวลาลงฐานข้อมูลและการเทียบเคียงเวลาระหว่างเครื่องเซิร์ฟเวอร์ แต่อาจเกิดการกระโดดย้อนกลับหรือเดินช้าลงชั่วขณะเมื่อมีการซิงโครไนซ์ผ่าน NTP ดังนั้นควรใช้ส่วนต่าง Unix Epoch สำหรับข้อมูลเวลาในอดีตที่บันทึกไว้แล้ว และใช้ควบคู่กับนาฬิกาแบบเดินหน้าทางเดียวหรือ Monotonic (performance.now(), time.monotonic_ns(), std::time::Instant) เมื่อต้องการวัดค่าความหน่วง (Latency) ภายในโปรเซสเดียวกัน

เวิร์กเบนช์เวลา Epoch กับ แปลง Unix Timestamp เป็นวันที่: คุณควรใช้เครื่องมือไหน?

คำตอบโดยย่อ: ใช้ เวิร์กเบนช์เวลา Epoch เมื่อต้องการดูนาฬิกา Unix แบบสด ประกอบค่าเวลาจากช่องข้อมูล Y/M/D/H/M/S ดึงตารางขอบเขตวัน/สัปดาห์/เดือน/ปี คำนวณส่วนต่างระหว่างสองค่าเวลา หรือคัดลอกโค้ดตัวอย่างแต่ละภาษา และใช้ แปลง Unix Timestamp เป็นวันที่ เมื่อต้องการถอดรหัสค่าจำนวนเต็มระดับ s, ms, µs, ns หรือสตริง ISO-8601 และ RFC 3339 ทั้งแบบค่าเดียวและแบบหลายบรรทัดพร้อมกัน

เครื่องมือทั้งสองตัวของ Utiliome ประมวลผลภายในเบราว์เซอร์ของคุณ 100% โดยแยกการทำงานระหว่าง การประกอบค่า Epoch แบบโต้ตอบและการวางแผนช่วงเวลาคิวรี ออกจาก การถอดรหัสข้อมูลความละเอียดสูงและการแปลงไฟล์ล็อกแบบกลุ่ม (Batch) อย่างชัดเจน เลือกใช้งาน เวิร์กเบนช์เวลา Epoch เมื่อคุณต้องการสร้างขอบเขตการคิวรี ติดตามนาฬิกา Unix แบบสด คำนวณส่วนต่างระยะเวลา หรือคัดลอกโค้ดสำเร็จรูป และสลับไปใช้เครื่องมือคู่ขนานอย่าง แปลง Unix Timestamp เป็นวันที่ เมื่อคุณมีค่าเวลาดิบขนาด 10, 13, 16 หรือ 19 หลัก หรือต้องการถอดรหัสข้อความล็อกหลายบรรทัดพร้อมกัน

ความสามารถ เวิร์กเบนช์เวลา Epoch แปลง Unix Timestamp เป็นวันที่
เวิร์กโฟลว์หลัก นาฬิกาสด ตัวสร้าง Y/M/D/H/M/S ขอบเขตช่วงเวลา คำนวณส่วนต่าง และโค้ดตัวอย่าง ถอดรหัสค่าเวลา s/ms/µs/ns แบบสองทิศทางและแปลงชุดข้อมูล ISO-8601/RFC 3339 แบบกลุ่ม
นาฬิกา Unix Epoch แบบสด มี — ตัวนับวินาทีและมิลลิวินาทีแบบเรียลไทม์พร้อมปุ่มหยุด/จับเวลา ไม่มี — เน้นการแปลงค่าข้อมูลที่ป้อนเข้ามาอย่างแม่นยำ
ตัวสร้างช่องข้อมูล Y/M/D/H/M/S ช่องกรอกข้อมูลปฏิทินแบบโต้ตอบในเวลา UTC หรือเขตเวลา IANA ใดก็ได้ แปลงสตริง ISO-8601, RFC 3339 และ RFC 2822 ที่วางลงไปได้โดยตรง
ตารางขอบเขต วัน / สัปดาห์ / เดือน / ปี คำนวณค่าจำนวนเต็ม Epoch เริ่มต้นและสิ้นสุดล่วงหน้าให้ครบทั้งสี่ช่วงเวลา ไม่มี
เครื่องคำนวณส่วนต่างระหว่างสองค่าเวลา แยกองค์ประกอบ T2 - T1 อย่างละเอียด (d/h/m/s/ms และรูปแบบ ISO-8601 PnDTnHnMnS) แสดงเฉพาะระยะเวลาสัมพัทธ์เทียบกับนาฬิกาของระบบในปัจจุบันเท่านั้น
รองรับ BigInt 16 หลัก (µs) และ 19 หลัก (ns) เน้นระดับวินาที (10 หลัก) และมิลลิวินาที (13 หลัก) ตรวจจับ BigInt 64 บิตอัตโนมัติครบทุกระดับตั้งแต่ s, ms, µs ไปจนถึง ns ขนาด 19 หลัก
การแปลงข้อมูลหลายบรรทัดพร้อมกัน (Batch) ใช้วันที่อ้างอิงเดี่ยว + คู่ค่าเวลาสำหรับคำนวณส่วนต่าง มี — แปลงค่าเวลาหลายร้อยรายการที่คั่นด้วยการขึ้นบรรทัดใหม่ได้ในครั้งเดียว

หากคุณกำลังตรวจสอบข้อมูล Span ระดับนาโนวินาที 19 หลักจาก OpenTelemetry ค่าไมโครวินาที 16 หลักจาก PostgreSQL หรือชุดข้อมูลล็อกที่มีค่าเวลาหลายรูปแบบปนกันหลายบรรทัด ให้เปิดใช้งาน แปลง Unix Timestamp เป็นวันที่ ได้เลย

คำถามที่พบบ่อย

คำถามที่พบบ่อยและคู่มือทางเทคนิค เวิร์กเบนช์เวลา Epoch

รวมทุกสิ่งที่คุณควรรู้เกี่ยวกับการใช้งาน เครื่องมือแปลงเวลา epoch ออนไลน์ฟรีของ Utiliome

ทำไมคิวรี SQL และฐานข้อมูลอนุกรมเวลา (Time-series) จึงควรใช้ขอบเขต Epoch แบบครึ่งเปิดแทนการใช้เวลา 23:59:59?

การกำหนดขอบเขตบนแบบรวมค่าที่สิ้นสุด ณ เวลา 23:59:59 (เช่น 1784159999) จะทำให้ข้อมูลใดๆ ที่มีเศษระดับมิลลิวินาทีหรือไมโครวินาทีซึ่งอยู่ระหว่าง 23:59:59.001 ถึง 23:59:59.999 ตกหล่นไป การเขียนเงื่อนไขแบบครึ่งเปิดโดยยึดจุดเริ่มต้น 00:00:00 ของช่วงเวลาถัดไปเป็นเกณฑ์ (ts >= 1784073600 AND ts < 1784160000 สำหรับหน่วยวินาที หรือ ts >= 1784073600000 AND ts < 1784160000000 สำหรับหน่วยมิลลิวินาที) จะช่วยดึงข้อมูลทั้งวันได้อย่างครบถ้วนโดยไม่ขึ้นอยู่กับความละเอียดระดับเศษเสี้ยววินาที

ทำไมหนึ่งวันตามปฏิทินท้องถิ่นจึงไม่ได้มีความยาว 86,400 วินาที Epoch เสมอไป?

หนึ่งวันตามเวลา UTC จะมีความยาวเท่ากับ 86,400 วินาที POSIX เสมอ แต่เขตเวลา IANA ที่มีการปรับเวลาออมแสง (Daylight Saving Time) จะมีหนึ่งวันที่มี 23 ชั่วโมง (82,800 วินาที) เมื่อมีการปรับเข็มนาฬิกาไปข้างหน้า และมีหนึ่งวันที่มี 25 ชั่วโมง (90,000 วินาที) เมื่อมีการปรับเข็มนาฬิกาย้อนกลับ เนื่องจากการบวก 86,400 เข้ากับเวลาเที่ยงคืนท้องถิ่นจะทำให้ขอบเขตเวลาคลาดเคลื่อนไปหนึ่งชั่วโมงเมื่อข้ามช่วงเปลี่ยนผ่าน DST ตารางขอบเขตของเครื่องมือนี้จึงคำนวณจุดเวลา 00:00:00 ท้องถิ่นแต่ละจุดโดยอ้างอิงจากฐานข้อมูลเขตเวลา IANA โดยตรง

ตัวสร้าง Y/M/D/H/M/S จัดการกับชั่วโมงที่กำกวมหรือไม่มีอยู่จริงในช่วงการปรับเวลาออมแสง (DST) อย่างไร?

ในช่วงการปรับเวลาไปข้างหน้าในฤดูใบไม้ผลิ (เช่น เวลา 02:00 กระโดดข้ามไปเป็น 03:00 ในเขตเวลา America/New_York) นาทีบนหน้าปัดนาฬิกาที่อยู่ภายในชั่วโมงที่ถูกข้ามไปจะไม่มีอยู่จริงและจะถูกเลื่อนข้ามช่องว่างการเปลี่ยนผ่านนั้นไป ส่วนในช่วงการปรับเวลาย้อนกลับในฤดูใบไม้ร่วง ชั่วโมงที่ซ้ำกันจะเกิดขึ้นสองครั้งโดยห่างกัน 3,600 วินาที ครั้งแรกจะใช้ออฟเซ็ตเวลาออมแสงเดิมและครั้งที่สองจะใช้ออฟเซ็ตเวลามาตรฐาน สำหรับงานตั้งเวลา Cron และระบบตัดรอบบิลที่ต้องการความต่อเนื่องของเวลาอย่างเคร่งครัด แนะนำให้กำหนดขอบเขตเวลาเป็น UTC เสมอ

ขอบเขตสัปดาห์ตามมาตรฐาน ISO-8601 ในตารางขอบเขตถูกนิยามไว้อย่างไร?

ตามกฎของมาตรฐาน ISO-8601 ทุกสัปดาห์จะเริ่มต้นในวันจันทร์ เวลา 00:00:00 และสิ้นสุดในวันอาทิตย์ เวลา 23:59:59.999 โดยสัปดาห์ที่ 1 ของ ISO (W01) ในแต่ละปีถูกนิยามว่าเป็นสัปดาห์ตั้งแต่วันจันทร์ถึงวันอาทิตย์ที่มีวันพฤหัสบดีแรกของปีนั้นอยู่ด้วย (หรือเทียบเท่ากับสัปดาห์ที่มีวันที่ 4 มกราคม) ซึ่งหมายความว่าสัปดาห์ W01 อาจเริ่มต้นตั้งแต่วันที่ 29, 30 หรือ 31 ธันวาคมของปีปฏิทินก่อนหน้าได้

ทำไมคำสั่ง Bash บน GNU Linux และ macOS จึงใช้แฟล็ก (Flag) ต่างกันในการจัดรูปแบบค่าจำนวนเต็ม Epoch?

คำสั่ง date ของชุดเครื่องมือ GNU coreutils บนระบบ Linux จะแปลงค่าจำนวนเต็ม Unix Epoch ด้วยการใช้แฟล็กนำหน้า -d @TIMESTAMP (date -u -d @1784125800 +%Y-%m-%dT%H:%M:%SZ) ในขณะที่คำสั่ง date สาย BSD บน macOS และ FreeBSD จะใช้แฟล็ก -r TIMESTAMP (date -u -r 1784125800 +%Y-%m-%dT%H:%M:%SZ) อย่างไรก็ตาม ทั้งสองแพลตฟอร์มรองรับคำสั่ง date +%s เหมือนกันทุกประการสำหรับการแสดงผลค่า Unix Epoch ปัจจุบันในหน่วยวินาที