JavaScript Bitwise OR

​

Syntax

operand1 | operand2

​

Execution Mechanics

1. Type Evaluation and Coercion:
   • Number Operands: If the operands are standard numbers (or non-BigInt values coercible to numbers), JavaScript passes them through the internal ToInt32 abstract operation.
     • Fractional values are strictly truncated (the decimal portion is discarded).
     • Non-numeric values are coerced to numbers. Values that resolve to NaN, null, or undefined are converted to 0.
     • Numeric values exceeding the 32-bit signed integer limit wrap around.
   • BigInt Operands: If both operands are BigInt values, they are evaluated as arbitrary-precision integers using two’s complement representation. They bypass ToInt32 entirely and are not truncated to 32 bits.
   • Mixed Types: Attempting to apply the operator to a mix of BigInt and Number operands throws a TypeError.
2. Bitwise Alignment: The JavaScript engine aligns the binary representations of both integers. For Number operands, this is strictly bounded to 32 bits. For BigInt operands, the representation conceptually extends with infinite sign bits to accommodate the magnitude of the values.
3. Evaluation: A logical OR is applied to each bit position according to the following truth table:
   • 0 | 0 yields 0
   • 0 | 1 yields 1
   • 1 | 0 yields 1
   • 1 | 1 yields 1

​

Code Visualization

const a = 5;  // Binary: 00000000000000000000000000000101
const b = 3;  // Binary: 00000000000000000000000000000011

console.log(a | b); // Output: 7
// Result Binary:      00000000000000000000000000000111

const bigA = 8589934592n; // 2^33 (Exceeds 32-bit limit)
const bigB = 5n;

// Evaluates with arbitrary precision, no 32-bit truncation
console.log(bigA | bigB); // Output: 8589934597n

console.log(5n | 3); 
// Output: TypeError: Cannot mix BigInt and other types, use explicit conversions

// Floating-point truncation
console.log(5.99 | 1.2); // Output: 5
// Step 1: 5.99 is truncated to 5 (0101)
// Step 2: 1.2 is truncated to 1 (0001)
// Step 3: 5 | 1 evaluates to 5 (0101)

// String coercion
console.log("10" | 2); // Output: 10
// Step 1: "10" is coerced to integer 10 (1010)
// Step 2: 2 remains 2 (0010)
// Step 3: 10 | 2 evaluates to 10 (1010)

// NaN / Undefined coercion
console.log(NaN | 4); // Output: 4
// Step 1: NaN is coerced to 0 (0000)
// Step 2: 4 remains 4 (0100)
// Step 3: 0 | 4 evaluates to 4 (0100)

const c = -5; // Binary: 11111111111111111111111111111011
const d = 2;  // Binary: 00000000000000000000000000000010

console.log(c | d); // Output: -5
// Result Binary:      11111111111111111111111111111011