Unix时间戳是什么？时间戳原理、秒级毫秒级区别与转换指南

在软件开发、数据处理和网络接口开发过程中，时间是非常常见的数据类型。

例如：

用户注册时间
用户登录时间
订单创建时间
文件修改时间
系统日志时间
数据库记录时间
接口请求时间
Token过期时间
定时任务执行时间

如果直接使用日期字符串保存和传输时间，就可能受到不同地区、时区以及日期格式的影响。

例如：

2026-08-06 10:30:00

不同系统可能使用：

2026/08/06 10:30:00

或者：

2026-08-06T10:30:00+08:00

为了让计算机更加方便地保存、比较和计算时间，开发中经常使用 Unix Timestamp，也就是 Unix 时间戳。

时间戳是一种非常常见的时间表示方式，在 Web 开发、数据库、API 接口、日志系统以及各种编程语言中都有广泛应用。

什么是Unix时间戳？

Unix时间戳（Unix Timestamp）是一种表示时间的方式。

它通常表示：

从 1970 年 1 月 1 日 00:00:00 UTC 开始，到指定时间经过的秒数。

这个时间点被称为：

Unix Epoch

也就是 Unix 时间纪元。

例如：

1970-01-01 00:00:00 UTC

对应的 Unix 时间戳：

随着时间不断向前，时间戳也不断增加。

例如：

1970年
↓
0

1970年之后
↓
时间戳不断增加

当前时间
↓
更大的时间戳

因此，可以简单理解：

Unix 时间戳就是从 Unix 时间纪元开始计算的时间数值。

Unix Epoch是什么？

Unix Epoch 是 Unix 时间戳计算的起点。

标准定义为：

1970-01-01 00:00:00 UTC

也就是说：

Unix Timestamp = 0

例如：

1970-01-01 00:00:00 UTC
→ 0

如果经过 1 秒：

1970-01-01 00:00:01 UTC
→ 1

经过 60 秒：

1970-01-01 00:01:00 UTC
→ 60

经过 3600 秒：

1970-01-01 01:00:00 UTC
→ 3600

因此时间戳本质上是一个不断变化的数字。

Unix时间戳为什么从1970年开始？

1970 年并不是人类历史上的特殊时间点。

它主要是 Unix 操作系统早期设计中选择的一个时间起点。

Unix 系统采用这个时间点之后，Unix 时间戳逐渐成为计算机系统中非常常见的时间表示方式。

随着 Unix、Linux、Web 服务和各种编程语言的发展，这种表示方式逐渐成为软件开发中的通用方案之一。

Unix时间戳有什么特点？

时间戳最大的特点是：

使用数字表示时间。

例如：

2026-08-06 12:00:00

可以表示成类似：

1786017600

具体数值取决于时间以及使用的时间单位。

相比日期字符串，时间戳更加适合计算机进行：

时间比较
时间排序
时间计算
数据库保存
API传输
日志记录

时间戳为什么方便计算？

假设两个时间分别为：

时间A
2026-08-06 10:00:00

时间B
2026-08-06 12:00:00

如果使用日期字符串计算两个时间之间的差值，需要解析日期。

而如果转换成 Unix 时间戳：

时间A → 1786xxxxxx
时间B → 1786xxxxxx

两个数字直接相减即可得到时间差。

例如：

时间差 = 时间B时间戳 - 时间A时间戳

如果结果为：

那么两个时间相差：

7200秒

也就是：

2小时

因此，时间戳非常适合计算机进行时间运算。

秒级时间戳是什么？

最传统的 Unix 时间戳使用：

秒

作为时间单位。

例如：

1786000000

这种通常就是秒级 Unix 时间戳。

它表示从 Unix Epoch 到目标时间经过的秒数。

秒级时间戳通常用于：

后端接口
Linux系统
数据库
JWT
日志
定时任务

毫秒级时间戳是什么？

随着 Web 应用和实时系统的发展，秒级精度有时不够。

例如：

2026-08-06 12:00:00.123

这里不仅包含秒，还包含：

123毫秒

因此很多程序会使用：

毫秒级时间戳

毫秒级时间戳表示：

从 Unix Epoch 开始经过的毫秒数。

由于：

1秒 = 1000毫秒

因此：

毫秒时间戳 = 秒时间戳 × 1000

例如：

秒级：
1786000000

毫秒级：
1786000000000

秒级和毫秒级时间戳有什么区别？

这是开发过程中非常容易遇到的问题。

