Unix时间戳转换

当前时间戳

现在的Unix时间戳：
秒
2024-03-21 15:30:45

时间戳转日期时间

日期时间转时间戳

年 月 日
时 分 秒

什么是Unix Timestamp时间戳？

Unix 时间戳（Unix Timestamp）是一个自 1970 年 1 月 1 日 00:00:00 UTC（协调世界时）以来经过的秒数。这是一种在计算机系统中表示时间的通用标准，具有以下特点：

  • 精确到秒
  • 与时区无关
  • 便于计算和比较

当前时间戳示例：1704499200

这表示从 1970 年 1 月 1 日 00:00:00 UTC 到现在经过的秒数。

Unix时间戳特点：

  • 以秒为单位：一般是10位数的秒级时间戳
  • 以毫秒为单位：一般是13位数的毫秒级时间戳
  • 时区无关：时间戳本身不带有时区信息，是一个绝对时间点
  • 广泛应用：在计算机系统和编程中被广泛使用

时区（Timezone）

时区是地球上采用同一个时间的区域。主要特点包括：

  • 全球共分为 24 个主要时区
  • 每个时区相差整数小时（部分地区有 30 分钟或 45 分钟的偏移）
  • 以格林威治时间（GMT）或协调世界时（UTC）为基准

时间戳与时区的关系

时间戳的一个重要特性是它与时区无关。这意味着：

  • 同一时刻在世界任何地方的时间戳都是相同的
  • 时间戳转换为人类可读时间时，需要考虑时区
  • 在不同时区显示相同时间戳会得到不同的本地时间

示例：时间戳 1704499200 在不同时区的显示：

  • UTC+0: 2024-01-06 00:00:00
  • UTC+8 (北京时间): 2024-01-06 08:00:00
  • UTC-5 (纽约时间): 2024-01-05 19:00:00
人类可读时间 秒
1 小时 3600 秒
1 天 86400 秒
1 周 604800 秒
1 月 (30.44 天 ) 2629743 秒
1 年 (365.24 天 ) 31556926 秒

如何在不同编程语言中获取当前的Unix时间戳？

Java 
// pure java
System.currentTimeMillis() / 1000

// joda java
DateTime.now().getMillis() / 1000

// java >= 8
Instant.now().getEpochSecond()
PHP 
// 获取秒级时间戳
time();
// 获取毫秒级时间戳
round(microtime(true) * 1000);
JavaScript 
// 获取秒级时间戳
Math.round(Date.now() / 1000);
// 获取毫秒级时间戳
Date.now();
Python 
import time
# 获取秒级时间戳
int(time.time())
# 获取毫秒级时间戳
int(time.time() * 1000)
C#/.NET 
// 获取秒级时间戳
DateTimeOffset.UtcNow.ToUnixTimeSeconds();
// 获取毫秒级时间戳
DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
Go 
import (
"time"
)
// 获取秒级时间戳
int64(time.Now().Unix())
// 获取毫秒级时间戳
int64(time.Now().UnixMilli())
Erlang 
calendar:datetime_to_gregorian_seconds(calendar:universal_time())-719528*24*3600.
Groovy 
(new Date().time / 1000).longValue()
Ruby 
# 获取秒级时间戳
Time.now.to_i
# 获取毫秒级时间戳
(Time.now.to_f * 1000).to_i
Shell 
# 获取秒级时间戳
date +%s
# 获取毫秒级时间戳
date +%s%N | cut -b1-13
Objective-C 
// 获取秒级时间戳
[[NSDate date] timeIntervalSince1970];
// 获取毫秒级时间戳
(NSTimeInterval)([[NSDate date] timeIntervalSince1970] * 1000.0);
Perl 
# 获取秒级时间戳
time();
# 获取毫秒级时间戳
use Time::HiRes qw(time);
int(time() * 1000);
Lua 
-- 获取秒级时间戳
os.time()
-- 获取毫秒级时间戳（需要特定实现）
require("socket")
socket.gettime() * 1000
Dart 
// 获取秒级时间戳
DateTime.now().millisecondsSinceEpoch ~/ 1000;
// 获取毫秒级时间戳
DateTime.now().millisecondsSinceEpoch;
MySQL 
-- 获取秒级时间戳
SELECT UNIX_TIMESTAMP();
-- 获取毫秒级时间戳
SELECT UNIX_TIMESTAMP(NOW(3)) * 1000;
PostgreSQL 
-- 获取秒级时间戳
SELECT EXTRACT(EPOCH FROM NOW())::integer;
-- 获取毫秒级时间戳
SELECT EXTRACT(EPOCH FROM NOW()) * 1000 AS milliseconds;
SQLite 
-- 获取秒级时间戳
SELECT strftime('%s', 'now');
-- 获取毫秒级时间戳
SELECT strftime('%s', 'now', 'localtime') * 1000;
SQL Server 
-- 获取秒级时间戳
SELECT DATEDIFF(SECOND, '1970-01-01 00:00:00', GETDATE());
-- 日期转时获取毫秒级时间戳间戳
SELECT DATEDIFF(MILLISECOND, '1970-01-01 00:00:00', GETDATE());

