JavaScriptにおける型強制 • Deep JavaScript

2　JavaScriptにおける型強制

2.1　型強制とは何か？
- 2.1.1　型強制への対処法
2.2　ECMAScript仕様における型強制の実装を支援する演算
- 2.2.1　プリミティブ型とオブジェクトへの変換
- 2.2.2　数値型への変換
- 2.2.3　プロパティキーへの変換
- 2.2.4　配列インデックスへの変換
- 2.2.5　型付き配列要素への変換
2.3　休憩：JavaScriptにおける仕様アルゴリズムの表現
2.4　型強制アルゴリズムの例
- 2.4.1　ToPrimitive()
- 2.4.2　ToString()および関連演算
- 2.4.3　ToPropertyKey()
- 2.4.4　ToNumeric()および関連演算
2.5　型強制を行う演算
- 2.5.1　加算演算子 (+)
- 2.5.2　抽象等価比較 (==)
2.6　用語集：型変換に関する用語

この章では、JavaScriptにおける型強制の役割を調べます。このトピックについて比較的深く掘り下げ、例えばECMAScript仕様がどのように型強制を扱うかを見ていきます。

2.1　型強制とは何か？

各演算（関数、演算子など）は、そのパラメータが特定の型を持つことを期待します。値がパラメータに適切な型を持っていない場合、関数などに対しては3つの一般的な選択肢があります。

関数が例外をスローする

function multiply(x, y) {
  if (typeof x !== 'number' || typeof y !== 'number') {
    throw new TypeError();
  }
  // ···
}

関数がエラー値を返す

function multiply(x, y) {
  if (typeof x !== 'number' || typeof y !== 'number') {
    return NaN;
  }
  // ···
}

関数がその引数を有用な値に変換する

function multiply(x, y) {
  if (typeof x !== 'number') {
    x = Number(x);
  }
  if (typeof y !== 'number') {
    y = Number(y);
  }
  // ···
}

(3)では、演算は暗黙的な型変換を実行します。これは型強制と呼ばれます。

JavaScriptは当初例外を持たなかったため、ほとんどの演算で型強制とエラー値を使用しています。

// Coercion
assert.equal(3 * true, 3);

// Error values
assert.equal(1 / 0, Infinity);
assert.equal(Number('xyz'), NaN);

しかし、（特に新しい機能に関しては）引数が適切な型を持っていない場合に例外をスローするケースもあります。

nullまたはundefinedのプロパティへのアクセス

> undefined.prop
TypeError: Cannot read property 'prop' of undefined
> null.prop
TypeError: Cannot read property 'prop' of null
> 'prop' in null
TypeError: Cannot use 'in' operator to search for 'prop' in null

シンボルの使用

> 6 / Symbol()
TypeError: Cannot convert a Symbol value to a number

BigIntと数値の混合

> 6 / 3n
TypeError: Cannot mix BigInt and other types

その演算をサポートしていない新しい呼び出しまたは関数呼び出しの値

> 123()
TypeError: 123 is not a function
> (class {})()
TypeError: Class constructor  cannot be invoked without 'new'

> new 123
TypeError: 123 is not a constructor
> new (() => {})
TypeError: (intermediate value) is not a constructor

読み取り専用プロパティの変更（厳格モードでのみ例外をスロー）

> 'abc'.length = 1
TypeError: Cannot assign to read only property 'length'
> Object.freeze({prop:3}).prop = 1
TypeError: Cannot assign to read only property 'prop'

2.1.1　型強制への対処法

型強制に対処する2つの一般的な方法は次のとおりです。

呼び出し元は、値を明示的に変換して適切な型にすることができます。例えば、次のやり取りでは、文字列としてエンコードされた2つの数値を掛け合わせたいと考えています。
```
let x = '3';
let y = '2';
assert.equal(Number(x) * Number(y), 6);
```
呼び出し元は、演算にその変換を任せることができます。
```
let x = '3';
let y = '2';
assert.equal(x * y, 6);
```

私は通常、前者の方が好みです。なぜなら、私の意図を明確にするからです。私はxとyが数値ではないことを期待していますが、2つの数値を掛け合わせたいのです。

2.2　ECMAScript仕様における型強制の実装を支援する演算

