> ## 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.
# Dart Bitwise OR Assignment
The `|=` operator is a compound assignment operator in Dart that performs an OR (`|`) operation between the left and right operands and assigns the resulting value back to the left operand. Its behavior is dictated by the implementation of `operator |` on the left operand's type.
```dart theme={"dark"}
a |= b;
```
While conceptually similar to `a = a | b;`, the compound assignment operator evaluates the left-hand side expression **exactly once**. This is a critical semantic distinction if the left operand is an expression with side effects, such as a mutating indexer or a function call. In a compound assignment, the side effect is triggered only once, whereas the expanded form would evaluate it twice.
```dart theme={"dark"}
// The index 'i' is incremented exactly once.
list[i++] |= b;
// In contrast, the expanded form increments 'i' twice:
// list[i++] = list[i++] | b;
```
## Built-in Type Mechanics
**Integers (`int`) and `BigInt` (Bitwise OR)**
When applied to `int` or `BigInt` types, the operator performs a bitwise OR. It evaluates the binary representation of both operands, returning `1` for each bit position where at least one of the corresponding bits is `1`. If both bits are `0`, the resulting bit is `0`.
*Platform-Specific Behavior for `int`:*
* **Native Dart (Dart VM):** Bitwise operations are evaluated as 64-bit integers.
* **Web Dart (Compiled to JavaScript):** Bitwise operations truncate the operands to 32-bit integers prior to evaluation.
```dart theme={"dark"}
int a = 5; // Binary representation: ...0101
int b = 3; // Binary representation: ...0011
a |= b; // Performs: 0101 | 0011
print(a); // Outputs: 7 (Binary: ...0111)
```
**Booleans (`bool`) (Non-Short-Circuiting Logical OR)**
When applied to `bool` types, `|=` invokes Dart's non-short-circuiting logical OR (`|`). Unlike the standard `||` operator, which stops evaluation if the left operand is `true`, the `|` operator evaluates both the left and right operands. It assigns `true` to the left operand if at least one of the evaluated values is `true`.
```dart theme={"dark"}
bool a = false;
bool b = true;
a |= b;
print(a); // Outputs: true
```
## Custom Types and Operator Overloading
Because Dart supports operator overloading, the `|=` operator is not restricted to primitive types. Any custom class can implement `operator |`, which automatically enables the `|=` compound assignment operator for instances of that class.
For the assignment to be valid, the right operand must be of a type accepted by the left operand's `operator |` signature, and the resulting return type must be assignable back to the left operand's variable type.
```dart theme={"dark"}
class BitMask {
final int value;
BitMask(this.value);
// Overriding the | operator automatically enables |=
BitMask operator |(BitMask other) {
return BitMask(this.value | other.value);
}
}
void main() {
BitMask mask1 = BitMask(4); // Binary: 0100
BitMask mask2 = BitMask(2); // Binary: 0010
mask1 |= mask2;
print(mask1.value); // Outputs: 6 (Binary: 0110)
}
```
Tired of Poor Dart Skills? Fix That With Deep Grasping!
Learn More
