日時(Temporal) - とほほのJavaScript入門

目次

概要

使用例

現在の日時・日付・時刻を得る

タイムゾーンを意識しない場合は plainDateTimeISO()、タイムゾーンを意識する場合は zonedDateTimeISO()、日付のみは plainDateISO()、時刻のみは plainTimeISO() を使用します。

dt = Temporal.Now.plainDateTimeISO();
console.log(dt.toString());                // 2026-01-25T23:59:59.999
dz = Temporal.Now.zonedDateTimeISO();
console.log(dz.toString());                // 2026-01-25T23:59:59.999+09:00[Etc/GMT-9]
d1 = Temporal.Now.plainDateISO();
console.log(d1.toString());                // 2026-01-25
t1 = Temporal.Now.plainTimeISO();
console.log(t1.toString());                // 23:59:59.999

指定した日時を得る

タイムゾーンを意識しない場合は PlainDateTime、タイムゾーンを意識する場合は ZonedDateTime を使用します。

d1 = new Temporal.PlainDateTime(2026, 1, 25, 23, 59, 59);
console.log(d1.toString());                // 2026-01-25T23:59:59
d2 = Temporal.PlainDateTime.from("2026-01-25T23:59:59");
console.log(d2.toString());                // 2026-01-25T23:59:59

下記の様に年月のみを扱う PlainYearMonth、月日のみを扱う PlainMonthDay もあります。

d3 = new Temporal.PlainYearMonth(2026, 12);
console.log(d3.toString());                // 2026-12
d4 = new Temporal.PlainMonthDay(12, 31);
console.log(d4.toString());                // 12-31

時間差分を取得する

時間差分を求めるには since() または until() を使用します。

d1 = Temporal.Now.plainDateTimeISO();
setTimeout(() => {
  d2 = Temporal.Now.plainDateTimeISO();
  console.log(d2.since(d1));
  console.log(d2.since(d1).toString());    // PT1.234S
  console.log(d2.since(d1).seconds);       // 1
  console.log(d2.since(d1).milliseconds);  // 234
}, 1234);

n 時間後の日時を得る

n 時間後、n 時間前などを計算するには add() や subtract() を使用します。

d1 = Temporal.PlainDateTime.from("2026-01-25T23:59:59");
d2 = d1.add({ hours: 5});
console.log(d2.toString());     // 2026-01-26T04:59:59

YYYY/MM/DD HH:MM:SS形式の文字列にフォーマットする

フォーマットは Intl.DateTimeFormat と組み合わせることが推奨されています。

function formatDateTime(dt) {
  const zdt = dt.toZonedDateTime("Asia/Tokyo");
  const formatter = new Intl.DateTimeFormat("ja-JP", {
    timeZone: "Asia/Tokyo", hour12: false,
    year: "numeric", month: "2-digit", day: "2-digit",
    hour: "2-digit", minute: "2-digit", second: "2-digit",    
  });
  return formatter.format(zdt.toInstant());
}
d1 = Temporal.PlainDateTime.from("2026-01-25T23:59:59");
console.log(formatDateTime(d1));             // 2026/01/02 3:04:05

しかし、上記の様に hour に 2-digit を指定しても ja-JP では時間は 0 埋めしないのが一般的というルールが優先され、時間が 0 埋めされないことがあります。確実にフォーマットするには、下記の様な関数を用意するのがよいかもしれません。

function formatDateTime(d) {
  const pad = n => String(n).padStart(2, "0");
  return `${d.year}/${pad(d.month)}/${pad(d.day)} ` +
         `${pad(d.hour)}:${pad(d.minute)}:${pad(d.second)}`;
}
d1 = Temporal.PlainDateTime.from("2026-01-02T03:04:05");
console.log(formatDateTime(d1));             // 2026/01/02 03:04:05

YYYY/MM/DD HH:MM:SS形式の文字列をパースする

Temporal は標準形式以外のパース機能をサポートしていないので、下記の様な自作関数を用意するのがよさそうです。

function parseDateTime(s) {
  const [datePart, timePart] = s.split(" ");
  const [year, month, day] = datePart.split("/").map(Number);
  const [hour, minute, second] = timePart.split(":").map(Number);
  return new Temporal.PlainDateTime(year, month, day, hour, minute, second);
}
d1 = parseDateTime("2026/01/25 23:59:59");
console.log(d1.toString());      // 2026-01-25T23:59:59