如何在不同编程语言中实现Unix时间戳转普通时间？

Java 
long timestamp = 1704499200L;
// pure java
new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date(timestamp * 1000));

// java >= 8
LocalDateTime.ofInstant(Instant.ofEpochSecond(timestamp),
ZoneId.systemDefault()).format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
PHP 
$timestamp = 1704499200;
// 格式化为日期时间
date('Y-m-d H:i:s', $timestamp);
// 创建DateTime对象
$dt = new DateTime("@$timestamp");
$dt->setTimezone(new DateTimeZone('Asia/Shanghai'));
JavaScript 
// 创建Date对象并格式化
new Date(timestamp * 1000).toLocaleString();
// 使用Intl格式化
new Intl.DateTimeFormat('zh-CN', {
year: 'numeric',
month: '2-digit',
day: '2-digit',
hour: '2-digit',
minute: '2-digit',
second: '2-digit',
hour12: false
}).format(new Date(timestamp * 1000));
Python 
import time
from datetime import datetime

timestamp = 1704499200
# 使用datetime模块
datetime.fromtimestamp(timestamp).strftime('%Y-%m-%d %H:%M:%S')

# 使用time模块
time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(timestamp))
C#/.NET 
long timestamp = 1704499200;
// 使用DateTimeOffset
DateTimeOffset.FromUnixTimeSeconds(timestamp)
.LocalDateTime.ToString("yyyy-MM-dd HH:mm:ss");

// 使用DateTime
DateTime dateTime = DateTime.UnixEpoch.AddSeconds(timestamp)
.ToLocalTime();
Go 
timestamp := int64(1704499200)
// 转换为time.Time
timeObj := time.Unix(timestamp, 0)
// 格式化输出
timeObj.Format("2006-01-02 15:04:05")
Erlang 
Timestamp = 1704499200,
UniversalTime = calendar:gregorian_seconds_to_datetime(Timestamp + 719528*24*3600),
calendar:universal_time_to_local_time(UniversalTime).
Groovy 
def timestamp = 1704499200L
new Date(timestamp * 1000).format('yyyy-MM-dd HH:mm:ss')
Ruby 
timestamp = 1704499200
Time.at(timestamp).strftime('%Y-%m-%d %H:%M:%S')
Shell 
timestamp=1704499200
date -d "@$timestamp" "+%Y-%m-%d %H:%M:%S"
Objective-C 
NSTimeInterval timestamp = 1704499200;
NSDate *date = [NSDate dateWithTimeIntervalSince1970:timestamp];
NSDateFormatter *formatter = [[NSDateFormatter alloc] init];
[formatter setDateFormat:@"yyyy-MM-dd HH:mm:ss"];
NSString *dateString = [formatter stringFromDate:date];
Perl 
my $timestamp = 1704499200;
my $datetime = localtime($timestamp);
# 使用POSIX模块格式化
use POSIX qw(strftime);
strftime("%Y-%m-%d %H:%M:%S", localtime($timestamp));
Lua 
timestamp = 1704499200
-- 使用os.date格式化
os.date("%Y-%m-%d %H:%M:%S", timestamp)
Dart 
int timestamp = 1704499200;
DateTime dateTime = DateTime.fromMillisecondsSinceEpoch(timestamp * 1000);
// 使用intl包格式化
DateFormat formatter = DateFormat('yyyy-MM-dd HH:mm:ss');
String formatted = formatter.format(dateTime);
MySQL 
-- 时间戳转日期时间
SELECT FROM_UNIXTIME(1704499200);
-- 指定格式
SELECT FROM_UNIXTIME(1704499200, '%Y-%m-%d %H:%i:%s');
PostgreSQL 
-- 时间戳转日期时间
SELECT to_timestamp(1704499200);
-- 指定格式
SELECT to_char(to_timestamp(1704499200), 'YYYY-MM-DD HH24:MI:SS');
SQLite 
-- 时间戳转日期时间
SELECT datetime(1704499200, 'unixepoch');
-- 指定格式
SELECT strftime('%Y-%m-%d %H:%M:%S', 1704499200, 'unixepoch');
SQL Server 
-- 时间戳转日期时间
SELECT DATEADD(SECOND, 1704499200, '1970-01-01');
-- 指定格式
SELECT FORMAT(DATEADD(SECOND, 1704499200, '1970-01-01'),
'yyyy-MM-dd HH:mm:ss');

如何在不同编程语言中实现普通时间转Unix时间戳？

Java 
String dateStr = "2024-01-06 08:00:00";
// pure java
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
long timestamp = sdf.parse(dateStr).getTime() / 1000;

// java >= 8
LocalDateTime dateTime = LocalDateTime.parse(dateStr,
DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
long timestamp = dateTime.atZone(ZoneId.systemDefault())
.toInstant().getEpochSecond();
PHP 
// 将日期时间字符串转换为时间戳
strtotime('2024-01-06 08:00:00');

// 使用DateTime对象
$date = new DateTime('2024-01-06 08:00:00');
$timestamp = $date->getTimestamp();
JavaScript 
// 将日期时间字符串转换为时间戳（秒）
Math.floor(new Date('2024-01-06 08:00:00').getTime() / 1000);

// 使用Date.parse（返回毫秒时间戳）
Date.parse('2024-01-06 08:00:00') / 1000;
Python 
from datetime import datetime
import time

# 使用datetime模块
dt = datetime.strptime('2024-01-06 08:00:00', '%Y-%m-%d %H:%M:%S')
timestamp = int(dt.timestamp())

# 使用time模块
time_tuple = time.strptime('2024-01-06 08:00:00', '%Y-%m-%d %H:%M:%S')
timestamp = int(time.mktime(time_tuple))
C#/.NET 
string dateStr = "2024-01-06 08:00:00";
// 使用DateTimeOffset
DateTimeOffset dto = DateTimeOffset.ParseExact(dateStr,
"yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture);
long timestamp = dto.ToUnixTimeSeconds();

// 使用DateTime
DateTime dt = DateTime.ParseExact(dateStr,
"yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture);
long timestamp = ((DateTimeOffset)dt).ToUnixTimeSeconds();
Go 
dateStr := "2024-01-06 08:00:00"
layout := "2006-01-02 15:04:05"
t, _ := time.Parse(layout, dateStr)
timestamp := t.Unix()
Erlang 
% 从字符串转换
Timestamp2 = string_to_timestamp("2024-01-07 10:30:00"),
io:format("Timestamp from string: ~p~n", [Timestamp2]),
Groovy 
def dateStr = "2024-01-06 08:00:00"
def date = Date.parse("yyyy-MM-dd HH:mm:ss", dateStr)
def timestamp = date.time / 1000
Ruby 
require 'time'
Time.parse("2024-01-06 08:00:00").to_i
Shell 
date -d "2024-01-06 08:00:00" +%s
Objective-C 
NSString *dateStr = @"2024-01-06 08:00:00";
NSDateFormatter *formatter = [[NSDateFormatter alloc] init];
[formatter setDateFormat:@"yyyy-MM-dd HH:mm:ss"];
NSDate *date = [formatter dateFromString:dateStr];
NSTimeInterval timestamp = [date timeIntervalSince1970];
Perl 
use Time::Local;
my ($year, $month, $day, $hour, $min, $sec) = (2024, 1, 6, 8, 0, 0);
my $timestamp = timelocal($sec, $min, $hour, $day, $month-1, $year-1900);
Lua 
-- 需要额外的时间处理库如luadate
local date = require("date")
local d = date("2024-01-06 08:00:00")
local timestamp = d:totime()
Dart 
String dateStr = "2024-01-06 08:00:00";
DateTime dateTime = DateTime.parse(dateStr);
int timestamp = dateTime.millisecondsSinceEpoch ~/ 1000;
MySQL 
-- 日期时间转时间戳
SELECT UNIX_TIMESTAMP('2024-01-06 08:00:00');
PostgreSQL 
-- 日期时间转时间戳
SELECT EXTRACT(EPOCH FROM TIMESTAMP '2024-01-06 08:00:00');
SQLite 
-- 日期时间转时间戳
SELECT strftime('%s', '2024-01-06 08:00:00');
SQL Server 
-- 日期时间转时间戳
SELECT DATEDIFF(SECOND, '1970-01-01', '2024-01-06 08:00:00');