UNIXタイムスタンプを日付に変換するには

from datetime import datetime, timezone
from zoneinfo import ZoneInfo
 
ts = 1700000000  # エポック秒（10 桁）
 
utc = datetime.fromtimestamp(ts, tz=timezone.utc)
print(utc)  # 2023-11-14 22:13:20+00:00
 
# 表示したいタイムゾーンへは astimezone で変換する
jst = utc.astimezone(ZoneInfo("Asia/Tokyo"))
print(jst)  # 2023-11-15 07:13:20+09:00
 
# tz を省くと、実行環境のローカル時刻（タイムゾーン情報なし）になる
print(datetime.fromtimestamp(ts))  # TZ=Asia/Tokyo の環境では 2023-11-15 07:13:20
 
# ミリ秒（13 桁）は 1000 で割ってから渡す
ms = 1700000000123
print(datetime.fromtimestamp(ms / 1000, tz=timezone.utc))  # 2023-11-14 22:13:20.123000+00:00
 
# ミリ秒のまま渡すと範囲外で ValueError になる
try:
    datetime.fromtimestamp(ms, tz=timezone.utc)
except ValueError as e:
    print(e)  # year 55840 is out of range

const sec = 1700000000; // エポック秒（10 桁）
 
const date = new Date(sec * 1000); // Date が受け取るのはミリ秒
console.log(date.toISOString()); // 2023-11-14T22:13:20.000Z
 
// 表示したいタイムゾーンを指定して整形する
console.log(date.toLocaleString("ja-JP", { timeZone: "Asia/Tokyo" })); // 2023/11/15 7:13:20
 
// 秒のまま渡すと 1970 年 1 月の日付になる
console.log(new Date(sec).toISOString()); // 1970-01-20T16:13:20.000Z
 
// 不正な値は Invalid Date になり、toISOString は RangeError を投げる
const bad = new Date(Number("abc"));
console.log(Number.isNaN(bad.getTime())); // true
try {
  bad.toISOString();
} catch (e) {
  console.log(e.message); // Invalid time value
}

type EpochSeconds = number & { readonly __unit: "seconds" };
type EpochMillis = number & { readonly __unit: "millis" };
 
const fromSeconds = (s: EpochSeconds): Date => new Date(s * 1000);
const fromMillis = (ms: EpochMillis): Date => new Date(ms);
 
const sec = 1700000000 as EpochSeconds;
const ms = 1700000000123 as EpochMillis;
 
console.log(fromSeconds(sec).toISOString()); // 2023-11-14T22:13:20.000Z
console.log(fromMillis(ms).toISOString()); // 2023-11-14T22:13:20.123Z
 
// 単位を取り違えた呼び出しはコンパイルエラーになる
// fromSeconds(ms); // error TS2345: Argument of type 'EpochMillis' is not assignable to parameter of type 'EpochSeconds'.

package main
 
import (
	"fmt"
	"time"
)
 
func main() {
	sec := int64(1700000000) // エポック秒（10 桁）
 
	t := time.Unix(sec, 0) // ローカルタイムゾーンの time.Time になる
	fmt.Println(t)         // TZ=Asia/Tokyo の環境では 2023-11-15 07:13:20 +0900 JST
	fmt.Println(t.UTC())   // 2023-11-14 22:13:20 +0000 UTC
	fmt.Println(t.UTC().Format(time.RFC3339)) // 2023-11-14T22:13:20Z
 
	jst, err := time.LoadLocation("Asia/Tokyo")
	if err != nil {
		panic(err)
	}
	fmt.Println(t.In(jst)) // 2023-11-15 07:13:20 +0900 JST
 
	// ミリ秒は UnixMilli で渡す（Go 1.17 以降）
	fmt.Println(time.UnixMilli(1700000000123).UTC()) // 2023-11-14 22:13:20.123 +0000 UTC
 
	// ミリ秒を Unix に渡してもエラーにはならず、遠い未来の日付になる
	fmt.Println(time.Unix(1700000000123, 0).UTC().Year()) // 55840
}

