本文提到的工具
邊閱讀邊在瀏覽器中開啟工具,立即試試整個流程。
什麼是 Unix 時間?
Unix 時間(也稱為 POSIX 時間、Epoch 時間,或簡稱「時間戳記」)是自 1970 年 1 月 1 日 00:00:00 UTC 起經過的秒數,不計閏秒。

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