9時間ずれるのは全部同じ理由 — 日付と時刻の扱い

日付と時刻の扱い。地球儀と二つの時計、カレンダーとデータベース。

9時間ずれるのは、全部同じ理由です。時刻が4つの層で変換されていることを押さえ、TIMESTAMPとDATETIMEの違いを確かめます。

前回: 文字化けは壊れたのではない — 文字コードとUTF-8 作業場所はVMの中(Ubuntu Server)です。MySQL に appdb があり、~/server に Knex が入っている状態から始めます。この記事はタイムゾーンの設定を一時的に変更します。最後に必ず戻します。

いつか必ずこうなります。

  • 画面に出した日付が、1日前になっている
  • ログの時刻と、データベースに入っている時刻が、9時間ちょうど違う
  • 「今日の分」を集計したら、朝9時までの分が前日に入っていた
  • 締切を 2026-09-16 で登録したのに、15日の23時に期限切れになった

この4つは、全部同じ1つの原因から出ています。 別々のバグに見えるだけです。

そして厄介なのは、エラーが1つも出ないことです。プログラムは正常に動いています。ただ、どこかで誰かが親切に変換しているだけです。

私は最初、これを「よく分からないけど9時間足せば合う」で片づけようとしました。その場では合います。 そして、別の場所で今度は9時間引く羽目になり、最後には足すのか引くのか分からない場所が3箇所できました。

「なんとなくずれる」を、なんとなく直してはいけません。 どこでずれたのかを特定できるようになるのが、この回のゴールです。

そのために、まず時刻を変換している場所を全部並べます。 犯人が4人しかいないと分かれば、あとは1人ずつ聞けばいいだけになります。

対象レベル: 初級〜中級 / 区分: 必修

目次

この記事でわかること

  • 「1日ずれる」も「9時間ずれる」も、原因は同じだということ。ずれ幅がタイムゾーンの差そのものなら、犯人は必ず変換処理
  • 時刻は OS・データベース・アプリ・ブラウザの4つの層で、それぞれ独立に変換されていること。4つのうち1つでも認識が違えば必ずずれる
  • MySQL の TIMESTAMP は読み書きのたびに変換され、DATETIME は一切変換されないこと。同じ値を入れても、読み方を変えると違う値が返る
  • 原則は1つだけだということ。保存はUTC、表示はローカル。変換するのは入り口と出口だけ
  • 「日付」は時刻ではないこと。誕生日にタイムゾーンは無い。 DATE を DATETIME のつもりで扱うと1日ずれる
  • サマータイムのある地域には、存在しない時刻と、2回来る時刻があること。日本にも過去にあった。だから自分で計算してはいけない
  • 「今」をコードの奥で直接呼ぶと、そのコードはテストできなくなること

この記事でやること

  1. 4つの層のタイムゾーンを、それぞれ確認するコマンドを打つ(OS・DB・アプリ・ブラウザ)
  2. MySQL に TIMESTAMP と DATETIME を持つ表を作り、同じ値を入れて、読むときのタイムゾーンだけを変えて、わざと9時間ずらす
  3. UNIX時間・DATE 型も入れて、それぞれどう振る舞うかを1つの表で見比べる
  4. Knex(mysql2)の接続設定を「保存はUTC」に直し、DATE が1日ずれないようにする
  5. Node.js でサマータイムの「存在しない時刻」と「2回来る時刻」を実際に表示させる
  6. 変更したタイムゾーン設定を全部戻す

先に知る言葉

この記事で初めて出てくる言葉です。 基本的な言葉は用語集にもまとめてあります。

言葉意味
UTC協定世界時。世界共通の基準になる時刻。日本標準時はこれより9時間進んでいる。「イギリスの時間」ではなく基準そのもの
オフセットUTCとの差。日本なら +09:00。その瞬間の差を表すだけで、いつでも同じとは限らない
タイムゾーンAsia/Tokyo のような地域の名前。「いつからいつまでオフセットがいくつか」というルールの束を指す。+09:00 とは別物
tzdata / IANAタイムゾーンデータベース世界中のタイムゾーンのルールを集めたデータ。国の都合で変わるので、年に何度も更新される
サマータイム(DST)夏の間だけ時計を1時間進める制度。進める瞬間に1時間が消え、戻す瞬間に1時間が2回来る
UNIX時間(エポック秒)1970年1月1日 00:00:00 UTC からの経過秒数。タイムゾーンの概念を持たない整数
ISO 8601日付と時刻を文字列で書くときの国際規格。2026-09-16T12:00:00+09:00 の形
NTPネットワーク越しに時計を合わせる仕組み。時計のズレを直すもので、タイムゾーンとは無関係

「オフセット」と「タイムゾーン」を区別してください。 この記事で一番大事な区別です。 +09:00 はその瞬間の差、Asia/Tokyo はルールです。+09:00 を保存しても、来年ルールが変わったときに直せません。


① 時刻は4つの層で変換されている

まず、犯人を4人に絞ります。日付が画面に出るまでに、時刻はこの4箇所を通ります。

[ ① OS ] → [ ② データベース ] → [ ③ アプリ(Node.js)] → [ ④ ブラウザ ]
   VMの時計      MySQL のセッション    サーバー側の変換      表示する人の端末

そして、この4つは全部、独立に自分のタイムゾーンを持っています。 誰も相談していません。

「9時間ずれた」というのは、この矢印のどれか1本で変換が1回多いか、1回少ないかということです。 それ以外にはなりません。

それぞれのタイムゾーンを確認する

この表を丸ごと1回打ってください。 4つの答えを紙に書き出すのが、切り分けの第一歩です。

層どこで確認するか打つもの
① OSVMの中(Ubuntu)timedatectl
② データベースMySQL のプロンプトSELECT @@global.time_zone, @@session.time_zone;
③ アプリVMの中(Node.js)process.env.TZ と Intl.DateTimeFormat().resolvedOptions().timeZone
④ ブラウザブラウザの開発者ツールのコンソールIntl.DateTimeFormat().resolvedOptions().timeZone