以降のセクションでは、ECMAScript仕様で実際の引数を期待される型に変換するために使用される最も重要な内部関数を説明します。

例えば、TypeScriptでは次のように記述します。

function isNaN(number: number) {
  // ···
}

仕様では、これは次のようになります（JavaScriptに翻訳されているため、理解しやすくなっています）。

function isNaN(number) {
  let num = ToNumber(number);
  // ···
}

2.2.1　プリミティブ型とオブジェクトへの変換

プリミティブ型またはオブジェクトが期待される場合は、次の変換関数が使用されます。

ToBoolean()
ToNumber()
ToBigInt()
ToString()
ToObject()

これらの内部関数には、JavaScriptで非常に類似したアナログがあります。

> Boolean(0)
false
> Boolean(1)
true

> Number('123')
123

数値と並んで存在するBigIntの導入後、仕様では以前ToNumber()を使用していた場所にToNumeric()を頻繁に使用しています。詳細については、読み進めてください。

2.2.2　数値型への変換

現在、JavaScriptには2つの組み込み数値型があります：numberとbigint。

ToNumeric()は数値numを返します。その呼び出し元は通常、numの仕様型であるメソッドmthdを呼び出します。
```
Type(num)::mthd(···)
```
その他にも、次の演算でToNumericを使用します。
- 前置と後置の++演算子
- *演算子
小数点以下のない数値が期待される場合は、ToInteger(x)が使用されます。結果の範囲は、その後さらに制限されることがよくあります。
- これはToNumber(x)を呼び出し、小数点以下を除去します（Math.trunc()に似ています）。
- ToInteger()を使用する演算
  - Number.prototype.toString(radix?)
  - String.prototype.codePointAt(pos)
  - Array.prototype.slice(start, end)
  - など
ToInt32()、ToUint32()は数値を32ビット整数に変換し、ビット演算子で使用されます（表1を参照）。
- ToInt32()：符号付き、範囲[−2³¹, 2³¹−1]（制限値を含む）
- ToUint32()：符号なし（したがってU）、範囲[0, 2³²−1]（制限値を含む）

表1：ビット演算数値演算子のオペランドの型強制（BigInt演算子はビット数を制限しません）。
演算子	左オペランド	右オペランド	結果の型
`<<`	`ToInt32()`	`ToUint32()`	`Int32`
符号付き `>>`	`ToInt32()`	`ToUint32()`	`Int32`
符号なし `>>>`	`ToInt32()`	`ToUint32()`	`Uint32`
`&`, `^`, `\|`	`ToInt32()`	`ToUint32()`	`Int32`
`~`	—	`ToInt32()`	`Int32`

2.2.3　プロパティキーへの変換

ToPropertyKey()は文字列またはシンボルを返し、次で使用されます。

ブラケット演算子[]
オブジェクトリテラルにおける計算されたプロパティキー
in演算子の左辺
Object.defineProperty(_, P, _)
Object.fromEntries()
Object.getOwnPropertyDescriptor()
Object.prototype.hasOwnProperty()
Object.prototype.propertyIsEnumerable()
いくつかのReflectメソッド

2.2.4　配列インデックスへの変換

ToLength()は（直接）主に文字列インデックスに使用されます。
- ToIndex()のヘルパー関数
- 結果lの範囲：0 ≤ l ≤ 2⁵³−1
ToIndex()は型付き配列インデックスに使用されます。
- ToLength()との主な違い：引数が範囲外の場合、例外をスローします。
- 結果iの範囲：0 ≤ i ≤ 2⁵³−1
ToUint32()は配列インデックスに使用されます。
- 結果iの範囲：0 ≤ i < 2³²−1（上限は除外され、.lengthのためのスペースを残します）

2.2.5　型付き配列要素への変換

型付き配列要素の値を設定する場合、次の変換関数のいずれかが使用されます。

ToInt8()
ToUint8()
ToUint8Clamp()
ToInt16()
ToUint16()
ToInt32()
ToUint32()
ToBigInt64()
ToBigUint64()

2.3　休憩：JavaScriptにおける仕様アルゴリズムの表現

