Unix时间戳是什么？1970纪元时间详解与实战教程

什么是Unix时间戳？

Unix时间戳（也称为Epoch时间或POSIX时间）是一个表示特定时刻的数字，计算方式为自1970年1月1日00:00:00 UTC（协调世界时）以来经过的秒数。

例如：

0 = 1970年1月1日 00:00:00 UTC
1704067200 = 2024年1月1日 00:00:00 UTC
1735689600 = 2025年1月1日 00:00:00 UTC

为什么使用Unix时间戳？

Unix时间戳是一种通用的时间表示方式，具有以下优势：

简单 - 只是一个整数
通用 - 所有编程语言都支持
无时区问题 - 始终是UTC
易于计算 - 时间差就是简单的减法
紧凑 - 存储效率高

Unix纪元：1970年1月1日

为什么从1970年开始？

1970年1月1日被选为Unix时间的起点有几个历史原因：

Unix诞生时间 - Unix操作系统在1969-1970年开发，选择一个接近的整数年份作为起点很自然
技术限制 - 早期计算机使用32位整数存储时间戳
约定俗成 - 一旦确立，就成为了行业标准

2038年问题

使用32位有符号整数存储Unix时间戳会在2038年1月19日03:14:07 UTC溢出（2,147,483,647秒后）。

解决方案：

使用64位整数（可以表示到2920亿年后）
现代系统已经迁移到64位时间戳

Unix时间戳如何工作

基本概念

当前时间 = Unix纪元 + 时间戳秒数

1970-01-01 00:00:00 UTC + 1,704,067,200秒 = 2024-01-01 00:00:00 UTC

时间戳格式

标准Unix时间戳（秒）：

1704067200

毫秒时间戳（JavaScript常用）：

1704067200000

微秒时间戳：

1704067200000000

编程语言中的Unix时间戳

JavaScript / Node.js


JAVASCRIPT
1// 获取当前Unix时间戳（毫秒）
2const timestampMs = Date.now();
3console.log(timestampMs); // 1704067200000
4
5// 获取Unix时间戳（秒）
6const timestamp = Math.floor(Date.now() / 1000);
7console.log(timestamp); // 1704067200
8
9// 从时间戳创建日期
10const date = new Date(1704067200 * 1000);
11console.log(date.toISOString()); // 2024-01-01T00:00:00.000Z
12
13// 从日期获取时间戳
14const newTimestamp = Math.floor(date.getTime() / 1000);
15console.log(newTimestamp); // 1704067200

Python


PYTHON
1import time
2from datetime import datetime
3
4# 获取当前Unix时间戳
5timestamp = time.time()
6print(timestamp)  # 1704067200.123456
7
8# 获取整数时间戳
9timestamp_int = int(time.time())
10print(timestamp_int)  # 1704067200
11
12# 从时间戳创建datetime对象
13dt = datetime.fromtimestamp(1704067200)
14print(dt)  # 2024-01-01 00:00:00
15
16# 从datetime获取时间戳
17new_timestamp = int(dt.timestamp())
18print(new_timestamp)  # 1704067200
19
20# UTC时间
21utc_dt = datetime.utcfromtimestamp(1704067200)
22print(utc_dt)  # 2024-01-01 00:00:00

PHP


PHP
1<?php
2// 获取当前Unix时间戳
3$timestamp = time();
4echo $timestamp; // 1704067200
5
6// 从时间戳格式化日期
7$date = date('Y-m-d H:i:s', 1704067200);
8echo $date; // 2024-01-01 00:00:00
9
10// 从日期字符串获取时间戳
11$timestamp = strtotime('2024-01-01 00:00:00');
12echo $timestamp; // 1704067200
13
14// 使用DateTime类
15$dt = new DateTime('@1704067200');
16echo $dt->format('Y-m-d H:i:s'); // 2024-01-01 00:00:00
17?>

Java


JAVA
1import java.time.Instant;
2import java.time.LocalDateTime;
3import java.time.ZoneId;
4
5// 获取当前Unix时间戳（秒）
6long timestamp = Instant.now().getEpochSecond();
7System.out.println(timestamp); // 1704067200
8
9// 获取毫秒时间戳
10long timestampMs = System.currentTimeMillis();
11System.out.println(timestampMs); // 1704067200000
12
13// 从时间戳创建Instant
14Instant instant = Instant.ofEpochSecond(1704067200);
15System.out.println(instant); // 2024-01-01T00:00:00Z
16
17// 转换为LocalDateTime
18LocalDateTime ldt = LocalDateTime.ofInstant(instant, ZoneId.of("UTC"));
19System.out.println(ldt); // 2024-01-01T00:00:00
20
21// 从LocalDateTime获取时间戳
22long newTimestamp = ldt.atZone(ZoneId.of("UTC")).toEpochSecond();
23System.out.println(newTimestamp); // 1704067200

