JavaScriptにおけるプログラミングにおいて、値の比較は論理構成の根幹を成す要素です。

条件分岐やデータのフィルタリング、ユーザー入力のバリデーションなど、あらゆる場面で比較演算子が使用されます。

しかし、JavaScriptは動的型付け言語という特性上、比較の挙動が他の言語とは異なる独特な仕様を持っています。

特に型変換を伴う比較は、一見すると直感的ではない結果を返すことがあり、これが原因で予期せぬバグを引き起こすことも少なくありません。

2026年現在のモダンな開発環境においても、これらの仕様を正しく理解し、安全なコードを記述する技術はエンジニアにとって必須のスキルです。

本記事では、基本的な比較演算子の使い方から、等価演算子の詳細な挙動、そして安全な比較を実現するためのベストプラクティスまでを詳しく解説します。

目次 [ close ]
  1. 比較演算子の基礎知識
    1. 関係演算子の種類と動作
    2. 文字列の比較における注意点
  2. 等価演算子の詳細： == と === の違い
    1. 厳密等価演算子 (===)
    2. 等価演算子 (==) と暗黙の型変換
  3. 特殊な値の比較における挙動
    1. NaN (Not a Number) の比較
    2. null と undefined の扱い
  4. オブジェクトと参照の比較
  5. Object.is() による高精度な比較
  6. 安全な比較コードを書くためのベストプラクティス
    1. 1. 常に厳密等価演算子 (===) を使用する
    2. 2. 比較前に明示的な型変換を行う
    3. 3. Falsyな値の評価に注意する
    4. 4. Null合体演算子 (??) の活用
  7. まとめ

比較演算子の基礎知識

JavaScriptの比較演算子は、2つの値を比較してその結果を論理値 true または false で返します。

大きく分けて「関係演算子」と「等価演算子」の2種類が存在します。

まずは、数値を基本とした関係演算子の動作を確認しましょう。

関係演算子の種類と動作

関係演算子は、値の大小を比較するために使用されます。

演算子名称内容
>より大きい左辺が右辺より大きければ true
<より小さい左辺が右辺より小さければ true
>=以上左辺が右辺以上であれば true
<=以下左辺が右辺以下であれば true

これらの演算子は数値の比較において非常にシンプルに動作します。

JavaScript
// 数値の比較例
const age = 25;

console.log(age > 20);  // 20より大きいか
console.log(age >= 25); // 25以上か
console.log(age < 30);  // 30より小さいか
console.log(age <= 24); // 24以下か
実行結果
true
true
true
false

文字列の比較における注意点

関係演算子は文字列に対しても使用できますが、その場合は辞書順 (Unicodeコードポイント順)で比較されます。

数値の大小比較とは異なる結果になることがあるため注意が必要です。

JavaScript
// 文字列の比較例
console.log("apple" < "banana");
console.log("2" > "10"); // 文字列としての比較
実行結果
true
true

文字列の “2” は文字列の “10” よりも辞書順で後ろにあるため、"2" > "10" は true となります。

数値を比較したい場合は、必ず型を数値に変換してから比較を行うのが安全です。

等価演算子の詳細： == と === の違い

JavaScriptにおいて最も議論の的となり、かつ重要度が高いのが「等価演算子」です。

JavaScriptには2種類の等価演算子が存在します。

  1. 厳密等価演算子 (===)
  2. 等価演算子 (==) ※抽象等価演算子

これら2つの違いを正確に把握することが、バグのないコードを書くための第一歩です。

厳密等価演算子 (===)

厳密等価演算子 === は、比較する2つの値が「型」と「値」の両方において等しい場合にのみ true を返します。

暗黙の型変換が行われないため、予測可能性が高く安全です。

JavaScript
// 厳密等価演算子の例
console.log(10 === 10);      // 同じ数値型で同じ値
console.log(10 === "10");    // 数値型と文字列型
console.log(true === 1);     // 論理型と数値型
console.log(null === undefined); // nullとundefined
実行結果
true
false
false
false

モダンなJavaScript開発において、特別な理由がない限りはこの === を使用することが標準的なルールとなっています。

等価演算子 (==) と暗黙の型変換

等価演算子 == は、比較する値の型が異なる場合、JavaScriptエンジンが自動的に型を変換してから比較を行います。

これを「暗黙の型変換 (Implicit Coercion)」と呼びます。

この挙動は一見便利に思えますが、複雑なルールに基づいて変換が行われるため、意図しない結果を招くことがあります。

JavaScript
// 等価演算子 (==) の例
console.log(10 == "10");     // 文字列が数値に変換される
console.log(true == 1);      // trueが1に変換される
console.log("" == 0);        // 空文字が0に変換される
console.log(null == undefined); // この組み合わせはtrueになる
実行結果
true
true
true
true

特に "" == 0 が true になる挙動や、false == "0" が true になる挙動などは、コードの可読性を下げ、論理的なミスを誘発する原因となります。

基本的には == の使用を避け、型を意識した比較を行うべきです。

特殊な値の比較における挙動

JavaScriptには、比較において特殊な挙動を示す値がいくつか存在します。

これらはデバッグ時に非常に厄介な存在となるため、個別の理解が必要です。

NaN (Not a Number) の比較

NaN は「数値ではない」ことを表す特殊な値ですが、自分自身を含め、いかなる値とも等しくないと判定されます。

JavaScript
const result = NaN;

console.log(result === NaN);
console.log(result == NaN);
実行結果
false
false

