Unix时间戳转换工具 - 时间戳与日期互转、秒/毫秒与当前时间戳
🌟 凌晨两点,日志里只有一串数字
线上告警,订单状态不对。你打开日志,看到这样几行:
2026-10-25T00:17:03Z [order] created_at=17928864002026-10-25T00:17:03Z [order] expire_at=1792900800000一个 10 位,一个 13 位。一个是创建时间,一个是过期时间,可你盯着这两串数字,既不知道它们对应哪一天、哪个时区,也看不出哪个更晚。翻接口文档,写着 “timestamp, seconds”,但前端传上来的明明是 13 位;再去数据库里查,字段类型是 bigint,存的是秒。这时候你要的不是”时间戳是什么”的科普,而是把这串数字立刻翻成一个能看懂的时间,然后决定下一步查什么。
这类场景几乎每个后端、运维、数据分析的人都遇到过:
- 日志里只有
ts=1792886400,旁边没有可读时间; - 接口 A 返回秒,接口 B 返回毫秒,联调时字段对不上;
- 数据库里存的是
int秒,报表系统按毫秒解读,出来的日期是 1970 年; - 用户在北京,服务器在 UTC,同一句”今天 0 点”在两边指的不是同一个瞬间;
- 排查跨时区问题,需要同时看本地时间、UTC 和 RFC3339 字符串;
- 想给测试数据填一个”现在”的时间戳,又怕复制到一半数字跳了。
星点 时间戳转换工具 把这几件事收在一个页面里:时间戳和日期时间双向互转、实时当前时间戳、秒和毫秒的单位换算。全部计算在浏览器本地完成,输入不上传。
🧭 Unix 时间戳到底是什么
Unix 时间戳(Unix timestamp),也叫 epoch time、POSIX time,指的是从 1970 年 1 月 1 日 00:00:00 UTC 起,到某个瞬间经过的秒数。这个起点叫 Unix epoch,是所有 Unix 系系统和大多数编程语言共同采用的时间基准。
有几个性质必须先记住,后面所有坑都是从这儿来的。
第一,它是一个瞬间,不是一个日期。 时间戳本身不带时区。1792886400 这个数在全世界都指向同一个瞬间,只是在北京显示为 2026-10-25 08:00:00,在东京显示为 2026-10-25 09:00:00,在纽约显示为 2026-10-24 20:00:00。时区只在”把瞬间显示成人能读的钟表时间”这一步参与,不参与存储和比较。
起点定在 1970 年不是因为它有什么天文意义,而是早期 Unix 需要一个足够早、又能在 32 位整数里装得下的整年起点,当时选了最近的整年。这个选择的直接后果就是:32 位有符号整数最多表示到 2038 年,也就是后面要讲的 2038 问题。
第二,它不含闰秒。 Unix 时间把每一天当作固定的 86400 秒。UTC 插入闰秒的那一天,实际有 86401 秒,但 Unix 时间不会出现 23:59:60 这个值,也不会因此多走一秒。自 1972 年开始引入闰秒,最近一次是 2016 年 12 月 31 日。结果是 Unix 时间与”真实物理经过时间”之间存在累积偏移:日常业务完全无感,天文、授时、长时间精密计时才需要在意,那种场景要用 TAI 或单调时钟。
第三,它是整数。 秒级时间戳是整数,毫秒级也是整数。1700000000.123 这种写法是”秒 + 小数秒”,不是标准的时间戳表示。不少解析器会截断、四舍五入或者直接报错,把它当时间戳输入很容易丢掉精度。
第四,它有符号。 1970 年之前的时刻用负数表示,-1 就是 1969-12-31 23:59:59 UTC。负时间戳不是”非法值”,只是很多系统在设计时没考虑过 1970 年以前的数据。
秒和毫秒的关系很简单:1 秒 = 1000 毫秒,同一瞬间,秒级数值乘以 1000 就是毫秒级数值。
| 表示 | 数值 | 对应时刻(UTC) |
|---|---|---|
| 秒级 | 1792886400 | 2026-10-25 00:00:00 |
| 毫秒级 | 1792886400000 | 2026-10-25 00:00:00 |
看起来只是多了三个 0,但在代码里把 13 位当 10 位处理,或者反过来,结果会差得离谱。这一点在”常见错误”里会专门展开。
🚀 三个视图,覆盖时间戳的日常操作
工具把功能分成三个视图,各管一件事:转换、当前时间、单位换算。
转换视图:时间戳 ⇄ 日期时间
这是用得最多的一个。先选输入类型。
输入时间戳时,粘贴一串数字,单位可以选「自动」「秒」「毫秒」。选「自动」时,工具会根据数值给出判断,并且把判断结果显示出来,不会默默替你决定。你要是知道这串数字的真实单位,手动选「秒」或「毫秒」更稳。
输入日期时间时,支持 ISO 8601 / RFC 3339 写法(如 2026-10-25T08:00:00+08:00),也支持 YYYY-MM-DD HH:mm:ss 这种常见格式,旁边可以指定这个时间属于哪个时区。指定时区这一步不能省:同样是”2026-10-25 00:00:00”,标成 UTC 和标成北京时间,相差 8 小时,对应的时间戳也差 28800。
输入完,结果区立刻给出本地时间、UTC、RFC3339、Unix 秒、Unix 毫秒、星期和偏移。每一项都能单独复制,粘到工单、文档、聊天窗口里都方便。
日期输入有严格校验。写 2026-02-30 这种不存在的日期会直接报错,而不是悄悄帮你”归一化”成 3 月 2 日。排查数据问题时这点很重要:数据本身错了,工具应该告诉你错了,而不是替你圆过去,否则你会在一个错误的时间点上继续往下查。
当前时间视图:拿一个”现在”的时间戳
需要往测试数据里填当前时间、给缓存设过期、核对客户端与服务端的时间差,都会用到当前时间戳。
这个视图实时显示秒级和毫秒级两个值,可以暂停,也可以切换刷新频率。
暂停解决的是复制问题。数字一直在跳,很容易复制到一半就变了;点一下暂停,数值定住,复制出来的就是同一个数。
刷新频率解决的是可读性问题。不是所有场景都需要每帧刷新,做演示或者盯趋势时,慢一点反而看得清。
有个细节要说明:这个时间戳来自你设备的系统时钟,不是服务器时间。浏览器标签页切到后台时会被节流,数字不会照常跳动,切回页面会立刻刷新到当前值。所以它能当参考值,不能当权威时间源。
单位换算视图:秒和毫秒的精确换算
有时候你不需要知道具体日期,只是要把一个数从秒换成毫秒,或者反过来。这个视图做纯数值换算,并展示 ×1000 / ÷1000 的换算关系。
实现上用的是 BigInt,不是 JavaScript 的浮点数。JavaScript 的 Number 只能精确表示到 2^53 左右,处理 13 位、16 位时间戳时,浮点乘除可能出现末位偏差。BigInt 是整数运算,不存在这个问题。
对普通用户来说,记住一句话就够:大数换算别用计算器里的浮点,尤其是毫秒往微秒、纳秒换的时候。
🧪 一次完整排查:从 1792886400 到结论
把上面的功能串起来,走一遍真实流程,比单看功能说明清楚得多。
第 1 步:把日志里的值翻出来。 在转换视图粘贴 1792886400,手动选「秒」,结果给出:
- UTC:2026-10-25 00:00:00
- 北京:2026-10-25 08:00:00
- RFC3339:2026-10-25T00:00:00Z
第 2 步:判断这个值是不是”当地 0 点”。 如果业务含义是”用户所在时区的当天 0 点”,那它不对。它对应的是 UTC 的 0 点,换成北京是早上 8 点。北京时间的 0 点应该是 1792857600。这一步是跨时区排查里最容易漏掉的:数字没错,语义错了。
第 3 步:处理另一个 13 位的值。 1792900800000 是毫秒,切成秒是 1792900800,对应 UTC 2026-10-25 04:00:00、北京 12:00:00。和创建时间差 4 小时。差值是 14400 秒,expire_at - created_at 得到的是秒数,不是毫秒数。如果两边单位没统一,这个差值会变成 14400000,看起来像”差了 166 天”。
第 4 步:核对存储与展示。 数据库字段存秒,报表层按毫秒格式化,结果会显示 1970-01-20 左右。反过来,存毫秒、按秒展示,会显示五万多年后的日期。两种都”有值”,都不报错,只能靠对比年份发现。
第 5 步:把结论写清楚。 排查记录里最好直接写 UTC 时间和 RFC3339 字符串,而不是”昨天晚上”。跨时区协作时,一句”2026-10-25T00:00:00Z 前后 4 小时”不会有人理解错,一句”昨晚 12 点”能吵半小时。
🔍 结果区的每个字段在说什么
结果区一次给出七项信息,第一次用容易看花眼。逐个解释:
| 字段 | 含义 | 什么时候用 |
|---|---|---|
| 本地时间 | 按你浏览器所在时区显示的日期时间 | 自己看、写日报、跟同事口头对时间 |
| UTC | 零时区的标准时间 | 跨时区沟通、写技术文档、对日志 |
| RFC3339 | 带偏移的标准化字符串,如 2026-10-25T08:00:00+08:00 | 接口参数、配置文件、Kubernetes 资源 |
| Unix 秒 | 秒级时间戳 | 数据库字段、JWT、Redis TTL、多数后端 |
| Unix 毫秒 | 毫秒级时间戳 | JavaScript、Java、多数前端接口 |
| 星期 | 该日期是星期几 | 排期、对账、确认”下周三”是哪天 |
| 偏移 | 该时刻相对 UTC 的偏移,如 +08:00 | 判断是否跨夏令时、核对时区设置 |
两个容易误解的点。
本地时间不是服务器时间。 它取决于你这台设备的时区设置。同一串时间戳,同事的电脑设成 UTC,显示的就和你不一样,但 UTC 那一栏和两个 Unix 时间戳一定相同。如果三栏里的 UTC 对上了、本地时间对不上,问题在时区设置,不在数据。
偏移不是固定的。 +08:00 对中国是常年不变,但对使用夏令时的地区,同一个时区在夏天和冬天的偏移不同。看偏移字段要结合具体日期,不能拿一月的偏移去套七月的时刻。要系统地做多时区对照,可以配合 时区转换工具 一起看。
顺带说 RFC3339 和 ISO 8601 的关系:RFC3339 是 ISO 8601 的一个严格子集,专门为互联网协议定义,要求带 T 分隔、必须带偏移(Z 或 +08:00)。日常说”ISO 时间”多数时候指的就是 RFC3339 这种写法。两者在大多数场景可以互换,但写接口契约时,明确用 RFC3339 更不容易产生歧义。
📊 秒级、毫秒级、微秒级:一张表看清
| 精度 | 典型位数 | 同一瞬间的示例 | 常见来源 | 常见误判 |
|---|---|---|---|---|
| 秒 | 10 位 | 1792886400 | PHP time()、Go Unix()、Java getEpochSecond()、JWT exp、Redis TTL、MySQL UNIX_TIMESTAMP() | 当成毫秒 → 落到 1970 年 1 月 |
| 毫秒 | 13 位 | 1792886400000 | JS Date.now()、Java System.currentTimeMillis()、大部分 HTTP 接口 | 当成秒 → 跑到五万多年后 |
| 微秒 | 16 位 | 1792886400000000 | Python time.time_ns() // 1000、部分数据库与监控系统 | 当成毫秒 → 日期离谱;当成秒 → 更离谱 |
| 纳秒 | 19 位 | 1792886400000000000 | Go UnixNano()、Python time.time_ns() | 超出 JS Number 安全整数范围,精度直接丢 |
表里的”位数”是经验值,不是规范。负数会少一位,未来日期会多一位,所以位数只能用来快速猜,不能用来定论。真正可靠的做法是看接口文档、看数据库字段注释、看代码里调用的是哪个函数。拿不准的时候,在工具里手动指定单位,两种都试一遍,哪个结果落在业务合理区间就是哪个。
还有一个常被忽略的事实:10 位秒和 13 位毫秒的有效范围都到 2286 年 11 月(9999999999 秒对应 2286-11-20)。也就是说,位数判断在未来几十年内还算够用,但它从来不是语义保证,只是格式上的巧合。
⚠️ 2038 问题、负时间戳,和”自动判断”的边界
2038 问题
32 位有符号整数最大是 2147483647。把它当秒级时间戳,对应 2038-01-19 03:14:07 UTC,北京时间是 2038-01-19 11:14:07。再往后一秒,值会溢出,回绕成 -2147483648,也就是 1901-12-13 20:45:52 UTC。
这就是”2038 问题”(Year 2038 problem,也叫 Y2K38)。容易踩的地方不是新写的代码,而是:
- 老代码里用
int存时间戳; - 32 位嵌入式设备、老款路由器、工控设备;
- 数据库字段是
int(11)而不是bigint; - 某些协议字段规定用 32 位表示时间;
- 编译出来的二进制还是 32 位,即使跑在 64 位机器上。
无符号 32 位的上限是 4294967295,对应 2106-02-07 06:28:15 UTC,问题只是往后推了 68 年,没有消失。真正的解法是把存储和计算都换成 64 位,或者干脆用日期时间类型、带偏移的字符串。
负时间戳
1970 年之前的时刻用负数表示:
| 时间戳 | UTC 时间 |
|---|---|
| 0 | 1970-01-01 00:00:00 |
| -1 | 1969-12-31 23:59:59 |
| -2208988800 | 1900-01-01 00:00:00 |
| -2147483648 | 1901-12-13 20:45:52 |
负时间戳在历史数据、生日、档案、天文计算里都会遇到。本工具支持负值转换,超出可安全表达范围的数值会明确报错,不会给你一个看起来正常但其实错误的结果。
顺带一个坑:负数除法的取整方向。JavaScript 里 Math.floor(-1.5) 得 -2,Math.trunc(-1.5) 得 -1;Python 的 // 向下取整;C 的整数除法向零取整。把负数毫秒换成秒时,不同写法会差 1 秒。要精确,用「单位换算」做整数运算,别手写浮点除。
自动判断只是便利,不是保证
工具提供”自动”单位,判断结果会明确展示。这个设计的出发点是省事,不是替你保证正确。位数启发式在三种情况下会失准:
- 数值太短:
12345既可能是秒级时间戳(1970-01-01 03:25:45 UTC),也可能是个编号; - 负值:负号占一位,位数规律变了;
- 哨兵值:有些系统用
0、-1或极大值表示”永不过期""未设置”,这些值按时间戳解释没有业务意义。
所以规则很简单:看不懂的时候用自动;要精确、要写进代码、要对外交付的时候,手动选单位。
🐛 六个高频错误
1. 10 位和 13 位混用
最常见的坑,没有之一。
- 把 13 位毫秒
1700000000000当秒:得到五万多年后的日期; - 把 10 位秒
1700000000当毫秒:得到 1970-01-20,早了五十多年。
两种错法的共同点是”结果看起来像个正常日期”,所以很容易被忽略。核对时先看位数,再看结果年份是否符合业务常识。跨系统对接时,最省事的办法是在字段名里写死单位,比如 created_at_ms、expire_at_s,比在文档角落里写一句”单位:秒”管用。
2. 把小数秒直接当时间戳
1700000000.123 不是标准时间戳写法。有的解析器截断成 1700000000(毫秒丢了),有的四舍五入到下一秒,有的直接报错。要保留毫秒精度,先换成整数毫秒 1700000000123 再传。用「单位换算」比手算可靠:手写 * 1000 在浮点数上可能得到 1700000000123.0001 这种值,再取整方向又不对,就差 1 毫秒。
3. 以为当前时间戳就是服务器时间
前端拿到的 Date.now() 来自用户设备的系统时钟。设备时间被手动改过、时区设错、长期没同步 NTP,这个值都会偏。凡是涉及过期、限流、签名有效期、抽奖开奖时间的判断,必须以服务端时间为准;前端的时间戳只能用于展示和粗略提示。反过来说,服务端如果没配 NTP,多台机器之间的时间戳也会互相打架,分布式系统里”后写入的反而时间更早”经常是时钟不同步造成的。
4. 时区误解:同一时间戳,不同本地时间
1792886400 这个瞬间:
- UTC:2026-10-25 00:00:00
- 北京(UTC+8):2026-10-25 08:00:00
- 纽约(UTC-4,夏令时):2026-10-24 20:00:00
三个本地时间看起来差了一天,但它们指的是同一个瞬间。很多”日期对不上”的 bug,本质是把”本地日期”当成了”时间戳”来比较。比较时间用时间戳,展示时间才用本地时间。还有个更隐蔽的版本:按天分组统计时用本地日期字符串做 key,跨时区用户的”同一天”会被拆到两个桶里,报表就对不上了。
5. 纯日期字符串被当成 UTC 零点
JavaScript 里 new Date('2026-10-25') 按规范解析成 UTC 零点,而 new Date('2026-10-25 00:00:00')(带时间、无偏移)按本地时间解析。同一句”10 月 25 日”,两种写法在北京差 8 小时。这不是浏览器的 bug,是规范如此。要跨环境一致,就写完整的 RFC3339 带偏移字符串,别依赖解析器的默认行为。
6. 用固定天数手算时间差
365 × 24 × 3600 算一年多少秒,遇到闰年就错;用固定 86400 秒算”隔了几天”,跨夏令时就错。时间差要用时间库或工具算,尤其是跨月、跨年、跨时区的场景。需要算两个时刻实际经过多久,可以用 时间差计算器。
🌍 时间戳解决不了的三件事
时间戳能把”瞬间”表达得很干净,但它不是万能的。有三类问题,翻成时间戳也帮不上忙,得回到时区规则里找答案。
第一,本地时间可能不存在。 实行夏令时的地区,春季切换那天会把时钟从 02:00 直接拨到 03:00,于是当地根本没有 02:30 这个时刻。以美国东部为例,2026 年 3 月 8 日 02:30 是不存在的。你如果拿到一句”3 月 8 日 02:30 开会”,先得确认它是哪个时区的,再看这个时刻在该时区是否合法。
第二,本地时间可能重复。 秋季切回标准时间时,01:00 到 02:00 会走两遍。2026 年 11 月 1 日,美国东部当地的 01:30 出现两次,对应两个不同的时间戳,相差 3600 秒。只写”11 月 1 日 01:30”是有歧义的,必须带偏移或时区 ID。
第三,时区规则本身会变。 某个国家取消夏令时、调整偏移、改边界,都会让历史换算结果变化。这些规则来自 IANA 时区数据库(tzdata),系统不更新就会算错。所以处理历史时间时,不能拿”现在的偏移”去套”五年前的时刻”,得用带时区 ID 的库按当时规则算。这一点上,固定偏移 +08:00 和时区 ID Asia/Shanghai 不是一回事:前者只记录一刻的偏移,后者带着完整的规则历史。
一句话概括:时间戳管”哪一刻”,时区工具管”当地几点”。排查跨时区问题,两边都要看。星点的 时区转换工具 会把同一瞬间在多个 IANA 时区下同时展开,夏令时行还会带标记,比手动加减偏移靠谱。
🧩 各语言和系统的时间戳习惯
同一个”Unix 时间戳”,不同技术栈默认的单位不一样,这也是混用的根源:
| 语言 / 系统 | 常用接口 | 单位 |
|---|---|---|
| JavaScript | Date.now() / new Date().getTime() | 毫秒 |
| JavaScript | Math.floor(Date.now() / 1000) | 秒(手动换算) |
| Java | System.currentTimeMillis() | 毫秒 |
| Java | Instant.now().getEpochSecond() | 秒 |
| Go | time.Now().Unix() / UnixMilli() / UnixNano() | 秒 / 毫秒 / 纳秒 |
| Python | time.time() | 秒(浮点,带小数) |
| Python | time.time_ns() | 纳秒 |
| PHP | time() / microtime(true) | 秒 / 秒(浮点) |
| MySQL | UNIX_TIMESTAMP() / FROM_UNIXTIME() | 秒 |
| PostgreSQL | extract(epoch from now()) | 秒(带小数) |
| Redis | TTL / PEXPIRE | 秒 / 毫秒 |
| JWT | exp、iat(RFC 7519 NumericDate) | 秒 |
看一眼这张表就能明白,为什么”接口返回毫秒、后端按秒存”是高频事故:两端各自用的都是本语言最标准的接口,只是单位不同,谁都没写错,凑在一起就错了。
顺带说数据库选型。存时间戳用整数还是日期类型,会直接影响 2038 问题:
- MySQL 的
INT有符号上限就是 2038 年,BIGINT没这个问题; - MySQL 的
TIMESTAMP范围是 1970 到 2038,并且会按时区做转换;DATETIME不带时区,范围到 9999 年,但语义需要你自己保证; - PostgreSQL 的
timestamptz内部按 UTC 存,展示时按会话时区换算,精度到微秒;timestamp不带时区; - SQLite 没有原生日期类型,通常存整数时间戳或 ISO 字符串,单位要靠约定。
选整数就要接受”单位靠约定”,选日期类型就要接受”时区语义绑定在系统里”。两种都能用,怕的是混着用。
✅ 拿到一串时间戳后的核对清单
排查时间问题最怕”看一眼觉得对”。下面这套顺序不长,但能挡住大部分低级错误,适合贴在排查笔记里。
- 数位数,做初判。 10 位往秒想,13 位往毫秒想,16 位往微秒想。这只是初判,下一步必须手动定单位。
- 手动指定单位转换,先看 UTC 年份。 年份落在业务合理区间(比如最近几年),单位大概率对;年份是 1970 或者五万年后,单位一定错。
- 看时分秒的形状。 结果是 00:00:00,说明生成方很可能按某个时区的”当天零点”写入;结果是 08:00:00,而业务在中国,那它可能是 UTC 零点。这一步能反推出写入方的时区习惯。
- 和相邻字段做减法。 创建时间减更新时间、过期时间减创建时间,差值应该符合业务常识(几分钟、几天,而不是几万天)。数量级不对,多半是单位没统一。
- 检查符号。 出现负数,先确认是不是历史数据,再确认解析链路里没有把无符号值当有符号读。
- 写结论时带上 RFC3339。 排查记录、工单、周报里写
2026-10-25T00:00:00Z,比写”25 号凌晨”少很多来回确认。 - 存库或对接时固定单位。 字段名带
_s/_ms后缀,文档写清单位,比事后靠猜省事。
再补一个自查点:如果你在中国,看到的时间戳正好对应 UTC 的 16:00,那它很可能就是北京时间的次日 0 点。+08:00 意味着本地零点等于 UTC 前一天 16:00,这个换算在核对”按天统计”的数据时特别好用。
❓ 常见问题
时间戳有 10 位和 13 位,到底怎么判断?
10 位通常是秒,13 位通常是毫秒。但这个规律只是经验:负数会少一位,未来日期会多一位,编号也可能长得像时间戳。判断时先看接口文档和代码,拿不准就在工具里手动选单位,两种都转一遍,选结果落在业务合理年份的那个。时间戳会受时区影响吗?
时间戳本身不受时区影响,它记录的是一个绝对瞬间。受影响的是"显示":同一串时间戳在不同时区会显示成不同的本地时间。所以跨时区沟通时,优先说 UTC 时间或 RFC3339 字符串,而不是"上午十点"。2038 年我的系统会出问题吗?
取决于时间是怎么存的。用 64 位整数、日期时间类型、字符串存的系统不受影响;用 32 位有符号整数存秒级时间戳的系统,会在 2038-01-19 03:14:07 UTC 之后回绕到 1901 年。检查方式很直接:看数据库字段类型、看代码里的类型定义、看设备是不是 32 位。两个时间戳相减,为什么得到的数不是天数?
因为时间戳的单位是秒或毫秒,相减得到的是秒差或毫秒差,不是天数。秒差除以 86400 才是天,而且这个"天"是固定 24 小时的天,不是日历天。跨夏令时的时候,两者会差一小时。要算日历天数,用日期差工具;要算真实经过时长,用时间差工具。时间戳能表示 1970 年以前的时间吗?
能,用负数表示。比如 -1 是 1969-12-31 23:59:59 UTC,-2208988800 是 1900-01-01 00:00:00 UTC。不过不是所有系统都正确处理负值,有些库在格式化负时间戳时会出错,历史数据要特别验证。闰秒会影响我的计算吗?
日常业务基本不影响。Unix 时间不含闰秒,每天固定 86400 秒,所以跨闰秒计算"经过了多少秒"时,结果会比真实物理时间少 1 秒左右。需要精密计时的场景(授时、天文、长期累计误差敏感的系统)才需要专门处理。当前时间戳准吗?能当服务器时间用吗?
不能。当前时间视图读的是你设备的系统时钟,设备时间可能被改过、时区可能设错、也可能长期没同步。它能当参考值和测试数据来源,不能作为业务判断的权威时间。需要权威时间时,以服务端返回的时间为准。工具会把我的时间数据上传吗?
不会。所有转换和计算都在浏览器本地完成,不产生网络请求。日志、接口返回值、数据库里的时间戳都可以直接粘进来处理。时间戳和 UUID v7、雪花 ID 是一回事吗?
不是。UUID v7 和雪花 ID 里确实嵌了时间信息(v7 的前 48 位是毫秒时间戳),但它们是标识符,不是时间表示:长度不同、编码不同,还混了随机位或机器位。把这类 ID 整串当时间戳转换没有意义;要用里面的时间,得按各自的格式拆字段再解。前端做倒计时,用时间戳还是直接算日期?
用时间戳。正确做法是拿到目标时间戳,用目标值减当前时间戳得到剩余毫秒,再换算成天时分秒。直接对本地日期字符串做减法,会受时区和夏令时影响。另外倒计时最好以服务端时间校准一次,别完全相信用户设备的时钟。🔗 和系列里其他工具怎么配合
时间戳转换通常不是终点,它经常是排查链条上的第一环。按手上的输入选下一站:
- 只知道”要 2026 年 10 月 25 日这种格式”,要把时间输出成指定样式 → 日期时间格式化工具,支持预设和 Day.js 风格 token;
- 要确认”北京时间早上 9 点,对应纽约几点” → 时区转换工具,同一瞬间多时区展开,夏令时带标记;
- 手里是一段格式不明的时间文本,不确定它是不是时间戳 → 用时间字符串解析,它会明确告诉你哪里有歧义,而不是替你猜;
- 要算两个时刻隔了多久、跨了几天 → 时间差计算器,时刻差和日期差分开算。
整个系列都在星点时间工具下面,不需要登录,计算都在浏览器本地完成。
💬 收尾
时间戳之所以让人头疼,不是因为概念难,而是因为它在系统之间传递时,单位、时区、精度三个维度都可能变,而任何一处变了都不会报错,只会给你一个”看起来正常”的错误日期。把这三个维度固定下来——单位写进字段名、时区统一用 UTC、精度按业务选——大部分问题就不会发生。
真遇到一串看不懂的数字,先翻成 UTC 和 RFC3339,再判断时区语义,最后核对单位。这个顺序走下来,基本不会跑偏。需要顺手做日期格式化、多时区对照或者算时间差,星点时间工具系列 里都有对应的入口。
文章分享
如果这篇文章对你有帮助,欢迎分享给更多人!