オブジェクト種別

Temporal では下記のクラスオブジェクトをサポートしています。

用語

暦(calendar)

タイムゾーン(timeZone)

オブジェクト生成

Temporal.Now

Temporal.Now.zonedDateTimeISO([timeZone])

現在のタイムゾーン情報付き日時オブジェクトを生成します。

d = Temporal.Now.zonedDateTimeISO();
console.log(d.toString());                         // 2026-01-25T23:59:59.999+09:00[Etc/GMT-9]
d = Temporal.Now.zonedDateTimeISO("Asia/Tokyo");
console.log(d.toString());                         // 2026-01-25T23:59:59.999+09:00[Asia/Tokyo]

Temporal.Now.plainDateTimeISO([timeZone])

現在のタイムゾーン情報無し日時オブジェクトを生成します。

d = Temporal.Now.plainDateTimeISO();
console.log(d.toString());                         // 2026-01-25T23:59:59.999

Temporal.Now.plainDateISO([timeZone])

現在のタイムゾーン情報無し日付オブジェクトを生成します。

d = Temporal.Now.plainDateISO();
console.log(d.toString());                         // 2026-01-25

Temporal.Now.plainTimeISO([timeZone])

現在のタイムゾーン情報無し時刻オブジェクトを生成します。

d = Temporal.Now.plainTimeISO();
console.log(d.toString());                         // 23:59:59.999

Temporal.Now.instant()

現在のエポックタイムオブジェクトを生成します。

d = Temporal.Now.instant();
console.log(d.epochMilliseconds);                  // 1769182272460
console.log(d.epochNanoseconds);                   // 1769182272460000000n

Temporal.ZonedDateTime

タイムゾーン情報付きの日時を表すクラスです。

Temporal.ZonedDateTime(epochNanoseconds, timeZone, [calendar])

タイムゾーン付き日時オブジェクトを生成します。

now = Temporal.Now.instant();
d = new Temporal.ZonedDateTime(now.epochNanoseconds, "Asia/Tokyo");
console.log(d.toString());                         // 2026-01-25T23:59:59.999+09:00[Asia/Tokyo]

Temporal.ZonedDateTime.from(info, [options])

タイムゾーン付き日時オブジェクトを生成します。options は with() を参照してください。

d = Temporal.ZonedDateTime.from("2026-01-25T23:59:59[Asia/Tokyo]");
console.log(d.toString());                         // 2026-01-25T23:59:59+09:00[Asia/Tokyo]
d = Temporal.ZonedDateTime.from({
    year: 2026, month: 1, day: 25,
    hour: 23, minute: 59, second: 59,
    timeZone: "Asia/Tokyo" });
console.log(d.toString());                         // 2026-01-25T23:59:59+09:00[Asia/Tokyo]

Temporal.PlainDateTime

Temporal.PlainDateTime(year, month, day, [hour, [minute, [second, [millisecond, [microsecond, [nanosecond, [calendar]]]]]]])

タイムゾーン情報を持たない日時オブジェクトを生成します。

d = new Temporal.PlainDateTime(2026, 1, 25, 23, 59, 59, 999);
console.log(d.toString());                         // 2026-01-25T23:59:59.999

Temporal.PlainDateTime.from(info, [options])

タイムゾーン情報を持たない日時オブジェクトを生成します。options は with() の overflow を参照してください。

d = Temporal.PlainDateTime.from("2026-01-25T23:59:59");
console.log(d.toString());                         // 2026-01-25T23:59:59
d = Temporal.PlainDateTime.from({
    year: 2026, month: 1, day: 25,
    hour: 23, minute: 59, second: 59 });
console.log(d.toString());                         // 2026-01-25T23:59:59

Temporal.PlainDate

Temporal.PlainDate(year, month, day, [calendar])

タイムゾーン情報を持たない日付オブジェクトを生成します。

d = new Temporal.PlainDate(2026, 1, 25);
console.log(d.toString());                         // 2026-01-25

Temporal.PlainDate.from(into, [options])

タイムゾーン情報を持たない日付オブジェクトを生成します。options は with() の overflow を参照してください。