値が NaN かどうかを判定したい場合は、比較演算子ではなく Number.isNaN() メソッドを使用する必要があります。

JavaScript
const value = NaN;

if (Number.isNaN(value)) {
    console.log("この値はNaNです");
}

null と undefined の扱い

null と undefined は、等価演算子 == では互いに等しいとみなされますが、厳密等価演算子 === では異なります。

JavaScript
console.log(null == undefined);
console.log(null === undefined);
実行結果
true
false

値が存在しないことをチェックする際、歴史的には if (value == null) という記述で null と undefined の両方を一度にチェックするテクニックが使われてきました。

しかし、現代では可読性の観点から、それぞれの値を厳密にチェックするか、オプショナルチェイニング演算子などを活用する手法が推奨されます。

オブジェクトと参照の比較

プリミティブ型 (数値、文字列、論理値など) の比較は「値そのもの」を比較しますが、オブジェクトや配列の比較は「参照 (メモリ上の位置)」を比較します。

たとえ中身が全く同じであっても、異なるインスタンスであれば比較結果は false になります。

JavaScript
const objA = { id: 1 };
const objB = { id: 1 };
const objC = objA;

console.log(objA === objB); // 内容は同じだが参照が異なる
console.log(objA === objC); // 参照が同じ
実行結果
false
true

配列もオブジェクトの一種であるため、同様の挙動を示します。

JavaScript
console.log([] === []); // 異なる空配列の参照比較
実行結果
false

オブジェクトの中身 (プロパティ) を比較したい場合は、JSON.stringify() を使用して文字列化してから比較するか、再帰的にプロパティをチェックする「ディープイコール (Deep Equal)」の実装、またはライブラリの利用が必要です。

Object.is() による高精度な比較

ES2015で導入された Object.is() は、厳密等価演算子 === よりもさらに厳密な比較を提供します。

主な違いは、先述した NaN と、正負のゼロの扱いです。

比較===Object.is()
NaN と NaNfalsetrue
+0 と -0truefalse
JavaScript
console.log(Object.is(NaN, NaN));
console.log(Object.is(+0, -0));
実行結果
true
false

特殊な数学計算や、NaN を含むデータの同一性を厳格に判定したい場合には Object.is() が適しています。

安全な比較コードを書くためのベストプラクティス

これまでの挙動を踏まえ、実務でバグを防ぎ、メンテナンス性の高いコードを書くためのガイドラインをまとめます。

1. 常に厳密等価演算子 (===) を使用する

原則として == を使わず、=== を選択してください。

型が不明な値が混入した場合に、== だと予期せぬ型変換によって論理が通過してしまいますが、=== であれば安全に落とすことができます。

ESLintなどの静的解析ツールを導入し、eqeqeq ルールを有効にすることで、チーム全体でこの習慣を強制することが可能です。

2. 比較前に明示的な型変換を行う

ユーザーからの入力値 (HTML Formの value など) は常に文字列として渡されます。

これを数値と比較する場合は、あらかじめ数値型に変換しておくのが適切です。

JavaScript
const inputVal = "100"; // ユーザー入力

// Bad: 暗黙の型変換に頼る
if (inputVal == 100) { ... }

// Good: 明示的に変換して厳密に比較する
if (Number(inputVal) === 100) { ... }

明示的な変換を行うことで、コードを読む第三者にとっても「何と何を比較しているのか」が明確になります。

3. Falsyな値の評価に注意する

JavaScriptには、論理値評価で false とみなされる「Falsyな値」が存在します。

  • false
  • 0
  • "" (空文字)
  • null
  • undefined
  • NaN

これらを暗黙的に比較するとバグの温床になります。

例えば、設定値の 0 を有効な値として扱いたい場合に、単純な真偽値判定を行うと失敗します。

JavaScript
const settings = {
    retryCount: 0
};

// Bad: 0 は Falsy なので false と判定される
if (!settings.retryCount) {
    console.log("設定がありません");
}

// Good: undefined かどうかを厳密にチェックする
if (settings.retryCount === undefined) {
    console.log("設定がありません");
}

4. Null合体演算子 (??) の活用

比較演算そのものではありませんが、null や undefined を安全に比較・処理するために ?? (Nullish Coalescing) を活用しましょう。

これは左辺が null または undefined の場合のみ右辺を返します。

JavaScript
const userScore = 0;
const finalScore = userScore ?? 10; // userScoreが0なので、0が採用される

console.log(finalScore);
実行結果
0

従来の || 演算子では 0 も偽と判定されて 10 が代入されてしまいましたが、?? を使うことで「値が未定義かどうか」をより正確に扱えます。

まとめ

JavaScriptの比較演算子は、一見シンプルに見えて非常に奥が深い仕様を持っています。

「暗黙の型変換を避ける」という原則を守るだけで、多くのランタイムエラーや論理バグを未然に防ぐことができます。

本記事のポイントを振り返ります。

  • 大小比較演算子 (<, > など) を文字列に使う際は、辞書順になる点に注意する。
  • 等価比較には、型変換を行わない === を標準として使用する。
  • NaN の判定には Number.isNaN() を使用する。
  • オブジェクトや配列は中身ではなく「参照」で比較される。
  • 比較の前には必要に応じて明示的な型変換を行う。

これらのルールを意識してコードを書くことで、堅牢で読みやすいJavaScriptプログラムを構築できるようになります。

特に、複数の開発者が関わる大規模なプロジェクトや、将来的なメンテナンスを考慮する場合、こうした基本に忠実な比較処理の積み重ねが、システム全体の品質を支える鍵となります。