Unix 时间戳完整指南

1700000000  →  2023-11-14 22:13:20 UTC
1735689600  →  2025-01-01 00:00:00 UTC

1700000000000  →  2023-11-14 22:13:20.000 UTC
1735689600123  →  2025-01-01 00:00:00.123 UTC

1700000000000000  →  2023-11-14 22:13:20.000000 UTC

1700000000000000000  →  2023-11-14 22:13:20.000000000 UTC

时间差（秒）= 时间戳B - 时间戳A
时间差（天）= (时间戳B - 时间戳A) / 86400

// 获取当前时间戳（毫秒）
const msTimestamp = Date.now();           // 1700000000000
const msTimestamp2 = new Date().getTime(); // 同上

// 获取当前时间戳（秒）
const secTimestamp = Math.floor(Date.now() / 1000); // 1700000000

// 时间戳转日期
const date = new Date(1700000000 * 1000); // 注意：要乘以 1000
console.log(date.toISOString());          // "2023-11-14T22:13:20.000Z"
console.log(date.toLocaleString('zh-CN', { timeZone: 'Asia/Shanghai' }));
// "2023/11/15 上午6:13:20"

// 日期转时间戳
const ts = new Date('2025-01-01T00:00:00Z').getTime() / 1000;
// 1735689600

import time
from datetime import datetime, timezone

# 获取当前时间戳（秒，浮点数）
timestamp = time.time()              # 1700000000.123456

# 获取当前时间戳（秒，整数）
timestamp_int = int(time.time())     # 1700000000

# 时间戳转日期（UTC）
dt_utc = datetime.fromtimestamp(1700000000, tz=timezone.utc)
print(dt_utc)  # 2023-11-14 22:13:20+00:00

# 时间戳转日期（本地时区）
dt_local = datetime.fromtimestamp(1700000000)
print(dt_local)  # 2023-11-15 06:13:20（北京时间 UTC+8）

# 日期转时间戳
dt = datetime(2025, 1, 1, tzinfo=timezone.utc)
ts = int(dt.timestamp())             # 1735689600

<?php
// 获取当前时间戳（秒）
$timestamp = time();                  // 1700000000

// 获取当前时间戳（毫秒）
$msTimestamp = round(microtime(true) * 1000); // 1700000000000

// 时间戳转日期
echo date('Y-m-d H:i:s', 1700000000);
// "2023-11-15 06:13:20"（服务器时区，假设 Asia/Shanghai）

// 指定时区转换
$dt = new DateTime('@1700000000');
$dt->setTimezone(new DateTimeZone('Asia/Shanghai'));
echo $dt->format('Y-m-d H:i:s');     // "2023-11-15 06:13:20"

// 日期转时间戳
$ts = strtotime('2025-01-01 00:00:00 UTC'); // 1735689600
?>

package main

import (
    "fmt"
    "time"
)

func main() {
    // 获取当前时间戳
    now := time.Now()
    secTs := now.Unix()      // 秒级：1700000000
    msTs := now.UnixMilli()  // 毫秒级：1700000000000
    nsTs := now.UnixNano()   // 纳秒级：1700000000000000000

    // 时间戳转日期
    t := time.Unix(1700000000, 0)
    fmt.Println(t.UTC())
    // 2023-11-14 22:13:20 +0000 UTC

    // 转换至上海时区
    loc, _ := time.LoadLocation("Asia/Shanghai")
    fmt.Println(t.In(loc))
    // 2023-11-15 06:13:20 +0800 CST

    // 日期转时间戳
    dt := time.Date(2025, 1, 1, 0, 0, 0, 0, time.UTC)
    fmt.Println(dt.Unix()) // 1735689600
}

import java.time.*;

public class TimestampExample {
    public static void main(String[] args) {
        // 获取当前时间戳（毫秒）
        long msTs = System.currentTimeMillis();       // 1700000000000

        // 获取当前时间戳（秒）
        long secTs = Instant.now().getEpochSecond();  // 1700000000

        // 时间戳转日期（UTC）
        Instant instant = Instant.ofEpochSecond(1700000000L);
        System.out.println(instant);
        // 2023-11-14T22:13:20Z

        // 转换至上海时区
        ZonedDateTime shanghai = instant.atZone(ZoneId.of("Asia/Shanghai"));
        System.out.println(shanghai);
        // 2023-11-15T06:13:20+08:00[Asia/Shanghai]

        // 日期转时间戳
        ZonedDateTime dt = ZonedDateTime.of(
            2025, 1, 1, 0, 0, 0, 0, ZoneId.of("UTC")
        );
        long ts = dt.toEpochSecond(); // 1735689600
    }
}