d = Temporal.PlainDate.from("2026-01-25");
console.log(d.toString());                         // 2026-01-25
d = Temporal.PlainDate.from({ year: 2026, month: 1, day: 25 });
console.log(d.toString());                         // 2026-01-25

Temporal.PlainTime

Temporal.PlainTime(hour, minute, [second, [millisecond, [microsecond, [nanosecond]]]])

タイムゾーン情報を持たない時刻オブジェクトを生成します。

d = new Temporal.PlainTime(23, 59, 59);
console.log(d.toString());                         // 23:59:59

Temporal.PlainTime.from(info, [options])

タイムゾーン情報を持たない時刻オブジェクトを生成します。options は with() の overflow を参照してください。

d = Temporal.PlainTime.from("23:59:59.999999");
console.log(d.toString());                         // 23:59:59.999999
d = Temporal.PlainTime.from({ hour: 23, minute: 59, second: 59, millisecond: 999, microsecond: 999 });
console.log(d.toString());                         // 23:59:59.999999

Temporal.PlainYearMonth

Temporal.PlainYearMonth(year, month, [calendar, [referenceDay]])

タイムゾーン情報を持たない年月オブジェクトを生成します。

d = new Temporal.PlainYearMonth(2026, 1);
console.log(d.toString());                         // 2026-01

Temporal.PlainYearMonth.from(info, [options])

タイムゾーン情報を持たない年月オブジェクトを生成します。options は with() の overflow を参照してください。

d = Temporal.PlainYearMonth.from("2026-01-25");
console.log(d.toString());                         // 2026-01
d = Temporal.PlainYearMonth.from({ year: 2026, month: 1 });
console.log(d.toString());                         // 2026-01

Temporal.PlainMonthDay

Temporal.PlainMonthDay(month, day, [calendar, [referenceYear]])

タイムゾーン情報を持たない月日オブジェクトを生成します。referenceDay には参考年を指定します。例えば 2024 年はうるう年なので2月29日を指定できますが、2025年だとエラーとなります。

d1 = new Temporal.PlainMonthDay(1, 25);
console.log(d1.toString());                        // 01-25
d2 = new Temporal.PlainMonthDay(2, 29, undefined, 2024);
console.log(d2.toString());                        // 02-29
d3 = new Temporal.PlainMonthDay(2, 29, undefined, 2025);
console.log(d3.toString());                        // RangeError

Temporal.PlainMonthDay.from(info, [options])

タイムゾーン情報を持たない月日オブジェクトを生成します。options は with() の overflow を参照してください。

d = Temporal.PlainMonthDay.from("01-25");
console.log(d.toString());                         // 01-25
d = Temporal.PlainMonthDay.from({ month: 1, day: 25 });
console.log(d.toString());                         // 01-25

Temporal.Instant

エポックタイムと呼ばれる、1970年1月1日0時0分0秒(UTC)からの経過時間を扱うクラスです。ミリ秒(epochMilliseconds)と BigInt 型のナノ秒(epochNanoseconds)のメンバを持ちます。

Temporal.Instant(epochNanoseconds)

エポックタイムオブジェクトを生成します。

d = new Temporal.Instant(1769385599000000000n);
console.log(d.epochMilliseconds);                  // 1769385599000
console.log(d.epochNanoseconds);                   // 1769385599000000000n

Temporal.Instant.from(info)

エポックタイムオブジェクトを生成します。{ year: ... } の形式は使用できません。

d = Temporal.Instant.from("2026-01-25T23:59:59Z");
console.log(d.epochMilliseconds);                  // 1769385599000
console.log(d.epochNanoseconds);                   // 1769385599000000000n

Temporal.Instant.fromEpochMilliseconds(epochMilliseconds)

エポックタイムオブジェクトを生成します。

d = Temporal.Instant.fromEpochMilliseconds(1769385599000);
console.log(d.epochMilliseconds);                  // 1769385599000
console.log(d.epochNanoseconds);                   // 1769385599000000000n

Temporal.Instant.fromEpochNanoseconds(epochNanoseconds)

エポックタイムオブジェクトを生成します。

d = Temporal.Instant.fromEpochNanoseconds(1769385599000000000n);
console.log(d.epochMilliseconds);                  // 1769385599000
console.log(d.epochNanoseconds);                   // 1769385599000000000n

Temporal.Duration