順に打ちます。

① OS

VMの中(Ubuntu)で:

bash
$ timedatectl
               Local time: Wed 2026-09-16 21:04:11 JST
           Universal time: Wed 2026-09-16 12:04:11 UTC
                Time zone: Asia/Tokyo (JST, +0900)
System clock synchronized: yes
              NTP service: active

Ubuntu Server の初期設定の回で Asia/Tokyo にしてあるので、こう出ます。

ここで2行を分けて読んでください。

  • System clock synchronized: yes … 時計そのものが合っているか(NTPの仕事)
  • Time zone … 表示の基準

この2つは全く別の話です。 「9時間ずれる」はまず間違いなく下の行の話で、NTPは関係ありません。上が no のときだけ、時計そのものを疑ってください。

② データベース

VMの中(Ubuntu)で:

bash
$ sudo mysql

MySQL のプロンプトで:

SELECT @@global.time_zone, @@session.time_zone, NOW(), UTC_TIMESTAMP();
+--------------------+---------------------+---------------------+---------------------+
| @@global.time_zone | @@session.time_zone | NOW()               | UTC_TIMESTAMP()     |
+--------------------+---------------------+---------------------+---------------------+
| SYSTEM             | SYSTEM              | 2026-09-16 21:04:33 | 2026-09-16 12:04:33 |
+--------------------+---------------------+---------------------+---------------------+

SYSTEM は「①のOSに合わせる」という意味です。 自分では持っていません。だから OSのタイムゾーンを変えると、MySQL の解釈も一緒に変わります。

ここが最初の罠です。 開発中のVMは Asia/Tokyo、本番のサーバーは UTC ということが普通に起きます。アプリのコードは1文字も変えていないのに、本番だけ9時間ずれます。

③ アプリ(Node.js)

VMの中(Ubuntu)で:

bash
$ node -e "console.log('TZ =', process.env.TZ); console.log('resolved =', Intl.DateTimeFormat().resolvedOptions().timeZone); console.log('offset(min) =', new Date().getTimezoneOffset());"
TZ = undefined
resolved = Asia/Tokyo
offset(min) = -540

読み方が3行とも違います。

  • process.env.TZ が undefined … 環境変数で指定されていない。だからOSに従っている
  • resolved … 実際にいま使われているタイムゾーン。こちらが本当の答え
  • getTimezoneOffset() が -540 … 符号が直感と逆です。UTCから見た差ではなく、「ローカル時刻からUTCを引くのに必要な分数」なので、日本は -540(マイナス9時間)になります

getTimezoneOffset() の符号は、必ず一度は間違えます。 日本は +09:00 なのに -540 が返ります。この関数を自分の計算に使わないでください。 後述の理由で、そもそも手で足し引きしないのが正解です。

環境変数で上書きすることもできます。

bash
$ TZ=UTC node -e "console.log(Intl.DateTimeFormat().resolvedOptions().timeZone, new Date().toString());"
UTC Wed Sep 16 2026 12:06:02 GMT+0000 (Coordinated Universal Time)

同じマシン、同じコードで、時刻の表示が9時間変わりました。 アプリのタイムゾーンはOSとは独立に決められます。

Docker の回で作ったコンテナは、何も指定しなければ UTC です。 ホストが Asia/Tokyo でも、コンテナの中は UTC。同じ理由で、GitHub Actions のランナーも UTC です。「手元では通るのにCIだけ落ちるテスト」の定番の原因がこれです。

④ ブラウザ

ブラウザの開発者ツールのコンソールで:

Intl.DateTimeFormat().resolvedOptions().timeZone
'Asia/Tokyo'

これはサーバーが決められません。 見ている人の端末の設定です。海外から見れば別の値が返ります。

[スクリーンショット: 01_四層のタイムゾーン.png] timedatectl の出力、MySQL の SELECT @@global.time_zone, @@session.time_zone; の結果、node -e の出力の3つが同じ画面に並んで見えるように撮ってください。3つとも Asia/Tokyo 系になっていることが読み取れる状態で。

まとめると

層誰が決めるか変えられるか
① OSサーバーの管理者timedatectl set-timezone
② データベースサーバー設定 or 接続ごとSET time_zone = '...';
③ アプリ環境変数 TZ or OS起動時に指定できる
④ ブラウザ見ている人変えられない

④が変えられない、というのが結論を決めます。 表示する場所だけは、こちらの都合を押し付けられません。 だから「保存側を全部揃えて、表示のときだけ相手に合わせる」以外の設計は成り立ちません。これが後で出てくる原則の理由です。


② わざと9時間ずらす — TIMESTAMP と DATETIME

ここが山場です。同じ値を入れて、読むときのタイムゾーンだけを変えます。

実験用の表を作る

MySQL のプロンプトで:

USE appdb;

CREATE TABLE tz_demo (
  id       INT AUTO_INCREMENT PRIMARY KEY,
  memo     VARCHAR(50) NOT NULL,
  t_stamp  TIMESTAMP   NOT NULL,
  t_dt     DATETIME    NOT NULL,
  t_epoch  BIGINT      NOT NULL,
  t_date   DATE        NOT NULL
) ENGINE=InnoDB;

4種類の持ち方を、1行に横並びで入れます。 こうすると違いが1画面で見えます。

同じ瞬間を、4通りで入れる

いまのセッションのタイムゾーンを確認してから入れます。

SELECT @@session.time_zone;
SET time_zone = '+09:00';

SET time_zone はいまの接続だけに効きます。 他の接続にも、サーバー全体にも影響しません。接続を切れば消えます。 安全に試せます。

