JavaScript Left Shift Assignment

​

Syntax

x <<= y

​

Execution Mechanics

​

For Number Operands

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

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

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

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

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

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

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

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