時間差分を表すクラスです。時間差分は PnYnMnWnDTnHnMn.nnnnnnnnnS のような文字列でも表されます。1Y は1年、3D は3日を意味します。T は日付と時刻の区切り文字です。

Temporal.Duration(years, months, [weeks, [days, [hours, [minutes, [seconds, [milliseconds, [microseconds, [nanoseconds]]]]]]]])

時間差分オブジェクトを生成します。下記の例では、1年2ヶ月と3日4時間5分6.999999999秒の時間差オブジェクトを生成しています。

d = new Temporal.Duration(1, 2, undefined, 3, 4, 5, 6);
console.log(d.toString());                         // P1Y2M3DT4H5M6.999999999S

Temporal.Duration.from(info)

時間差分オブジェクトを生成します。

d = Temporal.Duration.from("P1Y2M3DT4H5M6.999999999S");
console.log(d.toString());                         // P1Y2M3DT4H5M6.999999999S
d = Temporal.Duration.from({ years: 1, months: 2 });
console.log(d.toString());                         // P1Y2M

プロパティ

日時オブジェクトは下記のプロパティを持ちます。オブジェクトによっては持たないものもあります。

d = Temporal.ZonedDateTime.from("2026-01-25T23:59:59.123456789[Asia/Tokyo]");

メソッド・関数

(広義の)日時オブジェクトやエポックタイムオブジェクトで概ね共通で使用可能なメソッドを下記に示します。オブジェクトによっては使用できないものもあります。

add(duration)

日時オブジェクトやエポックタイムオブジェクトに時間差分を加えます。

now = Temporal.Now.plainDateTimeISO();             // 現在時刻を取得
duration = Temporal.Duration.from("P1M");          // 時間差分(1ヶ月)
one_month_later = now.add(duration);               // 時間差分を加える
console.log(now.toString());                       // 2026-01-25T23:59:59
console.log(one_month_later.toString());           // 2026-02-25T23:59:59

下記の様な指定もできます。

d1 = Temporal.PlainDateTime.from("2026-01-25T23:59:59");
console.log(d1.add({ months: 2 }).toString());     // 2026-03-25T23:59:59
console.log(d1.add("P2M").toString());             // 2026-03-25T23:59:59

subtract(duration)

日時オブジェクトやエポックタイムオブジェクトに時間差分を減算します。

now = Temporal.Now.plainDateTimeISO();             // 現在時刻を取得
duration = Temporal.Duration.from("P1M");          // 時間差分(1ヶ月)
one_month_ago = now.subtract(duration);            // 時間差分を減算する
console.log(now.toString());                       // 2026-01-25T23:59:59
console.log(one_month_ago.toString());             // 2025-12-25T23:59:59

下記の様な指定もできます。

d1 = Temporal.PlainDateTime.from("2026-03-25T23:59:59");
console.log(d1.subtract({ months: 2 }).toString());// 2026-01-25T23:59:59
console.log(d1.subtract("P2M").toString());        // 2026-01-25T23:59:59

since(other, [options])

日時オブジェクトやエポックタイムオブジェクトの時間差分を求めます。d1.since(d2) は、d2 から d1 までの時間差分を求めます。

d1 = Temporal.PlainDateTime.from("2026-01-25T15:00:00");
d2 = Temporal.PlainDateTime.from("2026-01-24T15:00:00");
duration = d1.since(d2);
console.log(duration.toString());                  // P1D

until(other, [options])

日時オブジェクトやエポックタイムオブジェクトの時間差分を求めます。d1.until(d2) は、d1 から d2 までの時間差分を求めます。

d1 = Temporal.PlainDateTime.from("2026-01-24T15:00:00");
d2 = Temporal.PlainDateTime.from("2026-01-25T15:00:00");
duration = d1.until(d2);
console.log(duration.toString());                  // P1D

round(options)

日時オブジェクトやエポックタイムオブジェクトを単位で丸めます。options には下記を指定します。round("minute") は round({smallestUnit: "minute"}) の省略形です。

