什麼是 Unix 時間?

Unix 時間(也稱為 POSIX 時間、Epoch 時間,或簡稱「時間戳記」)是自 1970 年 1 月 1 日 00:00:00 UTC 起經過的秒數,不計閏秒。

Unix 時間與時區:實務工程參考手冊

1736823600  →  2026 年 1 月 14 日 09:00:00 UTC

為什麼是 1970 年 1 月 1 日?那是 Unix 作業系統開發的時期,設計者需要一個固定的基準點。這個選擇有些隨意,但之後已成為幾乎所有作業系統與程式語言的通用標準。

為什麼電腦使用 Unix 時間

Unix 時間解決了一個出乎意料困難的問題:位於不同時區的系統,要如何對現在是幾點取得共識?

「東京上午 9:00」與「倫敦凌晨 0:00」是同一個瞬間,但以當地時間表示卻不同。Unix 時間把時間表示為以 UTC 計算的單一整數,一舉解決這個問題。資料庫、日誌與 API 可以儲存並交換這個整數,不會有任何時區歧義。轉換成當地時間是在呈現層進行,而不是在儲存時。


秒與毫秒:最常見的陷阱

這是最讓人在除錯時沮喪的錯誤。

語言/情境 單位 位數 範例
Unix 標準、PHP time()、Python time.time() 秒 10 1736823600
JavaScript Date.now()、Java System.currentTimeMillis() 毫秒 13 1736823600000
部分日誌系統 微秒 16 1736823600000000
部分高精度系統 奈秒 19 1736823600000000000

症狀: 把毫秒時間戳記傳給預期為秒的函式,結果出現 1970 年的日期。反過來,把秒傳給以毫秒為基礎的函式,就會得到幾十年後的日期。

解法: 數位數。10 位 → 秒;13 位 → 毫秒。

function detectUnit(ts) {
  const digits = String(Math.abs(ts)).length;
  if (digits <= 10) return 'seconds';
  if (digits <= 13) return 'milliseconds';
  if (digits <= 16) return 'microseconds';
  return 'nanoseconds';
}

在常用語言中使用 Unix 時間

JavaScript / TypeScript

// 目前時間
const nowMs = Date.now();           // 毫秒
const nowSec = Math.floor(nowMs / 1000); // 秒

// 從 Unix 秒轉成 Date 物件
const ts = 1736823600;
const date = new Date(ts * 1000);   // 必須乘以 1000
console.log(date.toISOString());    // "2026-01-14T09:00:00.000Z"

// 從 Date 轉成 Unix 秒
const unixSec = Math.floor(new Date('2026-01-14T09:00:00Z').getTime() / 1000);
console.log(unixSec);               // 1736823600

// 以 Intl.DateTimeFormat 格式化(支援時區)
const formatter = new Intl.DateTimeFormat('ja-JP', {
  timeZone: 'Asia/Tokyo',
  dateStyle: 'full',
  timeStyle: 'long',
});
console.log(formatter.format(date)); // "2026年1月14日水曜日 18:00:00 JST"

Python

import time
from datetime import datetime, timezone, timedelta

# 目前時間
now_sec = time.time()         # float,自 epoch 起的秒數
now_int = int(time.time())    # 整數秒

# 從 Unix 秒轉成 datetime(UTC)
ts = 1736823600
dt_utc = datetime.fromtimestamp(ts, tz=timezone.utc)
print(dt_utc.isoformat())     # 2026-01-14T09:00:00+00:00

# 轉成 JST(UTC+9)
jst = timezone(timedelta(hours=9))
dt_jst = dt_utc.astimezone(jst)
print(dt_jst.isoformat())     # 2026-01-14T18:00:00+09:00

# 從 datetime 轉成 Unix 秒
ts_back = int(dt_utc.timestamp())

Go

import (
    "fmt"
    "time"
)

// 目前的 Unix 時間
now := time.Now().Unix()          // int64,秒
nowMs := time.Now().UnixMilli()   // int64,毫秒

// 從 Unix 秒轉成 time.Time
ts := int64(1736823600)
t := time.Unix(ts, 0).UTC()
fmt.Println(t.Format(time.RFC3339)) // 2026-01-14T09:00:00Z

// 轉成 JST
jst, _ := time.LoadLocation("Asia/Tokyo")
fmt.Println(t.In(jst).Format(time.RFC3339)) // 2026-01-14T18:00:00+09:00

SQL

-- PostgreSQL
SELECT to_timestamp(1736823600);                 -- 2026-01-14 09:00:00+00
SELECT EXTRACT(EPOCH FROM now())::bigint;        -- 目前的 Unix 秒

-- MySQL
SELECT FROM_UNIXTIME(1736823600);               -- 2026-01-14 09:00:00
SELECT UNIX_TIMESTAMP(NOW());                    -- 目前的 Unix 秒

-- SQLite
SELECT datetime(1736823600, 'unixepoch');        -- 2026-01-14 09:00:00
SELECT strftime('%s', 'now');                    -- 目前的 Unix 秒(字串)