类型	单位	常见长度	常见场景
秒级时间戳	秒	约10位	Unix、Linux、JWT
毫秒级时间戳	毫秒	约13位	JavaScript、Java、Web
微秒级时间戳	微秒	约16位	高精度系统
纳秒级时间戳	纳秒	约19位	高精度计时

目前 Web 开发中最常见的是：

10位左右 → 秒
13位左右 → 毫秒

但是不能仅仅通过数字长度判断单位。

最可靠的方式是结合接口文档、程序定义和上下文判断。

如何判断时间戳是秒还是毫秒？

实际开发中经常遇到：

1786000000

和：

1786000000000

通常：

10位左右
→ 秒级

而：

13位左右
→ 毫秒级

例如 JavaScript：

const timestamp = Date.now();

返回的是：

毫秒级时间戳

而 Unix/Linux 中常见的：

date +%s

通常返回：

秒级时间戳

秒级时间戳转换为毫秒级

如果已经有秒级时间戳：

1786000000

转换成毫秒：

1786000000 × 1000

结果：

1786000000000

JavaScript：

const seconds = 1786000000;

const milliseconds = seconds * 1000;

console.log(milliseconds);

毫秒级时间戳转换为秒级

如果有：

1786000000000

需要转换成秒：

const milliseconds = 1786000000000;

const seconds = Math.floor(milliseconds / 1000);

console.log(seconds);

需要注意：

毫秒转换为秒时，如果直接进行整数转换，小数部分会被舍弃。

时间戳与日期有什么区别？

时间戳和日期字符串都可以表示时间，但是表现形式不同。

例如：

Unix时间戳：

1786000000

日期：

2026-08-06 12:00:00

时间戳更加适合计算机处理。

日期字符串更加适合人类阅读。

因此：

时间戳
→ 程序处理

日期时间
→ 人类阅读

实际项目中通常会根据场景选择不同形式。

时间戳与时区有什么关系？

这是理解 Unix 时间戳时非常重要的一点。

Unix 时间戳本身表示的是一个绝对时间点。

它通常以：

UTC

作为计算基准。

时间戳本身没有：

北京时间
东京时间
纽约时间
伦敦时间

这样的时区信息。

时区主要影响：

时间戳转换成日期字符串时显示的结果。

例如同一个时间戳：

1786000000

在不同地区可能显示成不同的本地时间。

所以：

同一个时间戳
        ↓
不同的时区
        ↓
不同的本地日期时间

但它们实际上可能表示的是同一个瞬间。

UTC与北京时间

中国大陆常用：

UTC+8

也就是北京时间。

因此：

UTC时间
+
8小时
=
北京时间

例如：

UTC：
04:00:00

北京时间：
12:00:00

两者表示的是同一个时间点。

JavaScript获取时间戳

JavaScript 中最常用的方法之一：

Date.now();

当前时间的毫秒级时间戳

例如：

const timestamp = Date.now();

console.log(timestamp);

JavaScript获取秒级时间戳

可以使用：

const timestamp = Math.floor(Date.now() / 1000);

console.log(timestamp);

其中：

Date.now()

得到毫秒。

除以：

得到秒。

再使用：

Math.floor()

去掉小数部分。

JavaScript时间戳转换为日期

例如：

const timestamp = 1786000000000;

const date = new Date(timestamp);

console.log(date);

这里的时间戳是：

毫秒级

如果使用的是秒级时间戳：

const timestamp = 1786000000;

const date = new Date(timestamp * 1000);

console.log(date);

这是非常常见的开发场景。

Java中的时间戳

Java 可以使用：

System.currentTimeMillis();

获取当前时间的毫秒级时间戳。

例如：

long timestamp = System.currentTimeMillis();

System.out.println(timestamp);

如果需要秒级：

long timestamp = System.currentTimeMillis() / 1000;

System.out.println(timestamp);

Java使用Instant获取时间戳

现代 Java 项目中也可以使用：

Instant.now().getEpochSecond();

获取秒级时间戳。

获取毫秒级：

Instant.now().toEpochMilli();

例如：

long seconds = Instant.now().getEpochSecond();

long milliseconds = Instant.now().toEpochMilli();

Python获取时间戳

Python 可以使用：

import time

timestamp = time.time()

print(timestamp)

返回的通常是包含小数的秒级时间。

例如：

1786000000.123456

如果需要整数秒：

import time

timestamp = int(time.time())

print(timestamp)

如果需要毫秒：

import time

timestamp = int(time.time() * 1000)

print(timestamp)

PHP获取时间戳

PHP 可以使用：

$timestamp = time();

echo $timestamp;

