Bitwise AND Assignment

The bitwise AND assignment (&=) operator performs a bitwise AND operation on two operands and assigns the resulting value to the left operand. For Number operands, it evaluates their 32-bit binary representations, applies a logical AND to each corresponding pair of bits, and mutates the left operand with the final 32-bit integer result. For BigInt operands, it performs the bitwise AND operation across the arbitrary precision of the operands and assigns the resulting BigInt.

x &= y

While often conceptualized as x = x & y, the compound assignment operator &= evaluates the left-hand side expression only once. This distinction is critical when the left operand contains side effects, such as property accessors (getters/setters) or complex expressions. For example, in arr[i++] &= y, the index i is incremented only once, whereas arr[i++] = arr[i++] & y would evaluate and increment i twice.

Execution Mechanics

When the &= operator is evaluated, the JavaScript engine performs the following sequence of operations depending on the operand types:

1. Type Evaluation and Coercion:
   • If both operands are of type Number (or can be coerced to Number), they are implicitly converted to 32-bit signed integers using two’s complement representation via the internal ToInt32 abstract operation. Fractional values are truncated, and non-numeric values (e.g., null, undefined, NaN) are coerced to 0.
   • If both operands are of type BigInt, no 32-bit truncation occurs. The operation is performed using the arbitrary-precision two’s complement representation of the BigInt values.
   • If one operand is a BigInt and the other is a Number, the engine throws a TypeError (e.g., Cannot mix BigInt and other types).
2. Bitwise Evaluation: The engine compares the operands bit by bit. A bit in the resulting binary sequence is set to 1 if and only if the corresponding bits in both operands are 1. If either bit is 0, the resulting bit is 0.
3. Assignment: The newly calculated value (Number or BigInt) is assigned back to the memory space of the left operand.

Step-by-Step Evaluation Example (Number)

let a = 14; 
let b = 9;  

a &= b; 

console.log(a); // Output: 8

Binary Breakdown:

• a (14) is represented in 32-bit binary as: ...0000 1110
• b (9) is represented in 32-bit binary as: ...0000 1001

The bitwise AND operation aligns the bits:

  ...0000 1110  (14)
& ...0000 1001  (9)

  ...0000 1000  (8)

The resulting binary 1000 evaluates to the base-10 integer 8, which is then assigned to a.

BigInt Behavior

When using BigInt operands, the bitwise AND operation scales to the precision of the values without 32-bit truncation:

let bigX = 0b111100001111000011110000111100001111n;
let bigY = 0b101010101010101010101010101010101010n;

bigX &= bigY;

console.log(bigX); // Output: 43118103050n (0b101000001010000010100000101000001010n)

Attempting to mix BigInt and Number results in a TypeError:

let mixed = 10n;
mixed &= 5; // TypeError: Cannot mix BigInt and other types, use explicit conversions

Coercion Behavior (Number Context)

Because the operator forces a ToInt32 conversion for non-BigInt types, applying &= to non-integer types results in strict truncation and type casting before the bitwise operation occurs:

let x = 5.99; // Truncated to 5 (...0101)
x &= 3;       // 3 is (...0011)
// 5 & 3 evaluates to 1 (...0001)
console.log(x); // Output: 1

let y = "12"; // Coerced to number 12 (...1100)
y &= 10;      // 10 is (...1010)
// 12 & 10 evaluates to 8 (...1000)
console.log(y); // Output: 8

let z = NaN;  // Coerced to 0
z &= 5;       
console.log(z); // Output: 0

Master JavaScript with Deep Grasping Methodology!

Learn More