日付をJSON文字列にするには

import json
from datetime import datetime, timedelta, timezone
 
JST = timezone(timedelta(hours=9))
event = {"name": "定例会", "starts_at": datetime(2026, 10, 22, 9, 5, tzinfo=JST)}
 
# 既定のままでは datetime を文字列にできない
try:
    json.dumps(event)
except TypeError as e:
    print("TypeError:", e)  # TypeError: Object of type datetime is not JSON serializable
 
 
# default には「変換できない値」が来たときだけ呼ばれる関数を渡す
def to_jsonable(o):
    if isinstance(o, datetime):
        return o.isoformat()
    raise TypeError(f"{type(o).__name__} は JSON にできない")
 
 
text = json.dumps(event, ensure_ascii=False, default=to_jsonable)
print(text)  # {"name": "定例会", "starts_at": "2026-10-22T09:05:00+09:00"}
 
# 読み戻しても文字列のまま。日付型に戻すには自分で変換する
back = json.loads(text)
print(type(back["starts_at"]).__name__)  # str
print(datetime.fromisoformat(back["starts_at"]).utcoffset())  # 9:00:00

const event = { name: "定例会", startsAt: new Date("2026-10-22T09:05:00+09:00") };
 
// Date は toJSON を持つので、JSON.stringify が自動で ISO 8601 の文字列にする
const text = JSON.stringify(event);
console.log(text); // {"name":"定例会","startsAt":"2026-10-22T00:05:00.000Z"}（UTC に直されて +09:00 は残らない）
 
// 読み戻しても文字列のまま。Date に戻すには reviver で変換する
const back = JSON.parse(text);
console.log(typeof back.startsAt, back.startsAt instanceof Date); // string false
 
const revived = JSON.parse(text, (key, value) => (key === "startsAt" ? new Date(value) : value));
console.log(revived.startsAt instanceof Date, revived.startsAt.getTime() === event.startsAt.getTime()); // true true

type Meeting = { name: string; startsAt: Date };
// JSON に入った形は Date ではなく string なので、別の型で受ける
type MeetingJson = { name: string; startsAt: string };
 
const meeting: Meeting = { name: "定例会", startsAt: new Date("2026-10-22T09:05:00+09:00") };
 
const text = JSON.stringify(meeting);
console.log(text); // {"name":"定例会","startsAt":"2026-10-22T00:05:00.000Z"}
 
// JSON.parse の戻り値は any なので、型を付けただけでは Date に変わらない
const wire = JSON.parse(text) as MeetingJson;
const back: Meeting = { name: wire.name, startsAt: new Date(wire.startsAt) };
console.log(back.startsAt instanceof Date, back.startsAt.getTime() === meeting.startsAt.getTime()); // true true

package main
 
import (
	"encoding/json"
	"fmt"
	"time"
)
 
type Event struct {
	Name     string     `json:"name"`
	StartsAt time.Time  `json:"startsAt"`
	EndsAt   *time.Time `json:"endsAt,omitempty"` // 未定は nil にすると出力されない
}
 
func main() {
	jst := time.FixedZone("JST", 9*60*60)
	e := Event{Name: "定例会", StartsAt: time.Date(2026, 10, 22, 9, 5, 0, 0, jst)}
 
	// time.Time は RFC 3339 の文字列になり、オフセットも残る
	b, _ := json.Marshal(e)
	fmt.Println(string(b)) // {"name":"定例会","startsAt":"2026-10-22T09:05:00+09:00"}
 
	// 読み戻すと time.Time に戻る
	var back Event
	if err := json.Unmarshal(b, &back); err != nil {
		panic(err)
	}
	fmt.Println(back.StartsAt.Equal(e.StartsAt)) // true
 
	// ゼロ値の time.Time は省略されず、0001 年として出力される
	z, _ := json.Marshal(Event{Name: "未定"})
	fmt.Println(string(z)) // {"name":"未定","startsAt":"0001-01-01T00:00:00Z"}
}

// Cargo.toml に次を追加する
// chrono = { version = "0.4", features = ["serde"] }
// serde = { version = "1", features = ["derive"] }
// serde_json = "1"
use chrono::{DateTime, FixedOffset};
use serde::{Deserialize, Serialize};
 
#[derive(Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
struct Event {
    name: String,
    starts_at: DateTime<FixedOffset>,
}
 
fn main() -> Result<(), serde_json::Error> {
    let event = Event {
        name: "定例会".to_string(),
        starts_at: DateTime::parse_from_rfc3339("2026-10-22T09:05:00+09:00").unwrap(),
    };
 
    // serde feature を有効にした chrono は RFC 3339 の文字列にする。オフセットも残る
    let text = serde_json::to_string(&event)?;
    println!("{text}"); // {"name":"定例会","startsAt":"2026-10-22T09:05:00+09:00"}
 
    // 読み戻すと DateTime<FixedOffset> に戻る
    let back: Event = serde_json::from_str(&text)?;
    println!("{}", back.starts_at == event.starts_at); // true
    Ok(())
}

// jackson-databind と jackson-datatype-jsr310 が必要
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import java.time.OffsetDateTime;
 
public class Main {
    public static void main(String[] args) throws Exception {
        var event = new Event("定例会", OffsetDateTime.parse("2026-10-22T09:05:00+09:00"));
 
        // 標準の ObjectMapper は java.time を扱えず、例外になる
        try {
            new ObjectMapper().writeValueAsString(event);
        } catch (Exception e) {
            System.out.println(e.getClass().getSimpleName());
        }
 
        // JavaTimeModule を登録し、数値ではなく ISO 8601 の文字列で書く設定にする
        ObjectMapper mapper = new ObjectMapper()
                .registerModule(new JavaTimeModule())
                .disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
        String text = mapper.writeValueAsString(event);
        System.out.println(text); // {"name":"定例会","startsAt":"2026-10-22T09:05:00+09:00"}
 
        Event back = mapper.readValue(text, Event.class);
        System.out.println(back.startsAt().isEqual(event.startsAt())); // true
    }
}
 
record Event(String name, OffsetDateTime startsAt) {}

using System.Text.Encodings.Web;
using System.Text.Json;
 
var e = new Event("定例会", new DateTimeOffset(2026, 10, 22, 9, 5, 0, TimeSpan.FromHours(9)));
var options = new JsonSerializerOptions
{
    PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
    Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping, // 日本語をそのまま出す
};
 
// DateTimeOffset は ISO 8601 の文字列になり、オフセットも残る
string text = JsonSerializer.Serialize(e, options);
Console.WriteLine(text); // {"name":"定例会","startsAt":"2026-10-22T09:05:00+09:00"}
 
// 読み戻すと DateTimeOffset に戻る
var back = JsonSerializer.Deserialize<Event>(text, options)!;
Console.WriteLine(back.StartsAt == e.StartsAt); // True
 
// DateTime は Kind によって出力が変わる。Unspecified はオフセットが付かない
Console.WriteLine(JsonSerializer.Serialize(new DateTime(2026, 10, 22, 9, 5, 0, DateTimeKind.Unspecified)));
Console.WriteLine(JsonSerializer.Serialize(new DateTime(2026, 10, 22, 9, 5, 0, DateTimeKind.Utc)));
 
record Event(string Name, DateTimeOffset StartsAt);