INSERT INTO tz_demo (memo, t_stamp, t_dt, t_epoch, t_date)
VALUES ('2026-09-16 21:00 JST として入れた',
        '2026-09-16 21:00:00',
        '2026-09-16 21:00:00',
        UNIX_TIMESTAMP('2026-09-16 21:00:00'),
        '2026-09-16');

4つの列に、見た目は同じ 2026-09-16 21:00 を入れました。 SQLの4つのうちの INSERT と SELECT しか使っていません。読んでみます。

SELECT t_stamp, t_dt, t_epoch, t_date FROM tz_demo;
+---------------------+---------------------+------------+------------+
| t_stamp             | t_dt                | t_epoch    | t_date     |
+---------------------+---------------------+------------+------------+
| 2026-09-16 21:00:00 | 2026-09-16 21:00:00 | 1789560000 | 2026-09-16 |
+---------------------+---------------------+------------+------------+

全部揃っています。 ここまでは何の問題もありません。

タイムゾーンを変えて、同じ行をもう一度読む

行は1文字も書き換えません。読み方だけ変えます。

SET time_zone = '+00:00';
SELECT t_stamp, t_dt, t_epoch, t_date FROM tz_demo;
+---------------------+---------------------+------------+------------+
| t_stamp             | t_dt                | t_epoch    | t_date     |
+---------------------+---------------------+------------+------------+
| 2026-09-16 12:00:00 | 2026-09-16 21:00:00 | 1789560000 | 2026-09-16 |
+---------------------+---------------------+------------+------------+

t_stamp だけが 21:00 から 12:00 に変わりました。 9時間です。

これが「9時間ずれる」の正体です。 何も壊れていません。TIMESTAMP は、そう振る舞うように作られているだけです。

列型何が起きたか
t_stampTIMESTAMP変換された。 書くときにUTCに直して保存し、読むときにセッションのタイムゾーンへ戻している
t_dtDATETIME変換されない。 入れた文字がそのまま返る
t_epochBIGINT変換されない。 ただの整数
t_dateDATE変換されない。 日付だけ

なぜこうなるのか

TIMESTAMP は「瞬間」を持っています。 中身はUTCの経過秒で、表示のたびにセッションのタイムゾーンへ翻訳されます。

DATETIME は「壁の時計に書いてある文字」を持っています。 どこの時刻かという情報を持っていません。だから翻訳のしようがなく、そのまま返ります。

TIMESTAMP: 「あの瞬間」   → 読む人の場所に合わせて表示が変わる
DATETIME : 「21時という字」 → 誰がどこで読んでも 21時

NOW() も同じ影響を受けます。 確かめます。

SELECT NOW(), UTC_TIMESTAMP();
SET time_zone = '+09:00';
SELECT NOW(), UTC_TIMESTAMP();

NOW() はセッションのタイムゾーンで返り、UTC_TIMESTAMP() は常にUTCで返ります。 表のデフォルト値に CURRENT_TIMESTAMP を書いたとき、どちらが入るかは列の型で決まります。

DATETIME の列に NOW() を入れると、「そのとき接続していた人のタイムゾーンの文字」が保存されます。 アプリは Asia/Tokyo、バッチは UTC で繋いでいた——これで、同じ表の中に2種類の時刻が混ざります。 見分ける方法はありません。これが一番痛い事故です。

どちらを使うべきか

「瞬間」を記録するなら、変換されるのが正しい振る舞いです。 つまり TIMESTAMP の考え方が合っています。

ただし MySQL の TIMESTAMP には、範囲の問題があります。

TIMESTAMPDATETIME
変換されるされない
保存できる範囲1970年〜2038年1000年〜9999年
サイズ4バイト5バイト
向くもの作成日時・更新日時どこの時刻かを別に決めてある日時

TIMESTAMP は2038年で天井を打ちます。 32ビットの符号付き整数で秒を数えているためです(2038年問題)。「30年ローンの満期」「子どもの成人予定日」を TIMESTAMP に入れると、いまこの瞬間に壊れます。

この記事の推奨は次の1つです。

DATETIME に、UTCの値だけを入れる。 そして「この列はUTCである」をチーム全員が知っている状態を、設定で強制する。

TIMESTAMP の自動変換に頼らない理由は、接続ごとのタイムゾーン設定に依存してしまうからです。依存先が多いほど、事故の入り口が増えます。 DATETIME + UTC 固定なら、変換が起きる場所は自分で書いた1箇所だけになります。

UNIX時間(BIGINT)で持つ選択肢もあります。

良いところつらいところ
UNIX時間絶対に変換されない。 言語をまたいでも解釈が1つ。大小比較・差分が単なる引き算SQLで読めない(1789646400 を見て日付が分からない)。FROM_UNIXTIME() を挟むと索引が効かなくなることがある

迷ったら DATETIME + UTC です。 UNIX時間は、ログや計測値のように「人が直接SQLで読まない」データに向きます。秒で足りないならミリ秒(BIGINT)にします。


③ 原則は1つだけ — 保存はUTC、表示はローカル

ここまでの話は、次の1行に畳めます。

保存はUTC、表示はローカル。変換するのは入り口と出口だけ。

図にすると、こうです。

ブラウザ ──[ISO 8601で送る]──> アプリ ──[UTCで保存]──> DB
                                   ↑ ここで1回だけ変換
DB ──[UTCのまま]──> アプリ ──[ISO 8601で返す]──> ブラウザ
                                                    ↑ ここで1回だけ変換

内側では、一度も変換しません。 変換が起きるのは外との境界だけです。

この形にしておくと、「どこでずれたか」の候補が2箇所しか無くなります。 さっき4人いた容疑者が2人になります。それが目的です。

なぜ「保存もローカル」ではいけないのか

