1# 파이썬 타임스탬프 변환기 자동 형식 감지
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        # 표준 유닉스 타임스탬프 (초)
20        date = datetime.datetime.fromtimestamp(numeric_timestamp)
21        print("감지됨: 표준 유닉스 타임스탬프 (초)")
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"  # AM/PM이 있는 12시간 형식
28    else:
29        format_string = "%A, %B %d, %Y %H:%M:%S"     # 24시간 형식
30    
31    return date.strftime(format_string)
32
33# 예제 사용법
34try:
35    # 표준 유닉스 타임스탬프 (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 = $numericTimestamp / 1000000;
11        echo "감지됨: 마이크로초 정밀도 타임스탬프\n";
12    } elseif (strlen($timestamp) === 13) {
13        // 밀리초 정밀도
14        $seconds = $numericTimestamp / 1000;
15        echo "감지됨: 밀리초 정밀도 타임스탬프\n";
16    } elseif (strlen($timestamp) === 10) {
17        // 표준 유닉스 타임스탬프 (초)
18        $seconds = $numericTimestamp;
19        echo "감지됨: 표준 유닉스 타임스탬프 (초)\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'  // AM/PM이 있는 12시간 형식
27        : 'l, F j, Y H:i:s';   // 24시간 형식
28    
29    // 날짜 변환 및 형식화
30    return date($formatString, $seconds);
31}
32
33// 예제 사용법
34try {
35    // 표준 유닉스 타임스탬프 (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// 자바 타임스탬프 변환기 자동 형식 감지
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            // 표준 유닉스 타임스탬프 (초)
28            long seconds = Long.parseLong(timestamp);
29            Instant instant = Instant.ofEpochSecond(seconds);
30            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
31            System.out.println("감지됨: 표준 유닉스 타임스탬프 (초)");
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            // 표준 유닉스 타임스탬프 (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            // 표준 유닉스 타임스탬프 (초)
35            if (!long.TryParse(timestamp, out long seconds))
36                throw new ArgumentException("유효하지 않은 타임스탬프 형식");
37                
38            dateTime = DateTimeOffset.FromUnixTimeSeconds(seconds).DateTime;
39            Console.WriteLine("감지됨: 표준 유닉스 타임스탬프 (초)");
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"  // AM/PM이 있는 12시간 형식
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            // 표준 유닉스 타임스탬프 (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