Go


GO
1package main
2
3import (
4    "fmt"
5    "time"
6)
7
8func main() {
9    // 获取当前Unix时间戳
10    timestamp := time.Now().Unix()
11    fmt.Println(timestamp) // 1704067200
12
13    // 获取纳秒时间戳
14    timestampNano := time.Now().UnixNano()
15    fmt.Println(timestampNano) // 1704067200000000000
16
17    // 从时间戳创建Time对象
18    t := time.Unix(1704067200, 0)
19    fmt.Println(t) // 2024-01-01 00:00:00 +0000 UTC
20
21    // 格式化时间
22    formatted := t.Format("2006-01-02 15:04:05")
23    fmt.Println(formatted) // 2024-01-01 00:00:00
24
25    // 解析时间字符串并获取时间戳
26    parsed, _ := time.Parse("2006-01-02", "2024-01-01")
27    newTimestamp := parsed.Unix()
28    fmt.Println(newTimestamp) // 1704067200
29}

Unix时间戳的优势

1. 时区无关

Unix时间戳始终表示UTC时间，避免了时区转换的复杂性：


JAVASCRIPT
1// 同一时刻在不同时区
2const timestamp = 1704067200;
3
4// 纽约（UTC-5）
5const nyDate = new Date(timestamp * 1000).toLocaleString('en-US', {
6  timeZone: 'America/New_York'
7}); // 12/31/2023, 7:00:00 PM
8
9// 东京（UTC+9）
10const tokyoDate = new Date(timestamp * 1000).toLocaleString('en-US', {
11  timeZone: 'Asia/Tokyo'
12}); // 1/1/2024, 9:00:00 AM
13
14// 但时间戳相同！

2. 易于计算

时间差计算非常简单：


PYTHON
1# 计算两个日期之间的天数
2start = 1704067200  # 2024-01-01
3end = 1704326400    # 2024-01-04
4
5days = (end - start) / 86400  # 86400秒 = 1天
6print(days)  # 3.0天

3. 数据库友好

大多数数据库都原生支持Unix时间戳：


SQL
1-- MySQL
2SELECT FROM_UNIXTIME(1704067200);
3-- 2024-01-01 00:00:00
4
5-- PostgreSQL
6SELECT to_timestamp(1704067200);
7-- 2024-01-01 00:00:00+00
8
9-- SQLite
10SELECT datetime(1704067200, 'unixepoch');
11-- 2024-01-01 00:00:00

4. API和数据交换

Unix时间戳是API响应中的标准格式：


JSON
1{
2  "created_at": 1704067200,
3  "updated_at": 1704153600,
4  "expires_at": 1704240000
5}

Unix时间戳的局限性

1. 可读性差

1704067200 不如 2024-01-01 直观。

解决方案：在显示时转换为人类可读格式。

2. 精度限制

标准Unix时间戳只精确到秒。

解决方案：

使用毫秒时间戳（JavaScript）
使用微秒或纳秒时间戳（Go、Python）

3. 不包含时区信息

Unix时间戳只表示UTC时间。

解决方案：单独存储时区信息或使用ISO 8601格式。

4. 闰秒问题

Unix时间戳不考虑闰秒，可能导致1秒的偏差。

解决方案：对于需要极高精度的应用，使用TAI（国际原子时）。

最佳实践

1. 始终使用UTC


JAVASCRIPT
1// ❌ 错误：使用本地时间
2const date = new Date('2024-01-01'); // 时区不明确
3
4// ✅ 正确：明确使用UTC
5const date = new Date('2024-01-01T00:00:00Z');

2. 存储时使用时间戳


PYTHON
1# ✅ 数据库中存储Unix时间戳
2user = {
3    'created_at': 1704067200,
4    'updated_at': 1704153600
5}
6
7# 显示时转换为本地时间
8from datetime import datetime
9created = datetime.fromtimestamp(user['created_at'])
10print(created.strftime('%Y-%m-%d %H:%M:%S'))

3. API中使用ISO 8601或Unix时间戳


JSON
1{
2  "timestamp": 1704067200,
3  "iso_date": "2024-01-01T00:00:00Z"
4}

4. 注意精度要求


JAVASCRIPT
1// 秒级精度
2const timestampSec = Math.floor(Date.now() / 1000);
3
4// 毫秒级精度
5const timestampMs = Date.now();
6
7// 根据需求选择