-- 获取当前时间戳（秒）
SELECT UNIX_TIMESTAMP();                  -- 1700000000

-- 时间戳转日期
SELECT FROM_UNIXTIME(1700000000);         -- '2023-11-15 06:13:20'（服务器时区）

-- 带格式的转换
SELECT FROM_UNIXTIME(1700000000, '%Y-%m-%d %H:%i:%s');

-- 日期转时间戳
SELECT UNIX_TIMESTAMP('2025-01-01 00:00:00');  -- 1735660800（依服务器时区）

-- 查询特定时间范围的数据
SELECT * FROM events
WHERE created_at >= UNIX_TIMESTAMP('2025-01-01')
  AND created_at <  UNIX_TIMESTAMP('2025-02-01');

-- 获取当前时间戳（秒）
SELECT EXTRACT(EPOCH FROM NOW());          -- 1700000000.123456

-- 时间戳转日期
SELECT TO_TIMESTAMP(1700000000);           -- 2023-11-15 06:13:20+08

-- 带时区的转换
SELECT TO_TIMESTAMP(1700000000) AT TIME ZONE 'UTC';
-- 2023-11-14 22:13:20

SELECT TO_TIMESTAMP(1700000000) AT TIME ZONE 'Asia/Shanghai';
-- 2023-11-15 06:13:20

-- 日期转时间戳
SELECT EXTRACT(EPOCH FROM TIMESTAMP WITH TIME ZONE '2025-01-01 00:00:00 UTC');
-- 1735689600

// 错误示范：忽略时区
new Date('2025-01-01 00:00:00')
// 浏览器可能解读为本地时间，也可能解读为 UTC，行为不一致！

// 正确做法：明确指定时区
new Date('2025-01-01T00:00:00+08:00')  // 北京时间
new Date('2025-01-01T00:00:00Z')       // UTC 时间

// 错误：把秒级时间戳直接传给 JavaScript Date
new Date(1700000000)
// 1970-01-20T16:13:20.000Z（错误！差了 1000 倍）

// 正确：秒级时间戳需乘以 1000
new Date(1700000000 * 1000)
// 2023-11-14T22:13:20.000Z（正确）

// 同样地，不要把毫秒级时间戳传给期望秒的函数
// Python: datetime.fromtimestamp(1700000000000) → OverflowError!

// 1969-12-31 00:00:00 UTC
Unix 时间戳: -86400

// 1900-01-01 00:00:00 UTC
Unix 时间戳: -2208988800

// PHP 的 strtotime() 在某些旧版本中不支持 1970 年以前的日期
// MySQL 的 TIMESTAMP 类型范围是 1970-2038，不支持负数
// 但 DATETIME 类型可以存储 1000-01-01 到 9999-12-31

# Python 浮点数精度问题
import time
t = time.time()  # 1700000000.1234567（最后几位可能不精确）

# 如需高精度，使用 time.time_ns()（Python 3.7+）
t_ns = time.time_ns()  # 1700000000123456789（整数，无精度丢失）

// JavaScript 中的陷阱
new Date('2025-01-01')   // 被解析为 UTC 00:00:00
new Date('2025/01/01')   // 被解析为本地时间 00:00:00（差 8 小时！）
new Date('Jan 1, 2025')  // 也是本地时间

// 最安全的做法：使用时间戳或 ISO 8601 格式
new Date(1735689600000)              // 明确无歧义
new Date('2025-01-01T00:00:00Z')     // ISO 8601，明确 UTC

2^31 - 1 = 2,147,483,647

2038 年 1 月 19 日 03:14:07 UTC（星期二）

1901 年 12 月 13 日 20:45:52 UTC（星期五）

2^63 - 1 = 9,223,372,036,854,775,807