この章の残りの部分では、いくつかの仕様アルゴリズムに遭遇しますが、「実装」はJavaScriptで行われます。次のリストは、頻繁に使用されるパターンを仕様からJavaScriptにどのように変換するかを示しています。

仕様：Type(value)がStringの場合
JavaScript：if (TypeOf(value) === 'string')
(非常に大まかな翻訳です。TypeOf()は以下で定義されています)
仕様：IsCallable(method)がtrueの場合
JavaScript：if (IsCallable(method))
(IsCallable()は以下で定義されています)
仕様：numValueをToNumber(value)とする
JavaScript：let numValue = Number(value)
仕様：isArrayをIsArray(O)とする
JavaScript：let isArray = Array.isArray(O)
仕様：Oに[[NumberData]]内部スロットがある場合
JavaScript：if ('__NumberData__' in O)
仕様：tagをGet(O, @@toStringTag)とする
JavaScript：let tag = O[Symbol.toStringTag]
仕様：「[object 」、tag、「]」の文字列連結を返す。
JavaScript：return '[object ' + tag + ']';

仕様の言語に合わせるため、let（constではなく）を使用しています。

いくつかのものは省略されています。たとえば、ReturnIfAbruptショートハンドの?と!です。

/**
 * An improved version of typeof
 */
function TypeOf(value) {
  const result = typeof value;
  switch (result) {
    case 'function':
      return 'object';
    case 'object':
      if (value === null) {
        return 'null';
      } else {
        return 'object';
      }
    default:
      return result;
  }
}

function IsCallable(x) {
  return typeof x === 'function';
}

2.4　型強制アルゴリズムの例

2.4.1　`ToPrimitive()`

演算ToPrimitive()は、多くの型強制アルゴリズムの中間ステップです（この章の後半でいくつか見ていきます）。これは任意の値をプリミティブ値に変換します。

ToPrimitive()は仕様で頻繁に使用されます。なぜなら、ほとんどの演算子はプリミティブ値でのみ動作できるためです。たとえば、加算演算子（+）を使用して数値を加算し、文字列を連結できますが、配列を連結するには使用できません。

これが、ToPrimitive()のJavaScriptバージョンです。

/**
 * @param hint Which type is preferred for the result:
 *             string, number, or don’t care?
 */
function ToPrimitive(input: any,
  hint: 'string'|'number'|'default' = 'default') {
    if (TypeOf(input) === 'object') {
      let exoticToPrim = input[Symbol.toPrimitive]; // (A)
      if (exoticToPrim !== undefined) {
        let result = exoticToPrim.call(input, hint);
        if (TypeOf(result) !== 'object') {
          return result;
        }
        throw new TypeError();
      }
      if (hint === 'default') {
        hint = 'number';
      }
      return OrdinaryToPrimitive(input, hint);
    } else {
      // input is already primitive
      return input;
    }
  }

ToPrimitive()は、オブジェクトがSymbol.toPrimitive（A行）を介してプリミティブへの変換をオーバーライドできるようにします。オブジェクトがそうしない場合、それはOrdinaryToPrimitive()に渡されます。

function OrdinaryToPrimitive(O: object, hint: 'string' | 'number') {
  let methodNames;
  if (hint === 'string') {
    methodNames = ['toString', 'valueOf'];
  } else {
    methodNames = ['valueOf', 'toString'];
  }
  for (let name of methodNames) {
    let method = O[name];
    if (IsCallable(method)) {
      let result = method.call(O);
      if (TypeOf(result) !== 'object') {
        return result;
      }
    }
  }
  throw new TypeError();
}

2.4.1.1　`ToPrimitive()`の呼び出し元はどのヒントを使用しますか？

パラメータhintには、3つの値のいずれかを取ることができます。

'number'は、可能であればinputを数値に変換する必要があることを意味します。
'string'は、可能であればinputを文字列に変換する必要があることを意味します。
'default'は、数値と文字列のどちらにも優先順位がないことを意味します。

さまざまな演算がToPrimitive()を使用する方法の例をいくつか示します。

