Bitwise XOR

The ^ operator in TypeScript is the bitwise XOR (exclusive OR) operator. It evaluates two numeric operands by performing a logical exclusive OR operation on each corresponding pair of bits. For standard number operands, this involves converting them to 32-bit signed integers, whereas bigint operands operate at arbitrary precision.

The operator evaluates bits according to the following truth table:

• 0 ^ 0 yields 0
• 1 ^ 1 yields 0
• 0 ^ 1 yields 1
• 1 ^ 0 yields 1

const operandA: number = 0b1010;
const operandB: number = 0b1100;
const result: number = operandA ^ operandB; // 0b0110

Evaluation Mechanics

When the TypeScript compiler transpiles and the JavaScript engine executes the ^ operator, the execution behavior depends strictly on the type of the operands:

For number and numeric enum operands:

1. Type Coercion and Truncation: Both operands are converted to 32-bit signed integers using two’s complement representation. Any fractional components are discarded (e.g., 5.9 becomes 5).
2. Bitwise Comparison: The engine aligns the 32 bits of both operands and compares them positionally.
3. Return Value: A new 32-bit signed integer is returned based on the XOR evaluation of the bit pairs.

const a: number = 5;  // Binary: ...0000 0101
const b: number = 3;  // Binary: ...0000 0011

const result: number = a ^ b; 

// Bitwise Evaluation:
//   0101 (5 in decimal)
// ^ 0011 (3 in decimal)
// ---
//   0110 (6 in decimal)

console.log(result); // Outputs: 6

For bigint operands: The operands are not truncated to 32 bits. The engine aligns the binary representation of the arbitrary-precision integers and performs the XOR operation across all bits, returning a new bigint.

TypeScript Type Constraints

TypeScript enforces strict type checking on the ^ operator to prevent unintended runtime coercion:

Number and Enum Operands: Operands can be of type number, any, or a numeric enum.

enum Flags {
  Read = 1,
  Write = 2
}

const val1: number = 10;
const val2: Flags = Flags.Write;
const out: number = val1 ^ val2; // Valid, returns 8

BigInt Operands: The ^ operator fully supports bigint types. Because bigint operates at arbitrary precision, no 32-bit truncation occurs.

const big1: bigint = 10n;
const big2: bigint = 4n;
const bigOut: bigint = big1 ^ big2; // Valid, returns 14n

Mixed Types (Compilation Error): TypeScript will throw a ts(2365) error if you attempt to mix number (or enum) and bigint operands, as the underlying JavaScript engine cannot implicitly mix these types for bitwise operations.

const num: number = 5;
const big: bigint = 3n;

// Error: Operator '^' cannot be applied to types 'number' and 'bigint'.
const invalid = num ^ big; 

Compound Assignment

TypeScript supports the compound assignment operator ^=, which applies the bitwise XOR operation and assigns the resulting value back to the left operand.

let x: number = 5;
x ^= 3; // Syntactic sugar for: x = x ^ 3;
// x is now 6

Master TypeScript with Deep Grasping Methodology!

Learn More