smallestUnit
指定した単位に丸めます。day, hour, minute, second, millisecond, microsecond, nanosecond のいずれかを指定します。
roundingMode
丸めモードを指定します。正方向に丸める(ceil)、負方向に丸める(floor)、0から離れる方向に丸める(expand)、0に近づく方向に丸める(trunc)、0.5はceilその他は四捨五入(halfCeil)、0.5はfloorその他は四捨五入(halfFloor)、0.5はexpand(halfExpand)、0.5はtrunc(halfTrunc)、0.5は偶数になるように丸める(halfEven)のいずれかを指定します。デフォルトは halfExpand です。
roundingIncrement
丸め増分を示します。例えば smallestUnit が minute で roundingIncrement が 30 の場合、30分単位に丸めることを意味します。
d1 = Temporal.PlainDateTime.from("2026-01-25T12:34:56.123456789");
d2 = d1.round("second");
console.log(d2.toString());                        // 2026-01-25T12:34:56 (秒で丸める)
d2 = d1.round({roundingMode: "floor", smallestUnit: "hour"});
console.log(d2.toString());                        // 2026-01-25T12:00:00 (時間で丸める-切り捨て)
d2 = d1.round({roundingIncrement: 30, smallestUnit: "minute"});
console.log(d2.toString());                        // 2026-01-25T12:30:00 (30分単位に丸める)

equals(other)

日時オブジェクトやエポックタイムオブジェクトが等しい日時を示しているか否かを判断します。

d1 = Temporal.ZonedDateTime.from("2026-01-25T12:34:56.123456789[Asia/Tokyo]");
d2 = Temporal.Instant.fromEpochNanoseconds(1769312096123456789n);
console.log(d2.toString());                        // 2026-01-25T12:30:00 (30分単位に丸める)
console.log(d1.toString());                        // 2026-01-25T12:34:56.123456789+09:00[Asia/Tokyo]
console.log(d2.toString());                        // 2026-01-25T03:34:56.123456789Z
console.log(d2.equals(d1));                        // true

compare(obj1, obj2)

日時オブジェクトやエポックタイムオブジェクトを比較し、等しければ 0、obj1 が古ければ -1、新しければ 1 を返します。クラスメソッドではなくスタティック関数として用意されています。

d1 = Temporal.PlainDateTime.from("2026-01-25T12:34:56");
d2 = Temporal.PlainDateTime.from("2026-12-31T12:34:56");
console.log(Temporal.PlainDateTime.compare(d1, d2));  // -1

toString([options])

日時オブジェクトやエポックタイムオブジェクトや差分オブジェクトを文字列化します。options には下記を指定できます。

smallestUnit
round() を参照してください。
roundingMode
round() を参照してください。
fractionalSecondDigits
1秒未満の秒数を何桁まで表示するかを 0～9 の数値または auto で指定します。
timeZone
"Asia/Tokyo" や "UTC" などのタイムゾーンを指定します。
d1 = Temporal.ZonedDateTime.from("2026-01-25T12:34:56.999999999[Asia/Tokyo]");
console.log(d1.toString());                            // 2026-01-25T12:34:56.999999999+09:00[Asia/Tokyo]
d1 = Temporal.PlainDateTime.from("2026-01-25T12:34:56");
console.log(d1.toString());                            // 2026-01-25T12:34:56
d1 = Temporal.Instant.fromEpochMilliseconds(0);
console.log(d1.toString({timeZone: "Asia/Tokyo"}));    // 1970-01-01T09:00:00+09:00
console.log(d1.toString({timeZone: "UTC"}));           // 1970-01-01T00:00:00+00:00
console.log(d1.toString({fractionalSecondDigits: 6})); // 1970-01-01T00:00:00+00:00.000000Z

toJSON()

日時オブジェクトやエポックタイムオブジェクトや差分オブジェクトを文字列化します。toString() が人間の読みやすさを重視するのに対し、toJSON() は option による変換もなく JSON でデータ交換することを目的としてデータの正確性を重視します。

d1 = Temporal.PlainDateTime.from("2026-01-25T12:34:56");
console.log(d1.toJSON());                          // 2026-01-25T12:34:56
d1 = Temporal.ZonedDateTime.from("2026-01-25T12:34:56[Asia/Tokyo]");
console.log(d1.toJSON());                          // 2026-01-25T12:34:56+09:00[Asia/Tokyo]