hint === 'number'。次の演算は数値を優先します。
- ToNumeric()
- ToNumber()
- ToBigInt()、BigInt()
- 抽象関係比較（<）
hint === 'string'。次の演算は文字列を優先します。
- ToString()
- ToPropertyKey()
hint === 'default'。次の演算は、返されるプリミティブ値の型に関してニュートラルです。
- 抽象等価比較（==）
- 加算演算子（+）
- new Date(value)（valueは数値または文字列のいずれかです）

見てきたように、デフォルトの動作では'default'は'number'であるかのように扱われます。SymbolとDateのインスタンスのみが、この動作をオーバーライドします（後で示します）。

2.4.1.2　オブジェクトをプリミティブに変換するために呼び出されるメソッドはどれですか？

プリミティブへの変換がSymbol.toPrimitiveを介してオーバーライドされていない場合、OrdinaryToPrimitive()は次の2つのメソッドのいずれか、または両方とも呼び出します。

'toString'は、プリミティブ値を文字列にしたいというhintが示されている場合に最初に呼び出されます。
'valueOf'は、プリミティブ値を数値にしたいというhintが示されている場合に最初に呼び出されます。

次のコードは、それがどのように機能するかを示しています。

const obj = {
  toString() { return 'a' },
  valueOf() { return 1 },
};

// String() prefers strings:
assert.equal(String(obj), 'a');

// Number() prefers numbers:
assert.equal(Number(obj), 1);

プロパティキーSymbol.toPrimitiveを持つメソッドは、通常のプリミティブへの変換をオーバーライドします。これは標準ライブラリでは2回だけ行われます。

Symbol.prototype[Symbol.toPrimitive](hint)
- レシーバがSymbolのインスタンスの場合、このメソッドは常にラップされたシンボルを返します。
- その理由は、Symbolのインスタンスには文字列を返す.toString()メソッドがあるためです。しかし、hintが'string'であっても、.toString()は呼び出されるべきではありません。そうすることで、Symbolのインスタンスを文字列（まったく異なる種類のプロパティキーです）に誤って変換してしまうことがないからです。
Date.prototype[Symbol.toPrimitive](hint)
- さらに詳細を次に説明します。

2.4.1.3　`Date.prototype[Symbol.toPrimitive]()`

これは、日付がプリミティブ値に変換される方法です。

Date.prototype[Symbol.toPrimitive] = function (
  hint: 'default' | 'string' | 'number') {
    let O = this;
    if (TypeOf(O) !== 'object') {
      throw new TypeError();
    }
    let tryFirst;
    if (hint === 'string' || hint === 'default') {
      tryFirst = 'string';
    } else if (hint === 'number') {
      tryFirst = 'number';
    } else {
      throw new TypeError();
    }
    return OrdinaryToPrimitive(O, tryFirst);
  };

デフォルトのアルゴリズムとの唯一の違いは、'default'が'string'になり（'number'ではなく）、hintを'default'に設定する演算を使用した場合に観察できます。

==演算子は、他のオペランドがundefined、null、boolean以外のプリミティブ値の場合、オブジェクトをプリミティブ（デフォルトのヒント付き）に変換します。次のやり取りでは、日付の変換の結果が文字列であることがわかります。
```
const d = new Date('2222-03-27');
assert.equal(
  d == 'Wed Mar 27 2222 01:00:00 GMT+0100'
       + ' (Central European Standard Time)',
  true);
```
+演算子は、両方のオペランドをプリミティブ型に強制変換します（デフォルトのヒント付き）。結果のいずれかが文字列の場合、文字列連結を実行します（そうでない場合は数値加算を実行します）。次のインタラクションでは、日付の強制変換の結果が文字列であることがわかります。なぜなら、演算子は文字列を返しているからです。
```
const d = new Date('2222-03-27');
assert.equal(
  123 + d,
  '123Wed Mar 27 2222 01:00:00 GMT+0100'
    + ' (Central European Standard Time)');
```

2.4.2　`ToString()`および関連する操作

これは、ToString()のJavaScriptバージョンです。

