> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# TypeScript Bitwise OR Assignment
The `|=` (bitwise OR assignment) operator performs a bitwise OR operation between the binary representations of its left and right operands, assigning the resulting value to the left operand.
## Syntax
```typescript theme={"dark"}
x |= y;
```
This is syntactically equivalent to:
```typescript theme={"dark"}
x = x | y;
```
## Mechanics
1. **Operand Conversion:**
* For `number` types, TypeScript (following JavaScript semantics) implicitly truncates both operands into 32-bit signed integers represented in two's complement format.
* For `bigint` types, operands are not truncated to 32 bits and retain their arbitrary precision during the bitwise operation.
2. **Bitwise Evaluation:** The operator compares the operands bit by bit. If either the left bit *or* the right bit at a given position is `1`, the corresponding bit in the result is set to `1`. It yields `0` only if both bits are `0`.
3. **Assignment:** The evaluated result is assigned back to the left operand. For `number` types, the 32-bit integer result is converted back into a standard IEEE 754 double-precision float before assignment.
## Truth Table
\| Bit `x` | Bit `y` | Result (`x | y`) |
\| :---: | :---: | :---: |
\| 0 | 0 | **0** |
\| 0 | 1 | **1** |
\| 1 | 0 | **1** |
\| 1 | 1 | **1** |
## Code Visualization
```typescript theme={"dark"}
let a: number = 5;
// 32-bit binary: 00000000000000000000000000000101
let b: number = 3;
// 32-bit binary: 00000000000000000000000000000011
a |= b;
// Bitwise OR: 00000000000000000000000000000111
// Decimal value: 7
console.log(a); // 7
```
## TypeScript Type Constraints
TypeScript enforces strict type checking on bitwise operators to prevent unintended runtime coercion:
* **Valid Numeric Types:** Operands must be of a valid numeric type (`number`, `bigint`, or an `enum`). Attempting to use `|=` with strictly typed non-numeric types (such as `string`, `boolean`, or `object`) will trigger compiler error `TS2362` (for the left-hand side) or `TS2363` (for the right-hand side), stating that the operand *"must be of type 'any', 'number', 'bigint' or an enum type."* Variables explicitly typed as `any` will bypass this check and will not throw an error.
* **Type Homogeneity:** TypeScript requires both operands to be of the exact same type. You cannot mix `number` and `bigint` without explicit casting. Mixing incompatible but otherwise valid numeric types triggers `TS2365`.
```typescript theme={"dark"}
let num: number = 10;
num |= 2; // Valid
let big: bigint = 10n;
big |= 2n; // Valid
// Mixing types:
// big |= 2;
// Error TS2365: Operator '|=' cannot be applied to types 'bigint' and 'number'.
// Invalid types:
let str: string = "2";
// num |= str;
// Error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type.
```
Tired of Poor TypeScript Skills? Fix That With Deep Grasping!
Learn More
