Left Shift Assignment

The <<= (Left Shift Assignment) operator performs a bitwise left shift on its left operand by the number of bits specified by its right operand, and assigns the resulting value to the left operand.

Syntax

x <<= y

Equivalent to: x = x << y

Execution Mechanics

The behavior of the <<= operator depends strictly on the types of its evaluated operands. JavaScript supports bitwise operations on both Number and BigInt types, but mixing the two throws a TypeError.

For Number Operands

When operating on standard JavaScript numbers (or values coerced to numbers), the engine performs the following sequence:

1. Type Coercion: Both operands are implicitly coerced to 32-bit integers. The left operand is converted to a 32-bit signed integer (ToInt32), and the right operand is converted to a 32-bit unsigned integer (ToUint32).
2. Shift Masking: The right operand is masked with 0x1F (bitwise AND with 31). This applies a modulo 32 operation, ensuring the shift amount is strictly between 0 and 31 bits. Shifting by 32 bits or more wraps around.
3. Bit Manipulation: The 32-bit binary representation of the left operand is shifted to the left by the calculated number of bits.
4. Zero-Filling: Vacated bit positions on the right side are filled with zeros (0).
5. Truncation: Any bits shifted beyond the 32nd bit boundary on the left are discarded.
6. Assignment: The resulting 32-bit signed integer is assigned back to the left operand.

For BigInt Operands

When both operands are BigInt primitives, the 32-bit limitations are bypassed:

1. Validation: The engine checks the right operand. If the shift amount is negative, a RangeError is thrown.
2. Bit Manipulation: The left operand is shifted left by the exact, unmasked number of bits specified by the right operand.
3. Zero-Filling: Vacated bit positions on the right are filled with zeros (0).
4. No Truncation or Masking: The right operand is not masked with 0x1F, and the result is not truncated to 32 bits. The resulting binary representation grows to accommodate the shifted magnitude.
5. Assignment: The resulting BigInt is assigned back to the left operand.

Mechanical Examples

Basic Shift (Number)

let a = 5;      // 32-bit binary: 00000000000000000000000000000101
a <<= 2;        // Shifts left by 2 bits, filling right with 00
console.log(a); // Output: 20
                // 32-bit binary: 00000000000000000000000000010100

Modulo 32 Behavior (Number)

let b = 1;      // 32-bit binary: 00000000000000000000000000000001
b <<= 33;       // 33 & 0x1F = 1. Shifts left by 1 bit.
console.log(b); // Output: 2
                // 32-bit binary: 00000000000000000000000000000010

Unbounded Shift (BigInt)

let c = 1n;     
c <<= 33n;      // No modulo 32 masking, no 32-bit truncation.
console.log(c); // Output: 8589934592n

Sign Bit Overflow (Number)

let d = 1073741824; // 32-bit binary: 01000000000000000000000000000000
d <<= 1;            // The 1 shifts into the sign bit (32nd bit)
console.log(d);     // Output: -2147483648
                    // 32-bit binary: 10000000000000000000000000000000

Implicit Type Coercion (Number)

let e = "3";    // Coerced to ToInt32(3)
e <<= "2";      // Coerced to ToUint32(2)
console.log(e); // Output: 12 (Type is now Number)

Type Mixing Error

let f = 5n;
f <<= 2;        // TypeError: Cannot mix BigInt and other types

Master JavaScript with Deep Grasping Methodology!

Learn More