function ToString(argument) {
  if (argument === undefined) {
    return 'undefined';
  } else if (argument === null) {
    return 'null';
  } else if (argument === true) {
    return 'true';
  } else if (argument === false) {
    return 'false';
  } else if (TypeOf(argument) === 'number') {
    return Number.toString(argument);
  } else if (TypeOf(argument) === 'string') {
    return argument;
  } else if (TypeOf(argument) === 'symbol') {
    throw new TypeError();
  } else if (TypeOf(argument) === 'bigint') {
    return BigInt.toString(argument);
  } else {
    // argument is an object
    let primValue = ToPrimitive(argument, 'string'); // (A)
    return ToString(primValue);
  }
}

この関数が、オブジェクトに対してプリミティブ結果を文字列に変換する前に、中間ステップとしてToPrimitive()を使用している点に注目してください（A行）。

ToString()は、String()の動作と興味深い点で異なります。argumentがシンボルである場合、前者はTypeErrorをスローしますが、後者はスローしません。なぜでしょうか？シンボルのデフォルトは、文字列への変換で例外をスローすることです。

> const sym = Symbol('sym');

> ''+sym
TypeError: Cannot convert a Symbol value to a string
> `${sym}`
TypeError: Cannot convert a Symbol value to a string

そのデフォルトは、String()とSymbol.prototype.toString()でオーバーライドされています（両方とも次のセクションで説明します）。

> String(sym)
'Symbol(sym)'
> sym.toString()
'Symbol(sym)'

2.4.2.1　`String()`

function String(value) {
  let s;
  if (value === undefined) {
    s = '';
  } else {
    if (new.target === undefined && TypeOf(value) === 'symbol') {
      // This function was function-called and value is a symbol
      return SymbolDescriptiveString(value);
    }
    s = ToString(value);
  }
  if (new.target === undefined) {
    // This function was function-called
    return s;
  }
  // This function was new-called
  return StringCreate(s, new.target.prototype); // simplified!
}

String()は、関数呼び出しを介して呼び出されるか、newを介して呼び出されるかによって動作が異なります。new.targetを使用して、この2つを区別します。

これらは、ヘルパー関数StringCreate()とSymbolDescriptiveString()です。

/** 
 * Creates a String instance that wraps `value`
 * and has the given protoype.
 */
function StringCreate(value, prototype) {
  // ···
}

function SymbolDescriptiveString(sym) {
  assert.equal(TypeOf(sym), 'symbol');
  let desc = sym.description;
  if (desc === undefined) {
    desc = '';
  }
  assert.equal(TypeOf(desc), 'string');
  return 'Symbol('+desc+')';
}

2.4.2.2　`Symbol.prototype.toString()`

String()に加えて、.toString()メソッドを使用してシンボルを文字列に変換することもできます。その仕様は以下のとおりです。

Symbol.prototype.toString = function () {
  let sym = thisSymbolValue(this);
  return SymbolDescriptiveString(sym);
};
function thisSymbolValue(value) {
  if (TypeOf(value) === 'symbol') {
    return value;
  }
  if (TypeOf(value) === 'object' && '__SymbolData__' in value) {
    let s = value.__SymbolData__;
    assert.equal(TypeOf(s), 'symbol');
    return s;
  }
}

2.4.2.3　`Object.prototype.toString`

.toString()のデフォルトの仕様は以下のとおりです。

Object.prototype.toString = function () {
  if (this === undefined) {
    return '[object Undefined]';
  }
  if (this === null) {
    return '[object Null]';
  }
  let O = ToObject(this);
  let isArray = Array.isArray(O);
  let builtinTag;
  if (isArray) {
    builtinTag = 'Array';
  } else if ('__ParameterMap__' in O) {
    builtinTag = 'Arguments';
  } else if ('__Call__' in O) {
    builtinTag = 'Function';
  } else if ('__ErrorData__' in O) {
    builtinTag = 'Error';
  } else if ('__BooleanData__' in O) {
    builtinTag = 'Boolean';
  } else if ('__NumberData__' in O) {
    builtinTag = 'Number';
  } else if ('__StringData__' in O) {
    builtinTag = 'String';
  } else if ('__DateValue__' in O) {
    builtinTag = 'Date';
  } else if ('__RegExpMatcher__' in O) {
    builtinTag = 'RegExp';
  } else {
    builtinTag = 'Object';
  }
  let tag = O[Symbol.toStringTag];
  if (TypeOf(tag) !== 'string') {
    tag = builtinTag;
  }
  return '[object ' + tag + ']';
};