time() 返回当前 Unix 时间戳，单位为秒。

如果需要微秒级时间，可以使用：

microtime(true);

MySQL获取Unix时间戳

MySQL 可以使用：

SELECT UNIX_TIMESTAMP();

获取当前 Unix 时间戳。

也可以将日期转换为时间戳：

SELECT UNIX_TIMESTAMP('2026-08-06 12:00:00');

MySQL时间戳转换为日期

可以使用：

SELECT FROM_UNIXTIME(1786000000);

例如：

SELECT
    FROM_UNIXTIME(create_time)
FROM user;

如果数据库中保存的是秒级时间戳，可以直接转换。

如果保存的是毫秒级时间戳，则需要先除以：

例如：

SELECT FROM_UNIXTIME(timestamp / 1000);

Linux获取Unix时间戳

Linux 中可以使用：

date +%s

获取当前秒级时间戳。

例如：

$ date +%s
1786000000

获取当前时间：

date

Unix时间戳常见应用场景

1. 数据库存储

数据库可以使用时间字段保存：

created_at
updated_at
deleted_at

也可以保存 Unix 时间戳：

created_at = 1786000000

具体采用哪种方式，需要根据项目需求决定。

2. API接口

很多 API 接口会使用：

{
  "createdAt": 1786000000
}

相比日期字符串，数字时间戳更加方便程序处理。

但 API 文档必须明确：

使用秒还是毫秒。

否则前后端非常容易出现时间错误。

3. 日志系统

日志经常需要记录：

请求时间
响应时间
异常时间
登录时间

时间戳可以方便日志排序和时间差计算。

4. Token过期时间

JWT 等认证系统经常使用时间戳表示：

iat
exp

例如：

iat = 签发时间

exp = 过期时间

通过比较当前时间戳和 exp 就可以判断 Token 是否过期。

5. 文件处理

文件系统经常需要记录：

创建时间
修改时间
访问时间

时间戳适合进行排序和比较。

6. 定时任务

程序需要判断：

任务什么时候执行？
任务是否已经过期？
距离执行还有多久？

时间戳非常适合进行时间计算。

时间戳计算示例

假设当前时间：

1700000000

目标时间：

1700003600

那么：

1700003600 - 1700000000
= 3600

也就是：

1小时

常见的时间计算：

60秒
= 1分钟

3600秒
= 1小时

86400秒
= 1天

因此可以通过时间戳快速计算时间差。

时间戳比较大小

假设：

时间A = 1786000000
时间B = 1786003600

因为：

1786003600 > 1786000000

所以：

时间B晚于时间A

这也是时间戳适合排序的原因。

时间戳常见错误

秒和毫秒混用

这是最常见的问题。

例如后端返回：

1786000000

前端直接：

new Date(1786000000)

JavaScript 会将它当成毫秒。

结果得到的时间可能完全错误。

如果后端返回的是秒：

new Date(1786000000 * 1000)

才是正确的处理方式。

时间戳单位不一致

项目中可能出现：

数据库：秒

后端：秒

前端：毫秒

这种情况下如果没有明确转换规则，就很容易出现问题。

建议在 API 文档中明确：

createdAt:
类型：integer
单位：milliseconds

或者：

createdAt:
类型：integer
单位：seconds

JavaScript中的2038问题

传统 Unix 时间通常使用 32 位有符号整数表示秒数。

这种表示方式存在一个著名的：

Year 2038 Problem

当时间超过 2038 年附近的范围时，32 位有符号整数可能发生溢出。

现代系统通常已经使用：

64位整数
64位时间类型
更大的时间表示方式

因此现代开发中不应该再简单假设所有 Unix 时间都限制在 32 位整数范围内。

时间戳是否会重复？

正常情况下，秒级时间戳每秒变化一次。

因此同一秒内产生的多个事件可能具有相同的秒级时间戳。

例如：

10:00:00.001
10:00:00.200
10:00:00.900

如果全部转换为秒：

10:00:00
10:00:00
10:00:00

它们可能得到相同的秒级时间戳。

如果业务需要更高精度，可以考虑使用：

毫秒
微秒
纳秒
UUID
数据库自增ID

具体方案需要根据业务需求选择。

Unix时间戳的优点

Unix 时间戳具有很多优点。

统一

不同系统可以使用数字表示同一个时间点。

方便计算

可以直接进行：

加法
减法
比较
排序

传输简单

JSON 中可以直接传递：

{
  "timestamp": 1786000000
}

跨语言

Java、JavaScript、Python、PHP、Go、C++ 等语言都支持 Unix 时间戳。

