2.5 Operations that coerce

2.5.1 Addition operator (+)

This is how JavaScript’s addition operator is specified:

  1. function Addition(leftHandSide, rightHandSide) {
  2.   let lprim = ToPrimitive(leftHandSide);
  3.   let rprim = ToPrimitive(rightHandSide);
  4.   if (TypeOf(lprim) === 'string' || TypeOf(rprim) === 'string') { // (A)
  5.     return ToString(lprim) + ToString(rprim);
  6.   }
  7.   let lnum = ToNumeric(lprim);
  8.   let rnum = ToNumeric(rprim);
  9.   if (TypeOf(lnum) !== TypeOf(rnum)) {
  10.     throw new TypeError();
  11.   }
  12.   let T = Type(lnum);
  13.   return T.add(lnum, rnum); // (B)
  14. }

Steps of this algorithm:

  • Both operands are converted to primitive values.
  • If one of the results is a string, both are converted to strings and concatenated (line A).
  • Otherwise, both operands are converted to numeric values and added (line B). Type() returns the ECMAScript specification type of lnum. .add() is a method of numeric types.

2.5.2 Abstract Equality Comparison (==)

  1. /** Loose equality (==) */
  2. function abstractEqualityComparison(x, y) {
  3.   if (TypeOf(x) === TypeOf(y)) {
  4.     // Use strict equality (===)
  5.     return strictEqualityComparison(x, y);
  6.   }
  8.   // Comparing null with undefined
  9.   if (x === null && y === undefined) {
  10.     return true;
  11.   }
  12.   if (x === undefined && y === null) {
  13.     return true;
  14.   }
  16.   // Comparing a number and a string
  17.   if (TypeOf(x) === 'number' && TypeOf(y) === 'string') {
  18.     return abstractEqualityComparison(x, Number(y));
  19.   }
  20.   if (TypeOf(x) === 'string' && TypeOf(y) === 'number') {
  21.     return abstractEqualityComparison(Number(x), y);
  22.   }
  24.   // Comparing a bigint and a string
  25.   if (TypeOf(x) === 'bigint' && TypeOf(y) === 'string') {
  26.     let n = StringToBigInt(y);
  27.     if (Number.isNaN(n)) {
  28.       return false;
  29.     }
  30.     return abstractEqualityComparison(x, n);
  31.   }
  32.   if (TypeOf(x) === 'string' && TypeOf(y) === 'bigint') {
  33.     return abstractEqualityComparison(y, x);
  34.   }
  36.   // Comparing a boolean with a non-boolean
  37.   if (TypeOf(x) === 'boolean') {
  38.     return abstractEqualityComparison(Number(x), y);
  39.   }
  40.   if (TypeOf(y) === 'boolean') {
  41.     return abstractEqualityComparison(x, Number(y));
  42.   }
  44.   // Comparing an object with a primitive
  45.   // (other than undefined, null, a boolean)
  46.   if (['string', 'number', 'bigint', 'symbol'].includes(TypeOf(x))
  47.     && TypeOf(y) === 'object') {
  48.       return abstractEqualityComparison(x, ToPrimitive(y));
  49.     }
  50.   if (TypeOf(x) === 'object'
  51.     && ['string', 'number', 'bigint', 'symbol'].includes(TypeOf(y))) {
  52.       return abstractEqualityComparison(ToPrimitive(x), y);
  53.     }
  55.   // Comparing a bigint with a number
  56.   if ((TypeOf(x) === 'bigint' && TypeOf(y) === 'number')
  57.     || (TypeOf(x) === 'number' && TypeOf(y) === 'bigint')) {
  58.       if ([NaN, +Infinity, -Infinity].includes(x)
  59.         || [NaN, +Infinity, -Infinity].includes(y)) {
  60.           return false;
  61.         }
  62.       if (isSameMathematicalValue(x, y)) {
  63.         return true;
  64.       } else {
  65.         return false;
  66.       }
  67.     }
  69.   return false;
  70. }

The following operations are not shown here: