1# Python 时间戳转换，自动格式检测
2import datetime
3
4def convert_timestamp(timestamp, use_12hour=False):
5    # 转换为整数
6    timestamp = str(timestamp).strip()
7    numeric_timestamp = int(timestamp)
8    
9    # 根据数字长度检测时间戳格式
10    if len(timestamp) == 16:
11        # 微秒精度（除以 1,000,000 以获得秒）
12        date = datetime.datetime.fromtimestamp(numeric_timestamp / 1000000)
13        print("检测到：微秒精度时间戳")
14    elif len(timestamp) == 13:
15        # 毫秒精度（除以 1,000 以获得秒）
16        date = datetime.datetime.fromtimestamp(numeric_timestamp / 1000)
17        print("检测到：毫秒精度时间戳")
18    elif len(timestamp) == 10:
19        # 标准 Unix 时间戳（秒）
20        date = datetime.datetime.fromtimestamp(numeric_timestamp)
21        print("检测到：标准 Unix 时间戳（秒）")
22    else:
23        raise ValueError("无效的时间戳格式。期望 10、13 或 16 位数字。")
24    
25    # 格式化日期字符串
26    if use_12hour:
27        format_string = "%A, %B %d, %Y %I:%M:%S %p"  # 12 小时格式，带 AM/PM
28    else:
29        format_string = "%A, %B %d, %Y %H:%M:%S"     # 24 小时格式
30    
31    return date.strftime(format_string)
32
33# 示例用法
34try:
35    # 标准 Unix 时间戳（10 位数字）
36    print(convert_timestamp("1609459200", False))
37    
38    # 毫秒精度（13 位数字）
39    print(convert_timestamp("1609459200000", False))
40    
41    # 微秒精度（16 位数字）
42    print(convert_timestamp("1609459200000000", True))
43except ValueError as e:
44    print(e)
45

1<?php
2// PHP 时间戳转换，自动格式检测
3function convertTimestamp($timestamp, $use12Hour = false) {
4    // 确保时间戳是字符串，以便进行长度检查
5    $timestamp = trim((string)$timestamp);
6    
7    // 根据数字长度检测时间戳格式
8    if (strlen($timestamp) === 16) {
9        // 微秒精度（除以 1,000,000 以获得秒）
10        $seconds = (float)$timestamp / 1000000;
11        echo "检测到：微秒精度时间戳\n";
12    } elseif (strlen($timestamp) === 13) {
13        // 毫秒精度（除以 1,000 以获得秒）
14        $seconds = (float)$timestamp / 1000;
15        echo "检测到：毫秒精度时间戳\n";
16    } elseif (strlen($timestamp) === 10) {
17        // 标准 Unix 时间戳（秒）
18        $seconds = (float)$timestamp;
19        echo "检测到：标准 Unix 时间戳（秒）\n";
20    } else {
21        throw new Exception("无效的时间戳格式。期望 10、13 或 16 位数字。");
22    }
23    
24    // 格式字符串
25    $formatString = $use12Hour 
26        ? 'l, F j, Y g:i:s A'  // 12 小时格式，带 AM/PM
27        : 'l, F j, Y H:i:s';   // 24 小时格式
28    
29    // 转换并格式化日期
30    return date($formatString, $seconds);
31}
32
33// 示例用法
34try {
35    // 标准 Unix 时间戳（10 位数字）
36    echo convertTimestamp("1609459200", false) . "\n";
37    
38    // 毫秒精度（13 位数字）
39    echo convertTimestamp("1609459200000", false) . "\n";
40    
41    // 微秒精度（16 位数字）
42    echo convertTimestamp("1609459200000000", true) . "\n";
43} catch (Exception $e) {
44    echo $e->getMessage() . "\n";
45}
46?>
47

