JavaScript/!=

カテゴリ:Book:JavaScript#!=%20

!=（Inequality operator） は、ECMAScript における不等価演算子です。この演算子は、2つのオペランドを比較し、それらが等しくないかどうかを判断します。不等価演算子は等価演算子（==）と同様に型変換（型強制）を行い、異なる型の値を比較する際に特定のルールに従います[1]。

構文

EqualityExpression[?In, ?Yield, ?Await] != RelationalExpression[?In, ?Yield, ?Await]
  • EqualityExpression[?In, ?Yield, ?Await]: 比較される左側のオペランド
  • RelationalExpression[?In, ?Yield, ?Await]: 比較される右側のオペランド

この演算子は、以下のように使用されます：

let x = 5;
let y = "6";
console.log(x != y); // true（型変換が行われた後、値が異なる）

動作

不等価演算子（!=）は、以下の順序で動作します：

  1. 等価比較を実行: 内部的に等価演算子（==）と同じ比較ロジックを使用
  2. 結果を否定: 等価比較の結果の論理否定（NOT）を返す

つまり、a != b は !(a == b) と等価です。

例

基本的な使用法

以下のプログラムは、不等価演算子の基本的な使用法を示しています。

// 基本的な使用法
let x = 5;
let y = 10;
console.log(x != y); // true（値が異なる）

let a = 5;
let b = 5;
console.log(a != b); // false（値が同じ）

このプログラムでは、同じ型（数値）の値を比較しています。

型変換の例

以下のプログラムは、不等価演算子による型変換の例を示しています。

// 数値と文字列
console.log(5 != "5"); // false（文字列 "5" が数値 5 に変換され、等しいと判断される）
console.log(5 != "6"); // true（文字列 "6" が数値 6 に変換され、5 と異なると判断される）

// ブーリアンと数値
console.log(true != 1); // false（true が 1 に変換され、等しいと判断される）
console.log(false != 1); // true（false が 0 に変換され、1 と異なると判断される）

// null と undefined
console.log(null != undefined); // false（特別なケースとして等しいと判断される）
console.log(null != 0); // true（null は 0 と等しくないと判断される）

// オブジェクトと基本型
console.log([1] != 1); // false（[1] は "1" に変換され、さらに 1 に変換され、等しいと判断される）
console.log([2] != 1); // true（[2] は "2" に変換され、さらに 2 に変換され、1 と異なると判断される）

このプログラムでは、異なる型の値を比較した場合の型変換の仕組みを示しています。

条件文での使用

以下のプログラムは、条件文内での不等価演算子の使用例を示しています。

// 条件文での使用
let value = "5";
if (value != 6) {
  console.log("値は 6 ではない"); // 出力される
}

let emptyArray = [];
if (emptyArray != true) {
  console.log("空の配列は true ではない"); // 出力される
}

このプログラムでは、条件文の中で不等価演算子を使用して、型変換が発生する例を示しています。

注意点

  • 予期しない結果: 等価演算子と同様に、型変換のルールにより直感に反する結果が生じることがあります。
  • NaN: NaN は他のどの値とも等しくないため、NaN != x は常に true を返します（NaN 自身との比較を含む）。
// 予期しない結果の例
console.log([] != ""); // false（[] は "" と等しいと判断される）
console.log([] != 0); // false（[] は 0 と等しいと判断される）
console.log("" != 0); // false（"" は 0 と等しいと判断される）

// NaN の例
console.log(NaN != NaN); // true（NaN は自分自身を含む他のどの値とも等しくない）
console.log(NaN != 5); // true

厳密不等価演算子との違い

不等価演算子（!=）と厳密不等価演算子（!==）の主な違いは、以下の通りです：

  • 不等価演算子（!=）: 型変換を行ってから比較し、結果を否定する
  • 厳密不等価演算子（!==）: 値または型のいずれかが異なる場合に true を返す

例：

let x = 5;
let y = "5";

console.log(x != y); // false（型変換が行われ、等しいと判断される）
console.log(x !== y); // true（型が異なるため）

console.log(null != undefined); // false（型変換により等しいと判断される）
console.log(null !== undefined); // true（型が異なるため）

ベストプラクティス

  • 予期しない型変換を避けるため、多くの場合は厳密不等価演算子（!==）の使用が推奨されます。
  • コードの意図を明確にするために、型変換が必要な場合は明示的に行うことが良い習慣です。
// 推奨される方法
let x = 5;
let y = "5";

// 暗黙的な型変換に依存する（理解しにくい）
if (x != y) {
  // 実行されない
}

// 明示的な型変換を行う（理解しやすい）
if (x !== Number(y)) {
  // 実行されない
}

// または厳密不等価演算子を使用する
if (x !== y) {
  // 実行される
}

実装上の詳細

不等価演算子（!=）の内部的な実装は、以下のようになっています：

  1. 左オペランドを評価する
  2. 右オペランドを評価する
  3. Abstract Equality Comparison アルゴリズムを使用して比較を行う
  4. 比較結果の論理否定を返す

Abstract Equality Comparison アルゴリズムは等価演算子（==）と共有されており、型変換のルールも同じです。

脚註

  1. ↑ 不等価演算子は等価演算子（==）の否定であり、同じ型変換ルールに従いますが、最終的な結果を反転させます。

外部リンク

カテゴリ:Book:JavaScript#!=%20 カテゴリ:JavaScript
カテゴリ:Book:JavaScript カテゴリ:JavaScript カテゴリ:Pages using the JsonConfig extension