一見、日本のサービスなら全部JSTで持てば楽に思えます。 そうしない理由は3つです。

  1. ④の層は変えられない。 海外から見られた瞬間に破綻する
  2. サマータイムのある地域では、ローカル時刻に「存在しない時刻」と「2回来る時刻」がある(後述)。主キーにも並び替えにも使えない値が生まれる
  3. サーバーを増やすと揃わない。 クラウドの新しいインスタンスは、だいたい UTC で立ち上がります

UTCには、この3つの問題が全部ありません。 サマータイムが無く、飛ばない、重複しない、世界中で1つです。

本番のサーバーはUTCにするのか

します。 本番環境ではOSもDBもアプリも全部UTCにして、JSTを見るのは人間が読む画面だけにするのが定石です。

ただし、この学習用VMは Asia/Tokyo のままにします。 理由は、初期設定の回で書いたとおり、ログを読むときに毎回9時間の暗算をすると人間が間違えるからです。

学習環境は「読みやすさ」、本番は「揃えやすさ」を取ります。 目的が違うので結論も違います。そして、この違いこそが「手元では合うのに本番だけずれる」の発生源なので、知ったうえで選んでください。


④ 文字列で渡すときは ISO 8601 で

JSONには日付型がありません。必ず文字列か数値になります。 だから書き方を決めておく必要があります。

これを使ってください。

2026-09-16T12:00:00Z          ← UTC。末尾の Z は +00:00 と同じ意味
2026-09-16T21:00:00+09:00     ← 同じ瞬間を、日本のオフセット付きで

これは ISO 8601 という国際規格の書き方で、インターネットで使うときはさらに絞り込んだ RFC 3339 に従います。 実務では両方の名前が同じものを指していると思って構いません。

[スクリーンショット: 02_iso8601比較.png] node -e "console.log(new Date('2026-09-16T21:00:00+09:00').toISOString())" の実行結果を撮ってください。2026-09-16T12:00:00.000Z が返っていることが読み取れる状態で。

これを渡さない

2026/09/16 12:00      ← ⚠️ どこの時刻か書いていない。区切りも規格外
09/16/2026            ← ⚠️ 月と日のどちらが先か、国によって違う
2026-09-16 12:00:00   ← ⚠️ 惜しい。T が無く、オフセットも無い
1789560000            ← 意味は1つに決まるが、人が読めない

上から3つは、受け取った側が「たぶんこうだろう」と推測することになります。 そして推測は環境ごとに違います。 それが1日のずれになります。

実際に確かめる

VMの中(Ubuntu)で:

bash
$ node -e "
  const a = new Date('2026-09-16T21:00:00+09:00');
  const b = new Date('2026-09-16T12:00:00Z');
  console.log('a =', a.toISOString());
  console.log('b =', b.toISOString());
  console.log('同じ瞬間か:', a.getTime() === b.getTime());
  "
a = 2026-09-16T12:00:00.000Z
b = 2026-09-16T12:00:00.000Z
同じ瞬間か: true

書き方が違っても、オフセットが付いていれば同じ瞬間に落ちます。 これがISO 8601を使う理由です。

おまけ: ISO 8601 は文字列のまま並べ替えられる

bash
$ node -e "console.log(['2026-09-16T12:00:00Z','2026-01-05T00:00:00Z','2026-09-16T03:00:00Z'].sort())"
[
  '2026-01-05T00:00:00Z',
  '2026-09-16T03:00:00Z',
  '2026-09-16T12:00:00Z'
]

日付として解釈しなくても、辞書順で正しく並びます。 桁が固定されていて、大きい単位が左にあるからです。2026/9/16 ではこうなりません(10 が 9 より前に来ます)。

JSON に載せるとき

JSON.stringify({ due: new Date('2026-09-16T21:00:00+09:00') })
{"due":"2026-09-16T12:00:00.000Z"}

Date を JSON.stringify に渡すと、自動的にISO 8601のUTCになります。 都合がいいので、そのまま使ってください。 REST APIの設計でも、日時はこの形で返すのが標準的です。

受け取った側では、JSON.parse は文字列のままにします。 自動的に Date には戻りません。戻したい場所で明示的に new Date(...) してください。 「勝手に変換されていた」が一番の敵です。


⑤ 「日付」は時刻ではない

誕生日にタイムゾーンはありません。

「1998年5月3日生まれ」は、日本で読んでもブラジルで読んでも5月3日です。「1998年5月3日の00:00 JST」ではありません。時刻という概念が最初から無いのです。

同じものが他にもあります。

  • 誕生日・記念日
  • 請求書の締め日、決算日
  • 「9月16日の営業日」
  • 祝日

これらを DATETIME や TIMESTAMP で持つと、必ず1日ずれます。

実際にずらしてみる

VMの中(Ubuntu)で:

bash
$ TZ=Asia/Tokyo node -e "console.log(new Date('2026-09-16').toISOString(), '|', new Date('2026-09-16').toString())"
2026-09-16T00:00:00.000Z | Wed Sep 16 2026 09:00:00 GMT+0900 (Japan Standard Time)

日付だけの文字列は、UTCの0時として解釈されます。 日本では9月16日の朝9時になります。ここまでは実害がありません。問題は、アメリカから見たときです。

bash
$ TZ=America/New_York node -e "console.log(new Date('2026-09-16').toString())"
Tue Sep 15 2026 20:00:00 GMT-0400 (Eastern Daylight Time)

9月15日になりました。 誕生日が1日前になる、あの現象です。

さらに厄介なのが、時刻付きの文字列だと解釈が逆になることです。

bash
$ TZ=America/New_York node -e "console.log(new Date('2026-09-16T00:00:00').toString())"
Wed Sep 16 2026 00:00:00 GMT-0400 (Eastern Daylight Time)

2026-09-16 は UTC、2026-09-16T00:00:00 は ローカルとして解釈されます。文字が3つ増えただけで、意味が変わります。 これは仕様どおりの動作です。 覚える必要はありません。覚えるべきは「オフセットを書かない文字列を new Date() に渡さない」の1つだけです。

正しい持ち方

