> ## 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 Left Shift Assignment
The `<<=` (Left Shift Assignment) operator performs a bitwise left shift on its left operand by the number of bits specified by its right operand, and assigns the computed result back to the left operand.
```typescript theme={"dark"}
x <<= y;
// Equivalent to: x = x << y;
```
## Execution Mechanics
When evaluating `x <<= y`, TypeScript (inheriting from JavaScript's ECMAScript specification) processes the operation based on the underlying types of the operands.
### For `number` Types
1. **Type Conversion (`ToInt32`):** Both `x` and `y` are implicitly coerced into 32-bit signed integers using two's complement representation. Any fractional components are discarded.
2. **Shift Masking:** The right operand `y` is masked to 5 bits using a bitwise AND operation (`y & 0x1F`). Consequently, the actual shift amount is strictly between 0 and 31. This is fundamentally different from the remainder operator (`%`), as negative shift amounts are safely masked to positive values (e.g., `-1 & 0x1F` evaluates to `31`, whereas `-1 % 32` evaluates to `-1`).
3. **Bit Manipulation:** The bits of `x` are shifted to the left by the evaluated shift amount.
4. **Zero-Filling:** Vacated bit positions on the right are filled with `0`s.
5. **Truncation:** Any bits shifted beyond the 32-bit boundary on the left are permanently discarded.
6. **Sign Mutation:** Because the 32nd bit (Most Significant Bit) dictates the sign in two's complement, shifting a `1` into this position will mutate a positive integer into a negative integer.
```typescript theme={"dark"}
let a: number = 5; // Binary: 00000000 00000000 00000000 00000101
a <<= 2; // Binary: 00000000 00000000 00000000 00010100
console.log(a); // Output: 20
let b: number = 1; // Binary: 00000000 00000000 00000000 00000001
b <<= 31; // Binary: 10000000 00000000 00000000 00000000 (MSB is 1)
console.log(b); // Output: -2147483648
let c: number = 10;
c <<= 33; // 33 & 0x1F = 1. Equivalent to c <<= 1.
console.log(c); // Output: 20
let d: number = 10; // Binary: ...00001010
d <<= -1; // -1 & 0x1F = 31. Equivalent to d <<= 31.
// The '1' bits overflow past the 32-bit boundary and are truncated.
// The 0th bit ('0') shifts into the 31st position.
console.log(d); // Output: 0
```
### For `bigint` Types
When both operands are of type `bigint`, the operator behaves differently:
1. **Arbitrary Precision:** The left operand is treated as an integer of arbitrary size. It is **not** truncated to 32 bits.
2. **No Shift Masking:** The right operand is **not** masked to 5 bits. You can shift by amounts greater than 31.
3. **Negative Shift Amounts:** Unlike `number` types, shifting a `bigint` by a negative amount is an invalid operation. Attempting to do so (e.g., `bigX <<= -1n`) will throw a runtime `RangeError` ("Right-hand side of 'shift left' operation must be non-negative").
4. **Type Strictness:** TypeScript enforces that both operands must be `bigint`. Mixing `number` and `bigint` with `<<=` will result in a compiler error (`TS2365`).
```typescript theme={"dark"}
let bigX: bigint = 5n;
bigX <<= 32n; // Shifts by exactly 32 bits, no masking applied
console.log(bigX); // Output: 21474836480n
// TypeScript Error: Operator '<<=' cannot be applied to types 'bigint' and 'number'.
// bigX <<= 2;
let bigY: bigint = 5n;
// bigY <<= -1n; // Throws runtime RangeError: Right-hand side of 'shift left' operation must be non-negative
```
## Mathematical Equivalence
For `number` types, assuming no 32-bit overflow occurs, `x <<= y` is mathematically equivalent to:
`x = x * (2 ** y)`
Tired of Poor TypeScript Skills? Fix That With Deep Grasping!
Learn More