常见用例

1. 日志时间戳


PYTHON
1import time
2
3log_entry = {
4    'timestamp': int(time.time()),
5    'level': 'INFO',
6    'message': 'User logged in'
7}

2. 缓存过期


JAVASCRIPT
1const cache = {
2  data: 'some value',
3  expiresAt: Math.floor(Date.now() / 1000) + 3600 // 1小时后过期
4};
5
6// 检查是否过期
7const isExpired = Math.floor(Date.now() / 1000) > cache.expiresAt;

3. 会话管理


PHP
1<?php
2session_start();
3$_SESSION['login_time'] = time();
4$_SESSION['expires_at'] = time() + 1800; // 30分钟后过期
5
6// 检查会话是否过期
7if (time() > $_SESSION['expires_at']) {
8    session_destroy();
9}
10?>

4. 时间范围查询


SQL
1-- 查询最近7天的记录
2SELECT * FROM events
3WHERE created_at >= UNIX_TIMESTAMP(DATE_SUB(NOW(), INTERVAL 7 DAY));

常见问题

Unix时间戳会在2038年溢出吗？

使用32位有符号整数会溢出，但现代系统使用64位整数，可以表示到2920亿年后。

Unix时间戳包含时区吗？

不包含。Unix时间戳始终表示UTC时间。

如何处理毫秒时间戳？

JavaScript使用毫秒，其他语言通常使用秒。转换时注意乘以或除以1000。


JAVASCRIPT
1// JavaScript（毫秒）→ Python（秒）
2const jsTimestamp = Date.now(); // 1704067200000
3const pyTimestamp = Math.floor(jsTimestamp / 1000); // 1704067200

Unix时间戳和ISO 8601哪个更好？

Unix时间戳：计算方便、存储紧凑
ISO 8601：可读性好、包含时区信息

建议：存储用时间戳，显示用ISO 8601。

总结

Unix时间戳是一种简单、通用、高效的时间表示方式：

优势：

简单的整数格式
时区无关（UTC）
易于计算和比较
所有编程语言都支持
数据库友好

最佳实践：

存储时使用Unix时间戳
显示时转换为本地时间
始终使用UTC
注意精度要求（秒/毫秒）
API中提供ISO 8601作为备选

准备好使用Unix时间戳了吗？试试我们的Unix时间戳转换器↗和时间戳计算器↗工具！

什么是Unix时间戳？

Unix时间戳（也称为Epoch时间或POSIX时间）是一个表示特定时刻的数字，计算方式为自1970年1月1日00:00:00 UTC（协调世界时）以来经过的秒数。

例如：

0 = 1970年1月1日 00:00:00 UTC
1704067200 = 2024年1月1日 00:00:00 UTC
1735689600 = 2025年1月1日 00:00:00 UTC

为什么使用Unix时间戳？

Unix时间戳是一种通用的时间表示方式，具有以下优势：

简单 - 只是一个整数
通用 - 所有编程语言都支持
无时区问题 - 始终是UTC
易于计算 - 时间差就是简单的减法
紧凑 - 存储效率高

Unix纪元：1970年1月1日

为什么从1970年开始？

1970年1月1日被选为Unix时间的起点有几个历史原因：

Unix诞生时间 - Unix操作系统在1969-1970年开发，选择一个接近的整数年份作为起点很自然
技术限制 - 早期计算机使用32位整数存储时间戳
约定俗成 - 一旦确立，就成为了行业标准

2038年问题

使用32位有符号整数存储Unix时间戳会在2038年1月19日03:14:07 UTC溢出（2,147,483,647秒后）。

解决方案：

使用64位整数（可以表示到2920亿年后）
现代系统已经迁移到64位时间戳

Unix时间戳如何工作

基本概念

当前时间 = Unix纪元 + 时间戳秒数

1970-01-01 00:00:00 UTC + 1,704,067,200秒 = 2024-01-01 00:00:00 UTC

时间戳格式

标准Unix时间戳（秒）：

1704067200

毫秒时间戳（JavaScript常用）：

1704067200000

微秒时间戳：

1704067200000000

编程语言中的Unix时间戳

JavaScript / Node.js


JAVASCRIPT
1// 获取当前Unix时间戳（毫秒）
2const timestampMs = Date.now();
3console.log(timestampMs); // 1704067200000
4
5// 获取Unix时间戳（秒）
6const timestamp = Math.floor(Date.now() / 1000);
7console.log(timestamp); // 1704067200
8
9// 从时间戳创建日期
10const date = new Date(1704067200 * 1000);
11console.log(date.toISOString()); // 2024-01-01T00:00:00.000Z
12
13// 从日期获取时间戳
14const newTimestamp = Math.floor(date.getTime() / 1000);
15console.log(newTimestamp); // 1704067200