この操作は、プレーンオブジェクトを文字列に変換する場合に使用されます。

> String({})
'[object Object]'

デフォルトでは、クラスのインスタンスを文字列に変換する場合にも使用されます。

class MyClass {}
assert.equal(
  String(new MyClass()), '[object Object]');

通常、MyClassの文字列表現を設定するために.toString()をオーバーライドしますが、「object」の後の文字列内の角括弧で囲まれた部分も変更できます。

class MyClass {}
MyClass.prototype[Symbol.toStringTag] = 'Custom!';
assert.equal(
  String(new MyClass()), '[object Custom!]');

.toString()のオーバーライドバージョンとObject.prototypeの元のバージョンを比較すると興味深いです。

> ['a', 'b'].toString()
'a,b'
> Object.prototype.toString.call(['a', 'b'])
'[object Array]'

> /^abc$/.toString()
'/^abc$/'
> Object.prototype.toString.call(/^abc$/)
'[object RegExp]'

2.4.3　`ToPropertyKey()`

ToPropertyKey()は、とりわけ、角括弧演算子で使用されます。その動作は以下のとおりです。

function ToPropertyKey(argument) {
  let key = ToPrimitive(argument, 'string'); // (A)
  if (TypeOf(key) === 'symbol') {
    return key;
  }
  return ToString(key);
}

繰り返しますが、プリミティブ型で操作する前に、オブジェクトはプリミティブ型に変換されます。

2.4.4　`ToNumeric()`および関連する操作

ToNumeric()は、とりわけ、乗算演算子（*）で使用されます。その動作は以下のとおりです。

function ToNumeric(value) {
  let primValue = ToPrimitive(value, 'number');
  if (TypeOf(primValue) === 'bigint') {
    return primValue;
  }
  return ToNumber(primValue);
}

2.4.4.1　`ToNumber()`

ToNumber()は、以下のとおり動作します。

function ToNumber(argument) {
  if (argument === undefined) {
    return NaN;
  } else if (argument === null) {
    return +0;
  } else if (argument === true) {
    return 1;
  } else if (argument === false) {
    return +0;
  } else if (TypeOf(argument) === 'number') {
    return argument;
  } else if (TypeOf(argument) === 'string') {
    return parseTheString(argument); // not shown here
  } else if (TypeOf(argument) === 'symbol') {
    throw new TypeError();
  } else if (TypeOf(argument) === 'bigint') {
    throw new TypeError();
  } else {
    // argument is an object
    let primValue = ToPrimitive(argument, 'number');
    return ToNumber(primValue);
  }
}

ToNumber()の構造は、ToString()の構造と似ています。

2.5　強制変換を行う操作

2.5.1　加算演算子（`+`）

JavaScriptの加算演算子の仕様は以下のとおりです。

function Addition(leftHandSide, rightHandSide) {
  let lprim = ToPrimitive(leftHandSide);
  let rprim = ToPrimitive(rightHandSide);
  if (TypeOf(lprim) === 'string' || TypeOf(rprim) === 'string') { // (A)
    return ToString(lprim) + ToString(rprim);
  }
  let lnum = ToNumeric(lprim);
  let rnum = ToNumeric(rprim);
  if (TypeOf(lnum) !== TypeOf(rnum)) {
    throw new TypeError();
  }
  let T = Type(lnum);
  return T.add(lnum, rnum); // (B)
}

このアルゴリズムの手順

両方のオペランドは、プリミティブ値に変換されます。
結果のいずれかが文字列の場合、両方は文字列に変換され、連結されます（A行）。
そうでない場合、両方のオペランドは数値に変換され、加算されます（B行）。Type()は、lnumのECMAScript仕様の型を返します。.add()は数値型のメソッドです。

2.5.2　抽象等値比較（`==`）

