JavaScriptにおいて、値が等しいかどうかを判定する処理は、プログラムの論理構造を決定する極めて重要な要素です。

しかし、JavaScriptには「等価演算子（==）」と「厳密等価演算子（===）」という2種類の比較演算子が存在し、それぞれの挙動の違いを正確に理解していないと思わぬバグを招く原因となります。

動的型付け言語であるJavaScriptは、比較の際に暗黙的な型変換（Type Coercion）を行う特性があります。

この特性は利便性をもたらす一方で、開発者の意図しない判定結果を生むリスクを孕んでいます。

本記事では、厳密等価演算子の仕組みと重要性を中心に、等価演算子との具体的な違いや、プロフェッショナルな現場で推奨される使い分けの基準について詳しく掘り下げていきます。

目次 [ close ]
  1. JavaScriptにおける2つの等価演算子
    1. 等価演算子（==）とは
    2. 厳密等価演算子（===）とは
  2. 暗黙的な型変換の罠：等価演算子が危険な理由
    1. 数値、文字列、真偽値の比較
    2. null と undefined の特殊な関係
  3. 厳密等価演算子（===）を採用すべきメリット
    1. 1. 予測可能性の向上
    2. 2. バグの未然防止
    3. 3. パフォーマンスの最適化
  4. 参照型（オブジェクト・配列）の比較における注意点
    1. 値の比較ではなく「参照」の比較
  5. 特殊なケース：NaN と Object.is
    1. NaN は自分自身とも等しくない
    2. Object.is による比較
  6. 使い分けのベストプラクティス
    1. 原則として「===」を常に使用する
    2. ESLint 等のツールで強制する
    3. 「==」の使用が許容される唯一のケース
  7. まとめ

JavaScriptにおける2つの等価演算子

JavaScriptで値を比較する際、最も頻繁に使用されるのが == と === です。

これらは一見似ていますが、判定のプロセスが根本的に異なります。

等価演算子（==）とは

等価演算子（==）は、比較する2つの値の型が異なる場合に、どちらか一方、あるいは両方の値を自動的に共通の型へ変換してから比較を行います。

これを「抽象的な比較（Abstract Equality）」と呼びます。

厳密等価演算子（===）とは

厳密等価演算子（===）は、型変換を一切行いません。

比較する2つの値が「同じ型」であり、かつ「同じ値」である場合のみ真（true）を返します。

これを「厳密な比較（Strict Equality）」と呼びます。

以下のコードで、その基本的な挙動の違いを確認してみましょう。

JavaScript
// 数値の1と文字列の"1"を比較
const num = 1;
const str = "1";

console.log(num == str);  // 型変換が行われる
console.log(num === str); // 型変換が行われない
実行結果
true
false

このように、等価演算子では数値と文字列が「等しい」と判定されますが、厳密等価演算子では「異なるもの」として扱われます。

暗黙的な型変換の罠：等価演算子が危険な理由

等価演算子（==）が推奨されない最大の理由は、型変換のルールが複雑で予測しにくい点にあります。

JavaScriptの仕様（ECMAScript）では詳細な変換アルゴリズムが定義されていますが、これをすべて把握して使いこなすのは現実的ではありません。

数値、文字列、真偽値の比較

特に混乱を招きやすいのが、数値、文字列、真偽値が混在する比較です。

JavaScript
console.log(true == 1);     // true (trueが1に変換される)
console.log(false == 0);    // true (falseが0に変換される)
console.log("" == 0);       // true (空文字が0に変換される)
console.log(" \t\r\n" == 0); // true (空白文字も0に変換される)
実行結果
true
true
true
true

上記の例では、論理的には全く異なるはずの値が true と判定されています。

例えば、ユーザー入力が空文字だった場合に、数値の 0 と等しいと判定されてしまうと、バリデーションチェックを通り抜けてしまうといった不具合に繋がります。

null と undefined の特殊な関係

等価演算子において、null と undefined は互いに等しいと見なされますが、他の値とは等しいと見なされません。

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

この挙動は、特定のケースで便利に利用されることもありますが、原則としては厳密等価演算子を用いて明確に区別すべきです。

厳密等価演算子（===）を採用すべきメリット

現代のJavaScript開発において、比較には原則として厳密等価演算子を使用することがスタンダードとなっています。

その主な理由は以下の3点です。

1. 予測可能性の向上

型変換が行われないため、コードを読んだ際に結果が直感的に理解しやすくなります。

数値なら数値同士、文字列なら文字列同士という前提で比較が行われるため、ロジックの透明性が高まります。

2. バグの未然防止

「数値の 0」と「空文字列 ""」を誤って同一視するようなミスを、言語仕様レベルで防ぐことができます。