toLocaleString([locales, [options])

日時オブジェクトを言語に依存した文字列に変換します。locales には "ja", "en", "en-US" などの言語を表す BCP 47 言語タグを指定します。候補として配列を指定することもできます。

d1 = Temporal.ZonedDateTime.from("2026-01-25T12:34:56[Asia/Tokyo]");
console.log(d1.toLocaleString("ja"));      // 2026/1/25 12:34:56 JST
d1 = Temporal.ZonedDateTime.from("2026-01-25T12:34:56[America/New_York]");
console.log(d1.toLocaleString("en-US"));   // 1/25/2026, 12:34:56 PM EST

options には下記を指定できます。

localeMatcher
ロケールのマッチングルールを 厳密("lookup")、ベストフィット("best fit")(規定値) のいずれかで指定します。
calendar
使用する 暦(calendar) を指定します。
numberingSystem
使用する数字種をラテン数字(latn)、漢数字(hanidec) などから指定します。指定可能な数字種は Intl.supportedValuesOf("numberingSystem") で確認できます。(参考) 
d1 = Temporal.ZonedDateTime.from("2026-01-25T12:34:56[Asia/Tokyo]");
console.log(d1.toLocaleString("ja", {numberingSystem: "hanidec"}));  // 二〇二六/一/二五 一二:三四:五六 JST
hour12
true を指定すると12時間表記となります。ただし、ロケールのデフォルトが優先されて12時間表記にならないこともあります。日本の場合、下記の様に指定すると12時間表記となるようです。 
d.toLocaleString("ja", {dateStyle:"long", timeStyle:"long", hourCycle:"h12"});  // 2026/1/25 午後3:34:56 JST
hourCycle
12:00 や 24:00 を 12:00 や 24:00 と表示するか、00:00 と表示するかを指定します。h11 は 0～11時、h12 は 1～12時、h23 は 0～23時、h24 は 1～24時で表記します。ただし、ロケールのデフォルトが優先され、指定してもうまく反映されないことがあります。
timeZone
タイムゾーン を指定します。
dateStyle
日付のフォーマットを full, long, medium, short のいずれかで指定します。何故か short より long の方が長く表示されます。 
d1 = Temporal.ZonedDateTime.from("2026-01-25T12:34:56[Asia/Tokyo]");
console.log(d1.toLocaleString("ja", {dateStyle: "full"}));   // 2026/1/25日曜日
console.log(d1.toLocaleString("ja", {dateStyle: "long"}));   // 2026/1/25
console.log(d1.toLocaleString("ja", {dateStyle: "medium"})); // 2026/01/25
console.log(d1.toLocaleString("ja", {dateStyle: "short"}));  // 2026/01/25
timeStyle
時刻のフォーマットを full, long, medium, short のいずれかで指定します。 
d1 = Temporal.ZonedDateTime.from("2026-01-25T12:34:56[Asia/Tokyo]");
console.log(d1.toLocaleString("ja", {timeStyle: "full"}));   // 12時24分56秒 日本標準時
console.log(d1.toLocaleString("ja", {timeStyle: "long"}));   // 12:34:56 JST
console.log(d1.toLocaleString("ja", {timeStyle: "medium"})); // 12:34:56
console.log(d1.toLocaleString("ja", {timeStyle: "short"}));  // 12:34
month
月のフォーマットを long, short, narrow, numeric, 2-digit のいずれかで指定します。 
d1 = Temporal.ZonedDateTime.from("2026-01-25T12:34:56[Asia/Tokyo]");
console.log(d1.toLocaleString("ja", {month: "long"}));     // 1月
console.log(d1.toLocaleString("ja", {month: "short"}));    // 1月
console.log(d1.toLocaleString("ja", {month: "narrow"}));   // 1月
console.log(d1.toLocaleString("ja", {month: "numeric"}));  // 1月
console.log(d1.toLocaleString("ja", {month: "2-digit"}));  // 01月
day
日のフォーマットを numeric, 2-digit のいずれかで指定します。しかし、Chrome の場合 2-digit を指定しても0埋めにはならないようです。 
d1 = Temporal.ZonedDateTime.from("2026-01-05T12:34:56[Asia/Tokyo]");
console.log(d1.toLocaleString("ja", {day: "numeric"}));    // 5日
console.log(d1.toLocaleString("ja", {day: "2-digit"}));    // 05日
weekday
曜日のフォーマットを long, short, narrow のいずれかで指定します。 
d1 = Temporal.ZonedDateTime.from("2026-01-25T12:34:56[Asia/Tokyo]");
console.log(d1.toLocaleString("ja", {weekday: "long"}));    // 日曜日
console.log(d1.toLocaleString("ja", {weekday: "short"}));   // 日
console.log(d1.toLocaleString("ja", {weekday: "narrow"}));  // 日
hour
時のフォーマットを numeric, 2-digit のいずれかで指定します。しかし、Chrome の場合 2-digit を指定しても0埋めにはならないようです。 
d1 = Temporal.ZonedDateTime.from("2026-01-25T01:02:03[Asia/Tokyo]");
console.log(d1.toLocaleString("ja", {hour: "numeric"}));   // 1時
console.log(d1.toLocaleString("ja", {hour: "2-digit"}));   // 1時
minute
分のフォーマットを numeric, 2-digit のいずれかで指定します。しかし、Chrome の場合 2-digit を指定しても0埋めにはならないようです。 
d1 = Temporal.ZonedDateTime.from("2026-01-25T01:02:03[Asia/Tokyo]");
console.log(d1.toLocaleString("ja", {minute: "numeric"}));   // 2
console.log(d1.toLocaleString("ja", {minute: "2-digit"}));   // 2
second
秒のフォーマットを numeric, 2-digit のいずれかで指定します。しかし、Chrome の場合 2-digit を指定しても0埋めにはならないようです。 
d1 = Temporal.ZonedDateTime.from("2026-01-25T01:02:03[Asia/Tokyo]");
console.log(d1.toLocaleString("ja", {second: "numeric"}));    // 3
console.log(d1.toLocaleString("ja", {second: "2-digit"}));    // 3
fractionalSecondDigits
1秒未満の秒の桁数を 1～3 の数値で指定します。4 以上を指定するとエラーとなります。 
d1 = Temporal.ZonedDateTime.from("2026-01-25T01:02:03.123456789[Asia/Tokyo]");
console.log(d1.toLocaleString("ja", {fractionalSecondDigits: 1}));    // 1
console.log(d1.toLocaleString("ja", {fractionalSecondDigits: 2}));    // 12 
console.log(d1.toLocaleString("ja", {fractionalSecondDigits: 3}));    // 123
console.log(d1.toLocaleString("ja", {fractionalSecondDigits: 4}));    // エラー
era
時代のフォーマットを long, short, narrow のいずれかで指定します。 
d1 = Temporal.ZonedDateTime.from("2026-01-25T01:02:03.123456789[Asia/Tokyo]");
console.log(d1.toLocaleString("ja", {era: "long"}));    // 西暦
console.log(d1.toLocaleString("ja", {era: "short"}));   // 西暦
console.log(d1.toLocaleString("ja", {era: "narrow"}));  // AD
dayPeriod
朝・昼・夜等のフォーマットを long, short, narrow のいずれかで指定します。日本の場合、フォーマットに関わらず、4時以降は「朝」、12時は「正午」、13時以降は「昼」、16時以降は「夕方」、20時以降は「夜」、23時以降は「夜中」と表示されるようです。 
console.log(Temporal.PlainTime.from("04:00:00").toLocaleString("ja", {dayPeriod: "long"}));  // 朝
console.log(Temporal.PlainTime.from("12:00:00").toLocaleString("ja", {dayPeriod: "long"}));  // 正午
console.log(Temporal.PlainTime.from("13:00:00").toLocaleString("ja", {dayPeriod: "long"}));  // 昼
console.log(Temporal.PlainTime.from("16:00:00").toLocaleString("ja", {dayPeriod: "long"}));  // 夕方
console.log(Temporal.PlainTime.from("20:00:00").toLocaleString("ja", {dayPeriod: "long"}));  // 夜
console.log(Temporal.PlainTime.from("23:00:00").toLocaleString("ja", {dayPeriod: "long"}));  // 夜中
timeZoneName
タイムゾーンのフォーマットを long, short, shortOffset, longOffset, shortGeneric, longGeneric のいずれかで指定します。 
d1 = Temporal.ZonedDateTime.from("2026-01-25T01:02:03.123456789[Asia/Tokyo]");
console.log(d1.toLocaleString("ja", {timeZoneName: "long"}));         // 2026/1/25 1時02分03秒 日本標準時
console.log(d1.toLocaleString("ja", {timeZoneName: "short"}));        // 2026/1/25 1:02:03 JST
console.log(d1.toLocaleString("ja", {timeZoneName: "shortOffset"}));  // 2026/1/25 1:02:03 GMT+9
console.log(d1.toLocaleString("ja", {timeZoneName: "longOffset"}));   // 2026/1/25 1:02:03 GMT+09:00
console.log(d1.toLocaleString("ja", {timeZoneName: "shortGeneric"})); // 2026/1/25 1:02:03 JST
console.log(d1.toLocaleString("ja", {timeZoneName: "longGeneric"}));  // 2026/1/25 1:02:03 日本標準時

with(info, [options])

日時オブジェクトの一部を更新します。info には year, month, day, hour, minute, second, millisecond, microsecond, nanosecond, monthCode, offset, era, eraYear を指定できます。

d1 = Temporal.PlainDateTime.from("2026-01-25T23:59:59");
d1 = d1.with({ month: 12 });
console.log(d1.toString());                // 2026-12-25T23:59:59

options には下記を指定できます。

disambiguation
夏時間と冬時間の切り替え時、同じ時刻が2回出現したり、存在しない時刻があり、時刻を正確に決められない場合の挙動を下記のいずれかで指定します。
  • compatible : なるべく既存の動作と互換性を保つ(規定値)。
  • earlier : 曖昧な場合は早い方の時刻に合わせる。
  • later : 曖昧な場合は遅い方の時刻に合わせる。
  • reject : 曖昧な場合はエラーとする。
offset
不正なオフセットが指定されたり、夏時間から冬時間に変わってしまう場合などの挙動を下記のいずれかで指定します。
  • use : 指定されたオフセットを強制的に使用する。
  • ignore : 指定されたオフセットを無視する。
  • reject : タイムゾーンで許可されていないオフセットはエラーとする。
  • prefer : できれば指定されたオフセットを使用するがタイムゾーンに矛盾する場合はタイムゾーンに従う(規定値)。
overflow
30日しか無い月に31日を指定した場合など数値があふれた際の挙動を正しい値に制約する(constrain)(規定値)、拒絶する(reject) のいずれかで指定します。 
d1 = Temporal.PlainDateTime.from("2026-01-25T23:59:59");
d1 = d1.with({ month: 13 }, { overflow: "constrain" });    // 2026-12-25T23:59:59
d1 = d1.with({ month: 13 }, { overflow: "reject" });       // RangeError

withCalendar(calendar)

グレゴリオ暦など使用する暦を更新します。

d1 = Temporal.ZonedDateTime.from("2021-07-01T12:34:56[America/New_York]");
d2 = d1.withCalendar("islamic-umalqura");
console.log(d2.toLocaleString("en-US", { calendar: "islamic-umalqura" }));  // 11/21/1442 AH, 12:34:56 PM EDT

withTimeZone(timeZone)

"Asia/Tokyo" などのタイムゾーンを変更します。

d1 = Temporal.ZonedDateTime.from("2026-01-25T09:00:00[Asia/Tokyo]");
d2 = d1.withTimeZone("America/New_York");
console.log(d2.toString());    // 2026-01-24T19:00:00-05:00[America/New_York]

withPlainTime(plainTime)

時刻を変更します。plainTime には Temporal.PlainTime.form() の info と同様の引数を指定できます。

d1 = Temporal.ZonedDateTime.from("2026-01-25T09:00:00[Asia/Tokyo]");
d2 = d1.withPlainTime("23:59:59");
d3 = d1.withPlainTime({ hour: 23, minute: 59, second: 59 });

Temporal.Now.timeZoneId()

現在日時のタイムゾーンを返します。Etc/GMT-9 は国名は不明ですが、標準時から9時間ずれた地域であることを示します。

d = Temporal.Now.timeZoneId();
console.log(d.toString());                         // Etc/GMT-9

私だったらこうするかな...

複雑な割には "2026/01/25 23:59:59" 形式へのフォーマットもできないシロモノなので、個人的には使わないかな...と思っています。私だったら、こんな仕様にしているかな。

Copyright (C) 2026 杜甫々
初版：2026年1月25日、最終更新：2026年1月25日
https://www.tohoho-web.com/js/temporal.htm