/** Loose equality (==) */
function abstractEqualityComparison(x, y) {
  if (TypeOf(x) === TypeOf(y)) {
    // Use strict equality (===)
    return strictEqualityComparison(x, y);
  }

  // Comparing null with undefined
  if (x === null && y === undefined) {
    return true;
  }
  if (x === undefined && y === null) {
    return true;
  }

  // Comparing a number and a string
  if (TypeOf(x) === 'number' && TypeOf(y) === 'string') {
    return abstractEqualityComparison(x, Number(y));
  }
  if (TypeOf(x) === 'string' && TypeOf(y) === 'number') {
    return abstractEqualityComparison(Number(x), y);
  }

  // Comparing a bigint and a string
  if (TypeOf(x) === 'bigint' && TypeOf(y) === 'string') {
    let n = StringToBigInt(y);
    if (Number.isNaN(n)) {
      return false;
    }
    return abstractEqualityComparison(x, n);
  }
  if (TypeOf(x) === 'string' && TypeOf(y) === 'bigint') {
    return abstractEqualityComparison(y, x);
  }

  // Comparing a boolean with a non-boolean
  if (TypeOf(x) === 'boolean') {
    return abstractEqualityComparison(Number(x), y);
  }
  if (TypeOf(y) === 'boolean') {
    return abstractEqualityComparison(x, Number(y));
  }

  // Comparing an object with a primitive
  // (other than undefined, null, a boolean)
  if (['string', 'number', 'bigint', 'symbol'].includes(TypeOf(x))
    && TypeOf(y) === 'object') {
      return abstractEqualityComparison(x, ToPrimitive(y));
    }
  if (TypeOf(x) === 'object'
    && ['string', 'number', 'bigint', 'symbol'].includes(TypeOf(y))) {
      return abstractEqualityComparison(ToPrimitive(x), y);
    }
  
  // Comparing a bigint with a number
  if ((TypeOf(x) === 'bigint' && TypeOf(y) === 'number')
    || (TypeOf(x) === 'number' && TypeOf(y) === 'bigint')) {
      if ([NaN, +Infinity, -Infinity].includes(x)
        || [NaN, +Infinity, -Infinity].includes(y)) {
          return false;
        }
      if (isSameMathematicalValue(x, y)) {
        return true;
      } else {
        return false;
      }
    }
  
  return false;
}

次の操作はここでは示されていません。

JavaScriptの型強制変換の仕組みを詳しく見てきたので、型変換に関する用語の簡単な用語集で締めくくりましょう。

型変換では、出力値が特定の型になるようにします。入力値が既にその型である場合は、変更せずにそのまま返されます。そうでない場合は、目的の型を持つ値に変換されます。
明示的な型変換とは、プログラマが操作（関数、演算子など）を使用して型変換をトリガーすることを意味します。明示的な変換は次のようになります。
- チェック付き：値を変換できない場合、例外がスローされます。
- チェックなし：値を変換できない場合、エラー値が返されます。
型キャストとは、プログラミング言語によって異なります。たとえば、Javaでは、チェック付きの明示的な型変換です。
型強制変換は暗黙的な型変換です。操作は、必要な型に引数を自動的に変換します。チェック付き、チェックなし、またはその中間の場合があります。

[出典：Wikipedia]

2 JavaScriptにおける型強制

2.1 型強制とは何か？

2.1.1 型強制への対処法

2.2 ECMAScript仕様における型強制の実装を支援する演算

2.2.1 プリミティブ型とオブジェクトへの変換

2.2.2 数値型への変換

2.2.3 プロパティキーへの変換

2.2.4 配列インデックスへの変換

2.2.5 型付き配列要素への変換

2.3 休憩：JavaScriptにおける仕様アルゴリズムの表現

2.4 型強制アルゴリズムの例

2.4.1 ToPrimitive()

2.4.1.1 ToPrimitive()の呼び出し元はどのヒントを使用しますか？

2.4.1.2 オブジェクトをプリミティブに変換するために呼び出されるメソッドはどれですか？

2.4.1.3 Date.prototype[Symbol.toPrimitive]()

2.4.2 ToString()および関連する操作

2.4.2.1 String()

2.4.2.2 Symbol.prototype.toString()

2.4.2.3 Object.prototype.toString

2.4.3 ToPropertyKey()

2.4.4 ToNumeric()および関連する操作

2.4.4.1 ToNumber()

2.5 強制変換を行う操作

2.5.1 加算演算子（+）

2.5.2 抽象等値比較（==）

2.6 用語集：型変換に関する用語