Python


PYTHON
1import time
2from datetime import datetime
3
4# 获取当前Unix时间戳
5timestamp = time.time()
6print(timestamp)  # 1704067200.123456
7
8# 获取整数时间戳
9timestamp_int = int(time.time())
10print(timestamp_int)  # 1704067200
11
12# 从时间戳创建datetime对象
13dt = datetime.fromtimestamp(1704067200)
14print(dt)  # 2024-01-01 00:00:00
15
16# 从datetime获取时间戳
17new_timestamp = int(dt.timestamp())
18print(new_timestamp)  # 1704067200
19
20# UTC时间
21utc_dt = datetime.utcfromtimestamp(1704067200)
22print(utc_dt)  # 2024-01-01 00:00:00

PHP


PHP
1<?php
2// 获取当前Unix时间戳
3$timestamp = time();
4echo $timestamp; // 1704067200
5
6// 从时间戳格式化日期
7$date = date('Y-m-d H:i:s', 1704067200);
8echo $date; // 2024-01-01 00:00:00
9
10// 从日期字符串获取时间戳
11$timestamp = strtotime('2024-01-01 00:00:00');
12echo $timestamp; // 1704067200
13
14// 使用DateTime类
15$dt = new DateTime('@1704067200');
16echo $dt->format('Y-m-d H:i:s'); // 2024-01-01 00:00:00
17?>

Java


JAVA
1import java.time.Instant;
2import java.time.LocalDateTime;
3import java.time.ZoneId;
4
5// 获取当前Unix时间戳（秒）
6long timestamp = Instant.now().getEpochSecond();
7System.out.println(timestamp); // 1704067200
8
9// 获取毫秒时间戳
10long timestampMs = System.currentTimeMillis();
11System.out.println(timestampMs); // 1704067200000
12
13// 从时间戳创建Instant
14Instant instant = Instant.ofEpochSecond(1704067200);
15System.out.println(instant); // 2024-01-01T00:00:00Z
16
17// 转换为LocalDateTime
18LocalDateTime ldt = LocalDateTime.ofInstant(instant, ZoneId.of("UTC"));
19System.out.println(ldt); // 2024-01-01T00:00:00
20
21// 从LocalDateTime获取时间戳
22long newTimestamp = ldt.atZone(ZoneId.of("UTC")).toEpochSecond();
23System.out.println(newTimestamp); // 1704067200

Go


GO
1package main
2
3import (
4    "fmt"
5    "time"
6)
7
8func main() {
9    // 获取当前Unix时间戳
10    timestamp := time.Now().Unix()
11    fmt.Println(timestamp) // 1704067200
12
13    // 获取纳秒时间戳
14    timestampNano := time.Now().UnixNano()
15    fmt.Println(timestampNano) // 1704067200000000000
16
17    // 从时间戳创建Time对象
18    t := time.Unix(1704067200, 0)
19    fmt.Println(t) // 2024-01-01 00:00:00 +0000 UTC
20
21    // 格式化时间
22    formatted := t.Format("2006-01-02 15:04:05")
23    fmt.Println(formatted) // 2024-01-01 00:00:00
24
25    // 解析时间字符串并获取时间戳
26    parsed, _ := time.Parse("2006-01-02", "2024-01-01")
27    newTimestamp := parsed.Unix()
28    fmt.Println(newTimestamp) // 1704067200
29}

Unix时间戳的优势

1. 时区无关

Unix时间戳始终表示UTC时间，避免了时区转换的复杂性：


JAVASCRIPT
1// 同一时刻在不同时区
2const timestamp = 1704067200;
3
4// 纽约（UTC-5）
5const nyDate = new Date(timestamp * 1000).toLocaleString('en-US', {
6  timeZone: 'America/New_York'
7}); // 12/31/2023, 7:00:00 PM
8
9// 东京（UTC+9）
10const tokyoDate = new Date(timestamp * 1000).toLocaleString('en-US', {
11  timeZone: 'Asia/Tokyo'
12}); // 1/1/2024, 9:00:00 AM
13
14// 但时间戳相同！

2. 易于计算

时间差计算非常简单：


PYTHON
1# 计算两个日期之间的天数
2start = 1704067200  # 2024-01-01
3end = 1704326400    # 2024-01-04
4
5days = (end - start) / 86400  # 86400秒 = 1天
6print(days)  # 3.0天

3. 数据库友好