1// Java 时间戳转换，自动格式检测
2import java.time.Instant;
3import java.time.LocalDateTime;
4import java.time.ZoneId;
5import java.time.format.DateTimeFormatter;
6
7public class TimestampConverter {
8    public static String convertTimestamp(String timestamp, boolean use12Hour) {
9        // 修剪输入
10        timestamp = timestamp.trim();
11        
12        // 根据数字长度检测时间戳格式
13        LocalDateTime dateTime;
14        if (timestamp.length() == 16) {
15            // 微秒精度（除以 1,000,000 以获得秒）
16            long microseconds = Long.parseLong(timestamp);
17            Instant instant = Instant.ofEpochSecond(0, microseconds * 1000); // 转换为纳秒
18            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
19            System.out.println("检测到：微秒精度时间戳");
20        } else if (timestamp.length() == 13) {
21            // 毫秒精度
22            long milliseconds = Long.parseLong(timestamp);
23            Instant instant = Instant.ofEpochMilli(milliseconds);
24            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
25            System.out.println("检测到：毫秒精度时间戳");
26        } else if (timestamp.length() == 10) {
27            // 标准 Unix 时间戳（秒）
28            long seconds = Long.parseLong(timestamp);
29            Instant instant = Instant.ofEpochSecond(seconds);
30            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
31            System.out.println("检测到：标准 Unix 时间戳（秒）");
32        } else {
33            throw new IllegalArgumentException("无效的时间戳格式。期望 10、13 或 16 位数字。");
34        }
35        
36        // 根据所需格式创建格式化器
37        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(
38            use12Hour ? "EEEE, MMMM d, yyyy h:mm:ss a" : "EEEE, MMMM d, yyyy HH:mm:ss"
39        );
40        
41        // 格式化日期
42        return dateTime.format(formatter);
43    }
44    
45    public static void main(String[] args) {
46        try {
47            // 标准 Unix 时间戳（10 位数字）
48            System.out.println(convertTimestamp("1609459200", false));
49            
50            // 毫秒精度（13 位数字）
51            System.out.println(convertTimestamp("1609459200000", false));
52            
53            // 微秒精度（16 位数字）
54            System.out.println(convertTimestamp("1609459200000000", true));
55        } catch (IllegalArgumentException e) {
56            System.err.println(e.getMessage());
57        }
58    }
59}
60

1// C# 时间戳转换，自动格式检测
2using System;
3
4class TimestampConverter
5{
6    public static string ConvertTimestamp(string timestamp, bool use12Hour)
7    {
8        // 修剪输入
9        timestamp = timestamp.Trim();
10        
11        // 根据数字长度检测时间戳格式
12        DateTime dateTime;
13        if (timestamp.Length == 16)
14        {
15            // 微秒精度（除以 1,000,000 以获得秒）
16            if (!double.TryParse(timestamp, out double microseconds))
17                throw new ArgumentException("无效的时间戳格式");
18                
19            // 转换微秒为 DateTime
20            dateTime = DateTimeOffset.FromUnixTimeSeconds(0).DateTime.AddSeconds(microseconds / 1000000);
21            Console.WriteLine("检测到：微秒精度时间戳");
22        }
23        else if (timestamp.Length == 13)
24        {
25            // 毫秒精度
26            if (!long.TryParse(timestamp, out long milliseconds))
27                throw new ArgumentException("无效的时间戳格式");
28                
29            dateTime = DateTimeOffset.FromUnixTimeMilliseconds(milliseconds).DateTime;
30            Console.WriteLine("检测到：毫秒精度时间戳");
31        }
32        else if (timestamp.Length == 10)
33        {
34            // 标准 Unix 时间戳（秒）
35            if (!long.TryParse(timestamp, out long seconds))
36                throw new ArgumentException("无效的时间戳格式");
37                
38            dateTime = DateTimeOffset.FromUnixTimeSeconds(seconds).DateTime;
39            Console.WriteLine("检测到：标准 Unix 时间戳（秒）");
40        }
41        else
42        {
43            throw new ArgumentException("无效的时间戳格式。期望 10、13 或 16 位数字。");
44        }
45        
46        // 根据 12 小时或 24 小时偏好返回格式字符串
47        string formatString = use12Hour 
48            ? "dddd, MMMM d, yyyy h:mm:ss tt"  // 12 小时格式，带 AM/PM
49            : "dddd, MMMM d, yyyy HH:mm:ss";   // 24 小时格式
50        
51        // 返回格式化的日期字符串
52        return dateTime.ToString(formatString);
53    }
54    
55    static void Main()
56    {
57        try
58        {
59            // 标准 Unix 时间戳（10 位数字）
60            Console.WriteLine(ConvertTimestamp("1609459200", false));
61            
62            // 毫秒精度（13 位数字）
63            Console.WriteLine(ConvertTimestamp("1609459200000", false));
64            
65            // 微秒精度（16 位数字）
66            Console.WriteLine(ConvertTimestamp("1609459200000000", true));
67        }
68        catch (ArgumentException e)
69        {
70            Console.WriteLine(e.Message);
71        }
72    }
73}
74