日付は DATE 型で持ちます。

ALTER TABLE tz_demo ADD COLUMN birthday DATE NULL;

そして、アプリ側では文字列 '1998-05-03' のまま扱います。 Date にしません。Date にした瞬間に時刻が生えて、タイムゾーンの影響を受け始めるからです。

Knex(mysql2)で DATE が1日ずれる

ところが、そのままでは文字列で受け取れません。 ドライバが親切に Date に変換してしまいます。

確かめます。VMの中(Ubuntu)で:

bash
$ cd ~/server
$ node -e "
  const knex = require('knex')({
    client: 'mysql2',
    connection: { host: '127.0.0.1', user: 'appuser', password: process.env.DB_PASSWORD, database: 'appdb' },
  });
  knex('tz_demo').select('t_date').first().then((r) => {
    console.log('返ってきたもの:', r.t_date);
    console.log('型:', Object.prototype.toString.call(r.t_date));
    console.log('JSONにすると:', JSON.stringify(r));
    return knex.destroy();
  });
  "
返ってきたもの: 2026-09-15T15:00:00.000Z
型: [object Date]
JSONにすると: {"t_date":"2026-09-15T15:00:00.000Z"}

DB_PASSWORD は .env から読ませてください。 コマンドラインに直接書くとシェルの履歴に残ります。

もう前日になっています。 ドライバは timezone を指定しないと、DATE の 2026-09-16 を「OS のタイムゾーンの 0時」として Date にします。この VM は Asia/Tokyo なので、00:00 JST が 前日15:00 UTC になり、JSON に出た瞬間に前日の日付に見えます。 同じコードを UTC のサーバーで動かすと 00:00Z になってずれが出ないので、動かす機械によって結果が変わるのが厄介なところです。

直し方は、DATE を文字列のまま受け取ることです。 ORMとマイグレーションの回で作った ~/server/knexfile.js の接続設定に足します。

module.exports = {
  client: 'mysql2',
  connection: {
    host: '127.0.0.1',
    user: process.env.DB_USER,
    password: process.env.DB_PASSWORD,
    database: 'appdb',
    // ① DATETIME / TIMESTAMP を UTC として解釈する
    timezone: 'Z',
    // ② DATE は Date に変換せず、文字列のまま返す
    dateStrings: ['DATE'],
  },
  pool: {
    // ③ 接続するたびに、この接続のタイムゾーンを UTC に固定する
    afterCreate(conn, done) {
      conn.query("SET time_zone = '+00:00';", (err) => done(err, conn));
    },
  },
};

3つとも役割が違います。

何をしているかこれが無いと
① timezone: 'Z'ドライバに「DBの値はUTCだ」と教えるドライバがOSのタイムゾーンで解釈し、サーバーを移すとずれる
② dateStrings: ['DATE']DATE を文字列のまま返すDate に変換され、誕生日が1日ずれる
③ afterCreate接続のたびに SET time_zone を打つNOW() と TIMESTAMP がOS任せになる

①と③はセットです。 片方だけだと、「DBはJSTで返しているのに、ドライバはUTCだと思って読む」という最悪の状態になります。9時間ずれた値が、エラーなしで保存されます。

dateStrings: true と書くと DATE も DATETIME も TIMESTAMP も全部文字列になります。 それも1つの選択です。「変換を全部止めて、自分で書いた場所でだけ変換する」という考え方で、③の原則にはむしろ忠実です。ただし DATETIME の差分計算を自分で書くことになるので、この記事では DATE だけに絞りました。

設定を書き換えたら、必ずもう一度読んで確かめてください。

bash
$ cd ~/server
$ node -e "
  const knex = require('knex')(require('./knexfile'));
  knex('tz_demo').select('t_date','t_dt').first().then((r) => { console.log(r); return knex.destroy(); });
  "
{ t_date: '2026-09-16', t_dt: 2026-09-16T21:00:00.000Z }

t_date が文字列になりました。 これで、どのサーバーで動かしても 2026-09-16 のままです。


⑥ サマータイム — 存在しない時刻と、2回来る時刻

ここまでの話は「9時間ずらす」でした。 サマータイムのある地域では、もっと悪いことが起きます。

1時間が消える

アメリカ東部では、2026年3月8日にサマータイムが始まります。午前2時になった瞬間、時計が午前3時に飛びます。

つまり、2026-03-08 02:30 という時刻は、その地域に存在しません。

VMの中(Ubuntu)で:

bash
$ node -e "
  const f = new Intl.DateTimeFormat('en-US', { timeZone: 'America/New_York', dateStyle: 'short', timeStyle: 'long' });
  console.log(f.format(new Date('2026-03-08T06:30:00Z')));
  console.log(f.format(new Date('2026-03-08T07:30:00Z')));
  "
3/8/26, 1:30:00 AM EST
3/8/26, 3:30:00 AM EDT

1時30分の次が3時30分です。 2時台が丸ごとありません。

この日にアラームを 02:30 に仕掛けたら、何が起きるでしょうか。 答えは「ライブラリと設定による」です。飛ばされるか、1時30分に鳴るか、3時30分に鳴るか。 どれも正解になり得ます。

1時間が2回来る

11月1日には逆のことが起きます。午前2時が午前1時に戻ります。

bash
$ node -e "
  const f = new Intl.DateTimeFormat('en-US', { timeZone: 'America/New_York', dateStyle: 'short', timeStyle: 'long' });
  console.log(f.format(new Date('2026-11-01T05:30:00Z')));
  console.log(f.format(new Date('2026-11-01T06:30:00Z')));
  "
11/1/26, 1:30:00 AM EDT
11/1/26, 1:30:00 AM EST

同じ「1:30 AM」が2回出ました。 末尾の EDT と EST だけが違います。