大多数数据库都原生支持Unix时间戳：


SQL
1-- MySQL
2SELECT FROM_UNIXTIME(1704067200);
3-- 2024-01-01 00:00:00
4
5-- PostgreSQL
6SELECT to_timestamp(1704067200);
7-- 2024-01-01 00:00:00+00
8
9-- SQLite
10SELECT datetime(1704067200, 'unixepoch');
11-- 2024-01-01 00:00:00

4. API和数据交换

Unix时间戳是API响应中的标准格式：


JSON
1{
2  "created_at": 1704067200,
3  "updated_at": 1704153600,
4  "expires_at": 1704240000
5}

Unix时间戳的局限性

1. 可读性差

1704067200 不如 2024-01-01 直观。

解决方案：在显示时转换为人类可读格式。

2. 精度限制

标准Unix时间戳只精确到秒。

解决方案：

使用毫秒时间戳（JavaScript）
使用微秒或纳秒时间戳（Go、Python）

3. 不包含时区信息

Unix时间戳只表示UTC时间。

解决方案：单独存储时区信息或使用ISO 8601格式。

4. 闰秒问题

Unix时间戳不考虑闰秒，可能导致1秒的偏差。

解决方案：对于需要极高精度的应用，使用TAI（国际原子时）。

最佳实践

1. 始终使用UTC


JAVASCRIPT
1// ❌ 错误：使用本地时间
2const date = new Date('2024-01-01'); // 时区不明确
3
4// ✅ 正确：明确使用UTC
5const date = new Date('2024-01-01T00:00:00Z');

2. 存储时使用时间戳


PYTHON
1# ✅ 数据库中存储Unix时间戳
2user = {
3    'created_at': 1704067200,
4    'updated_at': 1704153600
5}
6
7# 显示时转换为本地时间
8from datetime import datetime
9created = datetime.fromtimestamp(user['created_at'])
10print(created.strftime('%Y-%m-%d %H:%M:%S'))

3. API中使用ISO 8601或Unix时间戳


JSON
1{
2  "timestamp": 1704067200,
3  "iso_date": "2024-01-01T00:00:00Z"
4}

4. 注意精度要求


JAVASCRIPT
1// 秒级精度
2const timestampSec = Math.floor(Date.now() / 1000);
3
4// 毫秒级精度
5const timestampMs = Date.now();
6
7// 根据需求选择

常见用例

1. 日志时间戳


PYTHON
1import time
2
3log_entry = {
4    'timestamp': int(time.time()),
5    'level': 'INFO',
6    'message': 'User logged in'
7}

2. 缓存过期


JAVASCRIPT
1const cache = {
2  data: 'some value',
3  expiresAt: Math.floor(Date.now() / 1000) + 3600 // 1小时后过期
4};
5
6// 检查是否过期
7const isExpired = Math.floor(Date.now() / 1000) > cache.expiresAt;

3. 会话管理


PHP
1<?php
2session_start();
3$_SESSION['login_time'] = time();
4$_SESSION['expires_at'] = time() + 1800; // 30分钟后过期
5
6// 检查会话是否过期
7if (time() > $_SESSION['expires_at']) {
8    session_destroy();
9}
10?>

4. 时间范围查询


SQL
1-- 查询最近7天的记录
2SELECT * FROM events
3WHERE created_at >= UNIX_TIMESTAMP(DATE_SUB(NOW(), INTERVAL 7 DAY));

常见问题

Unix时间戳会在2038年溢出吗？

使用32位有符号整数会溢出，但现代系统使用64位整数，可以表示到2920亿年后。

Unix时间戳包含时区吗？

不包含。Unix时间戳始终表示UTC时间。

如何处理毫秒时间戳？

JavaScript使用毫秒，其他语言通常使用秒。转换时注意乘以或除以1000。


JAVASCRIPT
1// JavaScript（毫秒）→ Python（秒）
2const jsTimestamp = Date.now(); // 1704067200000
3const pyTimestamp = Math.floor(jsTimestamp / 1000); // 1704067200

Unix时间戳和ISO 8601哪个更好？

Unix时间戳：计算方便、存储紧凑
ISO 8601：可读性好、包含时区信息

建议：存储用时间戳，显示用ISO 8601。

总结

Unix时间戳是一种简单、通用、高效的时间表示方式：

优势：

简单的整数格式
时区无关（UTC）
易于计算和比较
所有编程语言都支持
数据库友好

最佳实践：

存储时使用Unix时间戳
显示时转换为本地时间
始终使用UTC
注意精度要求（秒/毫秒）
API中提供ISO 8601作为备选