// Cargo.toml: chrono = "0.4"
use chrono::{DateTime, FixedOffset, Utc};
 
fn main() {
    let sec: i64 = 1_700_000_000; // エポック秒（10 桁）
 
    // 範囲外の値だと None になるので、Option で受け取る
    let utc: DateTime<Utc> = DateTime::from_timestamp(sec, 0).unwrap();
    println!("{utc}"); // 2023-11-14 22:13:20 UTC
    println!("{}", utc.to_rfc3339()); // 2023-11-14T22:13:20+00:00
 
    let jst = FixedOffset::east_opt(9 * 3600).unwrap();
    println!("{}", utc.with_timezone(&jst)); // 2023-11-15 07:13:20 +09:00
 
    // ミリ秒は from_timestamp_millis で渡す
    let ms = DateTime::from_timestamp_millis(1_700_000_000_123).unwrap();
    println!("{ms}"); // 2023-11-14 22:13:20.123 UTC
 
    // ミリ秒を from_timestamp に渡してもエラーにならず、遠い未来の日付になる
    let far = DateTime::from_timestamp(1_700_000_000_123, 0).unwrap();
    println!("{}", far.to_rfc3339()); // +55840-11-08T22:15:23+00:00
 
    // None になるのは chrono が表せる範囲（約 ±26 万年）を超えたとき
    println!("{:?}", DateTime::from_timestamp(i64::MAX, 0)); // None
}

import java.time.Instant;
import java.time.ZoneId;
 
public class Main {
    public static void main(String[] args) {
        long sec = 1_700_000_000L; // エポック秒（10 桁）
 
        Instant instant = Instant.ofEpochSecond(sec);
        System.out.println(instant); // 2023-11-14T22:13:20Z
 
        // 表示したいタイムゾーンは atZone で付ける
        System.out.println(instant.atZone(ZoneId.of("Asia/Tokyo"))); // 2023-11-15T07:13:20+09:00[Asia/Tokyo]
 
        // ミリ秒は ofEpochMilli で渡す
        System.out.println(Instant.ofEpochMilli(1_700_000_000_123L)); // 2023-11-14T22:13:20.123Z
 
        // ミリ秒を ofEpochSecond に渡してもエラーにならず、遠い未来の日付になる
        System.out.println(Instant.ofEpochSecond(1_700_000_000_123L)); // +55840-11-08T22:15:23Z
    }
}

using System;
 
class Program {
    static void Main() {
        long sec = 1700000000; // エポック秒（10 桁）
 
        DateTimeOffset utc = DateTimeOffset.FromUnixTimeSeconds(sec); // オフセットは +00:00
        Console.WriteLine(utc.ToString("o")); // 2023-11-14T22:13:20.0000000+00:00
 
        // 固定オフセットなら ToOffset、夏時間のある地域なら TimeZoneInfo で変換する
        Console.WriteLine(utc.ToOffset(TimeSpan.FromHours(9)).ToString("o")); // 2023-11-15T07:13:20.0000000+09:00
        var tokyo = TimeZoneInfo.FindSystemTimeZoneById("Asia/Tokyo");
        Console.WriteLine(TimeZoneInfo.ConvertTime(utc, tokyo).ToString("o")); // 2023-11-15T07:13:20.0000000+09:00
 
        // ミリ秒は FromUnixTimeMilliseconds で渡す
        Console.WriteLine(DateTimeOffset.FromUnixTimeMilliseconds(1700000000123).ToString("o")); // 2023-11-14T22:13:20.1230000+00:00
 
        // ミリ秒を秒として渡すと、9999 年を超えるため例外になる
        try {
            DateTimeOffset.FromUnixTimeSeconds(1700000000123);
        } catch (ArgumentOutOfRangeException) {
            Console.WriteLine("ArgumentOutOfRangeException");
        }
    }
}