2026-11-01 01:30 というローカル時刻を DATETIME に保存したら、それがどちらの1時30分なのかは永久に分かりません。 情報が消えています。 これが「保存はUTC」の、いちばん強い理由です。UTCなら 05:30Z と 06:30Z で区別が付きます。

日本にもあった

「日本にはサマータイムが無いから関係ない」は間違いです。

日本には 1948年から1951年まで、サマータイムがありました。 その期間、日本のオフセットは +10:00 でした。

bash
$ node -e "
  const f = new Intl.DateTimeFormat('ja-JP', { timeZone: 'Asia/Tokyo', dateStyle: 'short', timeStyle: 'long' });
  console.log(f.format(new Date('1950-01-01T00:00:00Z')));
  console.log(f.format(new Date('1950-06-01T00:00:00Z')));
  "
1950/01/01 9:00:00 GMT+9
1950/06/01 10:00:00 GMT+10

6月だけ +10:00 になっています。 時間帯の表記(GMT+10 など)は Node.js に組み込まれた ICU の版で変わります。上は Node.js v22.14.0 での結果です。

古い生年月日や、過去の記録を扱うシステムでは、これが実際に効きます。 そして未来にも起きます。国が制度を変えれば、Asia/Tokyo のルールは変わります。実際、世界のどこかの国が毎年ルールを変えていて、tzdata は年に何度も更新されています。

だから自分で計算しない

以上が、「9時間足す」を自分で書いてはいけない理由です。

// ⚠️ 絶対に書かない
const jst = new Date(utc.getTime() + 9 * 60 * 60 * 1000);

これが間違っている理由は3つあります。

  1. 9時間が常に9時間とは限らない(1950年の日本は10時間)
  2. 他の地域では成り立たない(サマータイムで年に2回オフセットが変わる)
  3. 国がルールを変えたら、コードを直しに行くことになる

正しいのは、ルールを知っている道具に聞くことです。

new Intl.DateTimeFormat('ja-JP', {
  timeZone: 'Asia/Tokyo',
  dateStyle: 'medium',
  timeStyle: 'short',
}).format(someDate);

Intl は tzdata を持っています。 OSやNode.jsを更新すれば、ルールの変更が勝手に反映されます。 自分で書いた +9 は、誰も更新してくれません。


⑦ うるう秒 — NTPが吸収する

地球の自転は一定ではありません。 そのズレを埋めるために、UTCにはうるう秒が挿入されることがあります。1分が61秒になる、というものです。

結論から言うと、アプリケーションを書く側では気にしなくて構いません。 UNIX時間はうるう秒を数えない仕組みになっており、実際の運用ではNTPサーバーがうるう秒の前後で時計をわずかずつ引き伸ばして、境目を消してしまいます(この方式を leap smear と呼びます)。クラウド各社の時刻サーバーはこれをやっています。だから、アプリから見ると「1分が61秒だった」という瞬間は現れません。

そして、うるう秒は2035年までに廃止されることが国際的に決まっています。

ここで覚えるのは1つだけです。 timedatectl で System clock synchronized: yes になっていれば、時計そのものの心配はしなくていい。 「時計が合っているか」はNTPの仕事、「何時と表示するか」はタイムゾーンの仕事。 この2つを混ぜないでください。混ぜると、タイムゾーンの問題をNTPで直そうとして時間を溶かします。(私はやりました)


⑧ 「今」を直接呼ばない

最後は設計の話です。ここを外すと、時刻を扱うコードは一生テストできません。

こういうコードを書きがちです。

// ⚠️ テストできない
function isOverdue(task) {
  return new Date(task.dueAt) < new Date();
}

このコードをテストするには、どうすればいいでしょうか。

  • 締切を「1秒後」にして、1秒待つ? → テストが遅くなり、たまに落ちます
  • 締切を「2020年」にする? → 「期限切れでない」側のテストが書けません
  • 実行するマシンの時計を変える? → 論外です

問題は new Date() が「外の世界」を勝手に読んでいることです。 引数に無いものに結果が左右されるので、入力を決めても出力が決まりません。

直し方は、「今」を引数で渡すことです。

// 「今」を外から受け取る
function isOverdue(task, now) {
  return new Date(task.dueAt) < now;
}

これだけで、テストが普通の関数のテストになります。

import { describe, it, expect } from 'vitest';

describe('isOverdue', () => {
  const now = new Date('2026-09-16T12:00:00Z');

  it('締切を過ぎていれば true', () => {
    expect(isOverdue({ dueAt: '2026-09-16T11:59:59Z' }, now)).toBe(true);
  });

  it('締切ちょうどは false', () => {
    expect(isOverdue({ dueAt: '2026-09-16T12:00:00Z' }, now)).toBe(false);
  });

  it('9時間後の締切は false(JSTと取り違えていないか)', () => {
    expect(isOverdue({ dueAt: '2026-09-16T21:00:00Z' }, now)).toBe(false);
  });
});

3つ目のテストに注目してください。 これはタイムゾーンの取り違えを検出するためのテストです。もし関数の中で勝手に9時間足していたら、このテストが落ちます。

テストの回で書いたとおり、テストしにくいコードは「設計が良くない」というサインです。 時刻はその代表例です。 new Date() は外の世界を読む入出力であって、計算ではありません。入出力は端に寄せる——これはサーバーの回からずっと同じ話です。

「今」を呼んでいい場所は、いちばん外側の1箇所だけです。

app.get('/api/tasks', async (req, res) => {
  const now = new Date();              // ← ここでだけ呼ぶ
  const tasks = await listTasks(db);
  res.json(tasks.map((t) => ({ ...t, overdue: isOverdue(t, now) })));
});

副次的な効果があります。 1リクエストの中で new Date() を10回呼ぶと、10個の微妙に違う「今」ができます。上のように1回だけ呼べば、そのリクエスト全体で「今」が1つに揃います。 集計の境目で1件だけ数が合わない、といった事故が消えます。

