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        // ミリ秒精度
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        // フォーマット文字列に基づいて
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