Unix时间戳的缺点

时间戳虽然方便，但也存在一些问题。

可读性差

例如：

1786000000

人类无法直接看出具体日期。

而：

2026-08-06 12:00:00

更加直观。

容易产生单位错误

例如：

秒

和：

毫秒

如果混用，就会导致日期严重错误。

时区处理需要注意

时间戳本身表示的是时间点，而最终显示成什么本地时间，还需要结合时区。

时间戳使用最佳实践

在项目中使用时间戳时，建议遵循以下原则。

1. 明确单位

必须明确：

seconds

还是：

milliseconds

不要只写：

timestamp

2. API统一规范

例如整个系统统一使用：

毫秒级时间戳

或者：

秒级时间戳

避免不同接口采用不同标准。

3. 内部统一时间标准

大型项目中可以约定：

数据库
↓
后端
↓
API
↓
前端

统一时间处理方式。

4. 显示时再转换

程序内部可以使用时间戳进行计算。

用户界面显示：

2026-08-06 12:30:00

这样可以兼顾：

程序处理效率和用户阅读体验。

在线时间戳转换工具

如果不想通过代码进行时间戳转换，可以使用在线时间戳工具。

时间戳工具通常可以完成：

当前时间戳查询
时间戳转日期
日期转时间戳
秒级时间戳转换
毫秒级时间戳转换
时间差计算
时间格式转换

例如：

在线时间戳转换工具

使用方法通常非常简单：

输入时间戳
    ↓
选择秒/毫秒
    ↓
转换
    ↓
获得日期时间

也可以反过来：

输入日期时间
    ↓
选择时区
    ↓
转换
    ↓
获得Unix时间戳

时间戳转换示例

例如输入：

1786000000

如果选择：

秒级

工具会将它按照秒进行转换。

如果输入：

1786000000000

则应该选择：

毫秒级

如果单位选择错误，就可能得到完全不正确的日期。

因此在使用时间戳转换工具时，首先要确认：

当前时间戳到底是秒级还是毫秒级。

时间戳开发排错方法

当程序出现时间错误时，可以按照下面的方法检查。

第一步：检查原始值

例如：

1786000000

还是：

1786000000000

第二步：确认单位

检查接口文档：

seconds

还是：

milliseconds

第三步：检查时区

确认程序使用：

UTC

还是：

UTC+8

第四步：检查转换代码

JavaScript：

new Date(timestamp * 1000)

还是：

new Date(timestamp)

两者处理的单位不同。

第五步：检查数据库字段

确认数据库保存的是：

DATETIME

还是：

BIGINT

如果是 BIGINT，还需要确认保存的是秒还是毫秒。

时间戳常见问题

Unix时间戳从什么时候开始？

Unix 时间戳通常从：

1970-01-01 00:00:00 UTC

开始计算。

Unix时间戳是秒还是毫秒？

传统 Unix 时间戳通常指：

秒

但现代 Web 开发中也经常使用：

毫秒

所以看到一个时间戳时，应该结合上下文确认单位。

JavaScript时间戳是秒还是毫秒？

JavaScript：

Date.now()

毫秒级

而：

Math.floor(Date.now() / 1000)

可以得到：

秒级

MySQL时间戳是秒还是毫秒？

MySQL：

UNIX_TIMESTAMP()

返回的是秒级 Unix 时间戳。

如果项目保存的是毫秒级时间戳，则通常需要自行进行转换。

时间戳与时区有关吗？

时间戳表示的是一个绝对时间点。

转换为人类可读的日期时，需要结合时区。

因此同一个时间戳，在不同地区显示的本地时间可能不同。

时间戳可以用于排序吗？

可以。

在单位一致的情况下，时间戳非常适合进行时间排序。

例如：

1000
2000
3000

数字越大，表示的时间通常越晚。

总结

Unix 时间戳是软件开发中非常重要的一种时间表示方式。

它以：

1970-01-01 00:00:00 UTC

作为时间计算起点，通过数字表示某个时间点。

开发中最常见的两种时间戳是：

秒级时间戳

和：

毫秒级时间戳

需要特别注意：

秒 ≠ 毫秒

两者相差：

1000倍

在实际开发中，时间戳广泛应用于：

API接口
数据库
日志系统
用户注册
订单系统
Token认证
定时任务
文件管理
数据排序

使用时间戳时，最重要的是统一：

时间单位、时区和数据格式。

如果只是进行日常的时间戳与日期转换，可以直接使用在线时间戳工具完成转换，不需要手动编写代码。