CIがUTCで動くことを思い出してください。 テストの中で new Date() を呼んでいると、手元(JST)では通ってCIでだけ落ちるテストができます。「今」を引数で渡す設計は、これも同時に解決します。

どうしてもモジュールの奥で「今」が要る場合は、テストフレームワークの機能で時計を固定できます。 Vitest なら vi.useFakeTimers() と vi.setSystemTime() です。ただし、これは最後の手段です。 引数で渡せるならそちらが先です。


⑨ ライブラリ — 何を使うか

まず Date の落とし穴を知っておく

JavaScript 標準の Date は、1995年に10日で設計されたと言われているほど古い部分を引きずっています。

bash
$ node -e "
  console.log('月は0から:', new Date(2026, 9, 16).toDateString());
  console.log('存在しない日:', new Date(2026, 1, 31).toDateString());
  const d = new Date('2026-09-16T12:00:00Z');
  d.setUTCDate(d.getUTCDate() + 1);
  console.log('元の値が書き換わる:', d.toISOString());
  "
月は0から: Fri Oct 16 2026
存在しない日: Tue Mar 03 2026
元の値が書き換わる: 2026-09-17T12:00:00.000Z

3つとも罠です。

挙動何が問題か
月が0始まり9 を渡すと10月。日と年は1始まりなのに、月だけ0始まり
はみ出した日が繰り上がる2月31日がエラーにならず、黙って3月3日になる
setXxx が元の値を書き換える同じ Date を2箇所で使い回すと、片方の操作がもう片方に漏れる

3つ目が特に危険です。 Date を関数に渡して中で setDate されると、呼び出し元の値まで変わります。

Temporal — 標準側の答え

この問題を根本から作り直す Temporal という新しい仕様が、JavaScriptの標準に入りつつあります。

  • 書き換えられない(操作すると新しい値が返る)
  • Temporal.PlainDate(日付だけ)と Temporal.ZonedDateTime(タイムゾーン付きの瞬間)が、型として別物
  • 月が1始まり

「日付」と「時刻付きの瞬間」が別の型になっているというのが本質的です。⑤で説明した混同が、型のレベルで起きなくなります。

ただし、2026年現在はまだ実装が進んでいる途中です。 ブラウザやNode.jsのバージョンによって使えたり使えなかったりします。「そのうちこれになる」と知っておくだけで十分で、いま入れるならポリフィルが必要です。

実務でいま使うもの

ライブラリ特徴向くとき
date-fns関数の集まり。 使った関数だけがバンドルに入る。Date をそのまま扱うフォーマットと足し引きが主なとき
Luxon独自の型を持つ。 タイムゾーンの扱いが強く、Temporal に考え方が近いタイムゾーンの変換が主役のとき
Day.js軽い。書き味が Moment に近いMoment からの移行

Moment.js は、新規のプロジェクトでは使いません。 作者たち自身が公式サイトで「メンテナンスモードであり、新規プロジェクトには推奨しない」と明言しています。動かないわけではありませんが、書き換えられる型であることとサイズが大きいことが、いまの基準に合わなくなっています。

そして、いちばん大事なことを書きます。

「表示だけなら、ライブラリは要りません。」

bash
$ node -e "
  const d = new Date('2026-09-16T12:00:00Z');
  console.log(new Intl.DateTimeFormat('ja-JP', { timeZone: 'Asia/Tokyo', dateStyle: 'long', timeStyle: 'short' }).format(d));
  console.log(new Intl.DateTimeFormat('en-US', { timeZone: 'America/New_York', dateStyle: 'long', timeStyle: 'short' }).format(d));
  "
2026年9月16日 21:00
September 16, 2026 at 8:00 AM

Intl.DateTimeFormat は標準で入っていて、tzdata を持っていて、言語ごとの書き方も知っています。 まずこれで足りないか確かめてから、ライブラリを足してください。 依存を1つ減らせます。


つまずいたところ

「9時間足す関数」を作ってしまった。 最初、表示がずれるので addJst() という関数を書いて、ずれている場所に貼って回りました。その場では直ります。 そのあと、すでに変換済みの値にもう一度貼ってしまい、18時間ずれました。 そして「どこが変換済みでどこが未変換か」が分からなくなりました。変換する場所を決めるのが先で、関数を書くのは後でした。

NTPを疑って半日使った。 ログの時刻が合わないので「時計が狂っている」と思い、NTPの設定を調べ続けました。timedatectl は最初から synchronized: yes でした。 時計は合っていて、表示の基準だけが違っていたのです。この2つを分けて考えられるようになるまで、切り分けが一切できませんでした。

Docker に入れたら急にずれた。 VMでは合っていたのに、コンテナに入れた途端に9時間ずれました。コンテナの中はUTCでした。 コードは1文字も変えていません。アプリのタイムゾーンがOS任せ(process.env.TZ が未設定)だったので、動かす場所を変えたら動作が変わったわけです。これが「アプリのタイムゾーンを明示する」ことの意味だと、このとき分かりました。

DATETIME の列に、2種類の時刻が混ざった。 NOW() で入れていた列を後から調べたら、JSTで入った行とUTCで入った行が混ざっていました。 アプリと、手で流したSQLとで、接続のタイムゾーンが違ったためです。混ざったあとで見分ける方法はありません。 作成順とだいたいの推測で直すしかありませんでした。接続のタイムゾーンを固定する(afterCreate)のは、これを防ぐためです。

getTimezoneOffset() の符号で30分溶かした。 日本は +09:00 なのに -540 が返ります。足すのか引くのか分からなくなって、両方試しました。 そもそもこの関数を使う設計が間違っていました。


後片づけ

変更したものを全部戻します。

① MySQL のセッションのタイムゾーン

そのまま接続を切れば消えます。 念のため確認しておきます。

bash
$ sudo mysql
SELECT @@global.time_zone, @@session.time_zone;