大規模なアプリケーション開発において、こうした小さな認識のズレが致命的な計算ミスや条件分岐の誤りを引き起こすことは珍しくありません。

3. パフォーマンスの最適化

等価演算子（==）は、内部的に型を確認し、必要に応じて変換処理を実行するステップが必要です。

一方で厳密等価演算子（===）は、型が異なれば即座に false を返すため、微々たる差ではありますが、処理のオーバーヘッドが少なくなります。

参照型（オブジェクト・配列）の比較における注意点

厳密等価演算子を使用する場合でも、プリミティブ型（数値、文字列、真偽値など）と参照型（オブジェクト、配列、関数）では比較の仕組みが異なる点に注意が必要です。

値の比較ではなく「参照」の比較

オブジェクトや配列の場合、=== はその中身（プロパティの値や要素）が同じかどうかではなく、メモリ上の同じ場所を指しているか（参照が一致するか）を判定します。

JavaScript
const arrayA = [1, 2, 3];
const arrayB = [1, 2, 3];
const arrayC = arrayA;

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

たとえ見た目が全く同じオブジェクトであっても、新しく生成されたものであれば厳密等価演算の結果は false となります。

配列やオブジェクトの中身を比較したい場合は、ループ処理で各要素を確認するか、JSON文字列に変換して比較する、あるいはライブラリの等価比較関数を利用するなどの工夫が必要です。

特殊なケース：NaN と Object.is

厳密等価演算子（===）でも正しく判定できない特殊なケースが存在します。

その代表例が NaN（Not-a-Number）です。

NaN は自分自身とも等しくない

JavaScriptの仕様上、NaN はいかなる値とも等しくないと定義されています。

これは厳密等価演算子を使用しても同様です。

JavaScript
const value = NaN;

console.log(value === NaN); // false
console.log(Number.isNaN(value)); // true (専用のメソッドを使用)
実行結果
false
true

Object.is による比較

ES2015（ES6）以降では、より厳密な比較を行うための Object.is() メソッドが導入されました。

これは多くの場合 === と同じ挙動を示しますが、NaN の扱いや、+0 と -0 の区別において差異があります。

比較内容=====Object.is
NaN vs NaNfalsefalsetrue
0 vs -0truetruefalse
1 vs "1"truefalsefalse

通常のビジネスロジックでは === で十分ですが、数値計算などで厳密な極性の区別や NaN の検知が必要な場合には Object.is() の活用を検討してください。

使い分けのベストプラクティス

これまでの解説を踏まえ、実務における使い分けのガイドラインをまとめます。

原則として「===」を常に使用する

現代のJavaScriptコーディング規約（AirbnbのスタイルガイドやGoogleのスタイルガイドなど）では、等価演算子（==）の使用を禁止し、厳密等価演算子（===）の使用を義務付けていることがほとんどです。

開発チーム内でのコードの品質を一貫させるためにも、このルールに従うのが最も安全な選択です。

ESLint 等のツールで強制する

人間が手動でチェックするのには限界があります。

プロジェクトに ESLint を導入し、eqeqeq ルールを有効にすることで、== を使用した際に自動的に警告やエラーを表示するように設定することをお勧めします。

「==」の使用が許容される唯一のケース

唯一、意図的に等価演算子が使われることがあるのが、null と undefined を同時にチェックしたい場合です。

JavaScript
// nullとundefinedの両方を一度にチェック
if (value == null) {
  // valueがnullまたはundefinedの場合に実行される
}

// 上記を厳密に書くと以下のようになる
if (value === null || value === undefined) {
  // ...
}

この書き方はコードを短縮できるメリットがありますが、初心者が見た際に「単なるミス」なのか「意図的な使い分け」なのかを判断しにくいというデメリットもあります。

可読性を重視するなら、厳密等価演算子で明示的に書くか、TypeScriptを導入して型安全性を確保するのが現代的なアプローチです。

まとめ

JavaScriptの比較演算における == と === の違いは、単なる記法の差異ではなく、言語の設計思想に関わる重要なポイントです。

等価演算子（==）は暗黙的な型変換を行い、予期しない結果を招く可能性があるため、現代の開発では避けるべきとされています。

一方、厳密等価演算子（===）は型と値の両方を厳格にチェックするため、安全で堅牢なプログラムを作成する上で欠かせません。

開発者は、JavaScriptが持つ柔軟性を正しく理解しつつ、「常に厳密等価演算子（===）を選択する」という習慣を身につけることで、バグを減らし、メンテナンス性の高いコードを実現することができます。

特殊な比較が必要な場合を除き、常に型を意識したプログラミングを心がけましょう。