JavaScript Addition Assignment

The addition assignment (+=) operator evaluates the right operand, adds it to the value of the left operand, and assigns the resulting value back to the left operand. The specific operation performed—numeric addition or string concatenation—is dictated by the data types of the operands.

LeftOperand += RightOperand;

This operator is functionally equivalent to LeftOperand = LeftOperand + RightOperand, with the strict architectural distinction that the LeftOperand reference is evaluated only once.

Evaluation Mechanics and Type Coercion

Because JavaScript is dynamically typed, the += operator relies on the ECMAScript internal ToPrimitive algorithm and standard addition semantics to resolve the operation. 1. Numeric Addition If both operands are strictly of type Number, or if both operands are strictly of type BigInt, the operator performs standard mathematical addition. Mixing a Number operand with a BigInt operand is not permitted and will throw a TypeError.

let a = 5;
a += 10; // a is 15 (Number)

let b = 10n;
b += 5n; // b is 15n (BigInt)

let c = 5;
// c += 10n; // Throws TypeError: Cannot mix BigInt and other types

2. String Concatenation If either the left or right operand is a String (after any necessary primitive coercion), the operator forces string concatenation. The non-string operand is implicitly coerced into a string.

let str = "Hello";
str += " World"; // "Hello World" (String)

let mixed = 10;
mixed += "5"; // "105" (String) - Number 10 is coerced to String

3. Object to Primitive Coercion If an operand is an Object (including Array and Date), JavaScript attempts to convert it to a primitive value before applying the += operator. It does this by passing a "default" hint to the internal ToPrimitive algorithm. The resolution follows a specific hierarchy:

If the object implements a [Symbol.toPrimitive]() method, that method is invoked first.
If no such method exists, standard objects prioritize the valueOf() method. If valueOf() does not return a primitive, it falls back to the toString() method.
Date objects exhibit the exact opposite behavior: they prioritize toString() and fall back to valueOf().

let arr = [1, 2];
arr += [3, 4]; 
// arr becomes "1,23,4" (String)
// Arrays coerce to strings via toString(), resulting in "1,2" + "3,4"

let obj = 5;
obj += {}; 
// obj becomes "5[object Object]" (String)
// {} coerces to "[object Object]" via toString()

let dateStr = "Current: ";
dateStr += new Date("2023-01-01"); 
// dateStr becomes "Current: Sun Jan 01 2023..." (String)
// Date objects prioritize toString() over valueOf()

let customObj = 10;
customObj += {
  [Symbol.toPrimitive](hint) {
    return 5;
  }
};
// customObj becomes 15 (Number)
// [Symbol.toPrimitive]() is invoked first

4. Boolean, Null, and Undefined Coercion When interacting with numbers (and no strings are present), JavaScript coerces true to 1, false to 0, and null to 0. undefined coerces to NaN (Not-a-Number).

let num = 10;
num += true; // 11 (Number)
    
let val = 5;
val += null; // 5 (Number)

let undef = 5;
undef += undefined; // NaN (Number)

Tired of Poor JavaScript Skills? Fix That With Deep Grasping!Learn More

Functions

Methods

Constructors

Classes

Destructuring

Decorators

Modules

Accessors

Variables

Fields

Parameters

Error Handling

Control Flow

Statement Forms

Loops

Primitive Types

Comments

Access Operators

Spread Operators

Call Operators

Conditional Operators

Logical Operators

Equality Operators

Relational Operators

Arithmetic Operators

Assignment Operators

Update Operators

Unary Operators

Yield Operators

Bitwise Operators

Shift Operators

JavaScript Addition Assignment

Evaluation Mechanics and Type Coercion

​Evaluation Mechanics and Type Coercion

Evaluation Mechanics and Type Coercion