SYSTEM に戻っていれば元通りです。 SET time_zone は接続ごとの設定なので、サーバー全体には何も残っていません。

② 実験用の表を消す

USE appdb;
DROP TABLE IF EXISTS tz_demo;
SHOW TABLES;

tasks・users など元からあった表が残っていれば正常です。 tz_demo が消えていれば元通りです。

EXIT;

③ OSのタイムゾーン

この記事では OS の設定を変えていません。 もし試して変えた場合は、次で戻します。

VMの中(Ubuntu)で:

bash
$ sudo timedatectl set-timezone Asia/Tokyo
$ timedatectl

Time zone: Asia/Tokyo (JST, +0900) に戻っていれば元通りです。

④ knexfile.js の変更は残す

⑤で足した timezone / dateStrings / afterCreate は、戻しません。 これは実験ではなく、直したほうがいい設定だからです。

ただし、既存のデータが「JSTの文字」で入っている場合、この設定を入れると表示が9時間動きます。 実験用の表しか無いなら影響はありませんが、中身のある表がある場合は、先に何が入っているか確かめてください。

SELECT id, created_at FROM tasks ORDER BY id LIMIT 5;

created_at が自分の記憶より9時間前に見えるなら、それはUTCで正しく表示されているということです。画面に出すときにJSTへ直します。


まとめ

  • 「1日ずれる」も「9時間ずれる」も、原因は1つ。 どこかで変換が1回多いか、1回少ないだけ
  • ずれ幅がタイムゾーンの差ぴったりなら、時計の故障ではない。 必ず変換処理が犯人
  • 時刻は OS・データベース・アプリ・ブラウザの4層を通り、4つとも独立にタイムゾーンを持っている
  • 確認は4つ。 timedatectl / SELECT @@global.time_zone, @@session.time_zone / Intl.DateTimeFormat().resolvedOptions().timeZone / ブラウザのコンソール
  • ④のブラウザだけは、こちらから変えられない。 だから表示を相手に合わせる以外の設計は成り立たない
  • MySQL の TIMESTAMP は読み書きのたびに変換される。 DATETIME は一切変換されない
  • 同じ行を、セッションのタイムゾーンだけ変えて読むと、TIMESTAMP だけが9時間動く。 これが「9時間ずれる」の実物
  • TIMESTAMP は 1970年〜2038年しか入らない。 未来の日付には使えない
  • 推奨は DATETIME にUTCだけを入れること。 変換が起きる場所を自分で書いた1箇所に減らせる
  • UNIX時間は絶対に変換されないが、SQLで人が読めない。 ログや計測値向き
  • 原則は1つだけ。保存はUTC、表示はローカル。変換は入り口と出口だけ
  • 本番のサーバーはUTCにする。学習用VMは読みやすさを取って Asia/Tokyo。 この違いが「本番だけずれる」の発生源なので、知ったうえで選ぶ
  • 文字列で渡すときは ISO 8601 / RFC 3339。 2026-09-16T12:00:00Z の形
  • 2026/09/16 12:00 を渡さない。 受け取った側が推測することになり、推測は環境ごとに違う
  • ISO 8601 は、日付として解釈しなくても辞書順で正しく並ぶ
  • 「日付」は時刻ではない。誕生日にタイムゾーンは無い。 DATE 型を使い、文字列のまま扱う
  • new Date('2026-09-16') は UTC、new Date('2026-09-16T00:00:00') は ローカル。 オフセットの無い文字列を new Date() に渡さない
  • Knex(mysql2)には timezone: 'Z' と dateStrings: ['DATE'] と afterCreate の3つを入れる。 ①と③はセット
  • サマータイムのある地域には、存在しない時刻と、2回来る時刻がある
  • 2回来る時刻をローカルで保存すると、どちらか永久に分からない。 情報が消える
  • 日本にも 1948〜1951年にサマータイムがあり、そのとき +10:00 だった。 「日本には無いから関係ない」は誤り
  • + 9 * 60 * 60 * 1000 を自分で書かない。 ルールは変わる。変わったとき、自分のコードは誰も直してくれない
  • Intl.DateTimeFormat は tzdata を持っている。 OSを更新すればルールも更新される
  • うるう秒は深入りしなくてよい。 NTPが吸収し、2035年までに廃止される
  • 「時計が合っているか」はNTP、「何時と表示するか」はタイムゾーン。 混ぜると直らない問題を直そうとする
  • 「今」をコードの奥で直接呼ばない。 呼んだ瞬間にテストできなくなる
  • 「今」は引数で渡し、いちばん外側の1箇所でだけ new Date() を呼ぶ。 1リクエスト内で「今」が1つに揃うという副次効果もある
  • CIはUTCで動く。 「今」を引数にしておけば、手元だけ通るテストも同時に消える
  • Date の落とし穴は3つ。 月が0始まり/2月31日が黙って繰り上がる/setXxx が元の値を書き換える
  • Temporal は「日付」と「瞬間」を別の型にする。 まだ実装が進んでいる途中
  • Moment は新規に使わない(作者自身がメンテナンスモードと明言)。date-fns か Luxon
  • 表示だけならライブラリは要らない。 まず Intl.DateTimeFormat で足りるか試す

参考リンク


次に読む

この記事は 【第5段階】バックエンドとデータベース の 20 / 29 本目です。

記事
← 前の記事文字化けは壊れたのではない — 文字コードとUTF-8
→ 次の記事OAuthはログインの仕組みではない — 認可とOIDC

上から順に読めば積み上がるように並べています。 飛ばしても構いませんが、詰まったら前の回に戻ってください。

全体の順路は はじめに にあります。

roadmap.sh のどこをやっているか

日付と時刻の扱いは roadmap.sh に独立項目が無い。必ず一度は事故るので独立させた。

よかったらシェアしてね!
  • URLをコピーしました!
  • URLをコピーしました!

コメント

コメントする

目次