时间戳转换工具

本站在线提供：时间戳转换工具、北京时间戳转换、10 位时间戳转北京时间、13 位时间戳转换、各编程语言获取时间的戳方法。

时间戳的来历：时间戳是指从 1970 年 1 月 1 日 00:00:00 UTC（协调世界时）到特定时间的秒数或毫秒数。它被广泛用于计算机系统中，以方便地表示和比较时间。建议阅读

1.时间戳发展历程，2.时间戳的未来挑战与应对， 3.时间戳使用技巧，4.时间戳在不同领域的应用， 5.时间戳使用注意事项，6.时间戳一般和什么结合使用， 7.百科了解更多，

常见编程语言获取时间戳的方式：

Python：

import time

# 生成 10 位时间戳
ten_digit_timestamp = int(time.time())
print(f'Python 10 位时间戳：{ten_digit_timestamp}')

# 生成 13 位时间戳
thirteen_digit_timestamp = int(time.time() * 1000)
print(f'Python 13 位时间戳：{thirteen_digit_timestamp}')

# 将 13 位时间戳转换为日期时间
thirteen_digit = 1695174248803
date_time = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(thirteen_digit / 1000))
print(f'Python 转换后的日期时间：{date_time}')

Java：

import java.time.Instant;

// 生成 13 位时间戳
long thirteen_digit_timestamp = Instant.now().toEpochMilli();
System.out.println(f'Java 13 位时间戳：{thirteen_digit_timestamp}');

// 将 13 位时间戳转换为日期时间（假设已有一个 13 位时间戳变量）
long javaThirteenDigit = 1695174248803;
Instant instant = Instant.ofEpochMilli(javaThirteenDigit);
java.time.ZonedDateTime zonedDateTime = instant.atZone(java.time.ZoneId.systemDefault());
System.out.println(f'Java 转换后的日期时间：{zonedDateTime}');

C++：

#include <iostream>
#include <chrono>

int main() {
    // 生成 13 位时间戳
    auto now = std::chrono::system_clock::now();
    auto timestamp = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count();
    std::cout << "C++ 13 位时间戳：" << timestamp << std::endl;

    // 将 13 位时间戳转换为日期时间（假设已有一个 13 位时间戳变量）
    long long cplusplusThirteenDigit = 1695174248803;
    auto timePoint = std::chrono::system_clock::time_point(std::chrono::milliseconds(cplusplusThirteenDigit));
    std::time_t timeT = std::chrono::system_clock::to_time_t(timePoint);
    std::cout << "C++ 转换后的日期时间：" << std::ctime(&timeT);

    return 0;
}

JavaScript：

// 生成 13 位时间戳
let thirteen_digit_timestamp = Date.now();
console.log(`JavaScript 13 位时间戳：${thirteen_digit_timestamp}`);

// 将 13 位时间戳转换为日期时间（假设已有一个 13 位时间戳变量）
let jsThirteenDigit = 1695174248803;
let date = new Date(jsThirteenDigit);
console.log(`JavaScript 转换后的日期时间：${date.toLocaleString()}`);

Go：

package main

import (
    "fmt"
    "time"
)

func main() {
    // 生成 13 位时间戳
    thirteen_digit_timestamp := time.Now().UnixNano() / int64(time.Millisecond)
    fmt.Println("Go 13 位时间戳：", thirteen_digit_timestamp)

    // 将 13 位时间戳转换为日期时间（假设已有一个 13 位时间戳变量）
    goThirteenDigit := int64(1695174248803)
    t := time.Unix(0, goThirteenDigit*int64(time.Millisecond))
    fmt.Println("Go 转换后的日期时间：", t.Format("2006-01-02 15:04:05"))
}

PHP：

<?php
// 生成 13 位时间戳
$thirteen_digit_timestamp = round(microtime(true) * 1000);
echo 'PHP 13 位时间戳：'.$thirteen_digit_timestamp.'<br>';

// 将 13 位时间戳转换为日期时间（假设已有一个 13 位时间戳变量）
$phpThirteenDigit = 1695174248803;
$dateTime = date('Y-m-d H:i:s', $phpThirteenDigit/1000);
echo 'PHP 转换后的日期时间：'.$dateTime.'<br>';
?>

Rust：

use std::time::{SystemTime, UNIX_EPOCH};

fn main() {
    // 生成 13 位时间戳
    let now = SystemTime::now();
    let since_epoch = now.duration_since(UNIX_EPOCH).unwrap();
    let thirteen_digit_timestamp = since_epoch.as_millis();
    println!("Rust 13 位时间戳：{}", thirteen_digit_timestamp);

    // 将 13 位时间戳转换为日期时间（假设已有一个 13 位时间戳变量）
    let rustThirteenDigit = 1695174248803;
    let unix_time = std::time::Duration::from_millis(rustThirteenDigit);
    let datetime = UNIX_EPOCH + unix_time;
    println!("Rust 转换后的日期时间：{}", datetime);
}

Ruby：

puts "Ruby 13 位时间戳：#{Time.now.to_f * 1000}"

# 将 13 位时间戳转换为日期时间（假设已有一个 13 位时间戳变量）
rubyThirteenDigit = 1695174248803
puts "Ruby 转换后的日期时间：#{Time.at(rubyThirteenDigit/1000)}"

Shell：

# 生成 13 位时间戳
timestamp=$(date +%s%N | cut -b1-13)
echo "Shell 13 位时间戳：$timestamp"

# 将 13 位时间戳转换为日期时间（假设已有一个 13 位时间戳变量）
shellThirteenDigit=1695174248803
date -d @"$((shellThirteenDigit/1000))" +"%Y-%m-%d %H:%M:%S"
echo "Shell 转换后的日期时间：$(date -d @"$((shellThirteenDigit/1000))" +"%Y-%m-%d %H:%M:%S")"

Swift：

import Foundation

// 生成 13 位时间戳
let swiftThirteenDigitTimestamp = Int64(Date().timeIntervalSince1970 * 1000)
print("Swift 13 位时间戳：\(swiftThirteenDigitTimestamp)")

// 将 13 位时间戳转换为日期时间（假设已有一个 13 位时间戳变量）
let swiftThirteenDigit = 1695174248803
let date = Date(timeIntervalSince1970: TimeInterval(swiftThirteenDigit/1000))
let dateFormatter = DateFormatter()
dateFormatter.dateFormat = "yyyy-MM-dd HH:mm:ss"
let formattedDate = dateFormatter.string(from: date)
print("Swift 转换后的日期时间：\(formattedDate)")

C#：

using System;

class Program
{
    static void Main()
    {
        // 生成 13 位时间戳
        long thirteen_digit_timestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
        Console.WriteLine("C# 13 位时间戳：" + thirteen_digit_timestamp);

        // 将 13 位时间戳转换为日期时间（假设已有一个 13 位时间戳变量）
        long csharpThirteenDigit = 1695174248803;
        DateTime dateTime = DateTimeOffset.FromUnixTimeMilliseconds(csharpThirteenDigit).UtcDateTime;
        Console.WriteLine("C# 转换后的日期时间：" + dateTime);
    }
}

R：

timestamp <- as.numeric(Sys.time())*1000
cat("R 13 位时间戳：", timestamp, "\n")

# 将 13 位时间戳转换为日期时间（假设已有一个 13 位时间戳变量）
rThirteenDigit <- 1695174248803
dateTime <- as.POSIXct(rThirteenDigit/1000, origin = "1970-01-01")
cat("R 转换后的日期时间：", format(dateTime), "\n")