時區處理

UTC 是唯一安全的儲存格式

絕不要在資料庫中儲存沒有時區位移的當地時間。像 "2026-01-14 09:00:00" 這樣的值是有歧義的:那是東京的上午 9 點(00:00 UTC),還是紐約的上午 9 點(14:00 UTC)?

原則: 以 Unix 秒儲存(或 PostgreSQL 的 TIMESTAMP WITH TIME ZONE,它在內部會正規化為 UTC),只在顯示給使用者時才轉成當地時間。若要了解 UTC↔JST 的情況(位移速查表,以及 JavaScript 在哪些條件下會悄悄讓日期位移),請參閱 UTC 轉 JST 參考手冊。

夏令時間的陷阱

夏令時間(DST)會讓特定的當地時間變得有歧義(時鐘撥回時,同一個當地時間會出現兩次),或根本不存在(時鐘撥快時,會跳過一個小時)。UTC 沒有夏令時間,這又是為什麼要以 UTC 儲存、顯示時再轉換的另一個理由。

// 看起來正確,但很脆弱:DST 可能讓結果偏差一小時
const local = new Date('2026-03-08 02:30:00'); // 美國 DST 切換期間
// 請改為一律以 UTC 處理:
const utc = new Date('2026-03-08T07:30:00Z');

常見的時區位移

地區 標準位移 DST 位移
UTC +00:00 —
JST(日本) +09:00 無夏令時間
KST(韓國) +09:00 無夏令時間
CST(中國) +08:00 無夏令時間
EST(美東) −05:00 −04:00(EDT)
PST(美西) −08:00 −07:00(PDT)
CET(中歐) +01:00 +02:00(CEST)

日本、韓國與中國不實施夏令時間,這讓在東亞運作的系統處理時間簡單許多。


2038 年問題

Unix 時間通常以 32 位元有號整數儲存。32 位元有號整數的最大值是 2,147,483,647,對應到:

2038 年 1 月 19 日 03:14:07 UTC

過了那一刻,32 位元有號計數器會溢位並繞回最小的負值,使日期顯示為 1901 年 12 月 13 日。這稱為 Y2K38 或 Unix 千禧蟲。

哪些情況會受影響?

  • 嵌入式系統(工業控制器、韌體)
  • 把 time_t 當成 int32_t 使用的舊式 C 程式碼
  • 部分 32 位元 Linux 系統
  • 以 INT(11) 儲存時間戳記的舊資料庫結構

解法: 以 64 位元整數儲存時間戳記。64 位元有號整數可以表示到大約 2920 億年,實際上等於永遠。

現代語言與資料庫預設已使用 64 位元時間:Python 的 datetime、Go 的 time.Time、JavaScript 的 Date(內部使用 64 位元浮點數),以及 PostgreSQL 的 TIMESTAMP 型別,都不受 2038 年問題影響。風險在於舊式 C 程式碼與某些嵌入式環境。


快速換算參考

您手上有 您想要 公式
Unix 秒 毫秒 ts * 1000
毫秒 Unix 秒 Math.floor(ts / 1000)
Unix 秒 ISO 8601 字串 new Date(ts * 1000).toISOString()
ISO 8601 字串 Unix 秒 Math.floor(new Date(str).getTime() / 1000)
Unix 秒 格式化的當地時間 使用帶 timeZone 的 Intl.DateTimeFormat

常見問題

為什麼 new Date(1736823600) 會顯示 1970 年的日期?

您在預期毫秒的地方傳入了秒。JavaScript 的 Date 建構函式永遠預期毫秒。請乘以 1000:new Date(1736823600 * 1000)。

UTC 與 GMT 有什麼差別?

在軟體開發的實務上,UTC 與 GMT 可視為相同。GMT(格林威治標準時間)是歷史上的時區,UTC(協調世界時)則是現代的國際標準。UTC 由原子鐘維持,並以閏秒調整。在程式碼與文件中請使用「UTC」。

該用 Date.now() 還是 new Date().getTime()?

建議使用 Date.now():它稍快一些(不必建立物件),而且更能表達意圖。兩者都會回傳自 Unix epoch 起的毫秒數。

如何處理「3 分鐘前」這類相對時間的顯示?

計算現在與事件時間戳記相差的秒數,再套用門檻:

function timeAgo(unixSeconds) {
  const diff = Math.floor(Date.now() / 1000) - unixSeconds;
  if (diff < 60) return 'just now';
  if (diff < 3600) return `${Math.floor(diff / 60)} minutes ago`;
  if (diff < 86400) return `${Math.floor(diff / 3600)} hours ago`;
  return `${Math.floor(diff / 86400)} days ago`;
}

Unix 時間會受閏秒影響嗎?

嚴格來說不會:Unix 時間不計閏秒。這表示 Unix 時間並非嚴格連續:在正閏秒時,同一個秒數值會重複出現。實務上,作業系統會以「閏秒平滑化」(把調整分散到數小時內)處理,所以大多數應用程式碼完全不必擔心。