Start · Sprachen · JavaScript · Referenz · Left shift assignment (<<=)

Left shift assignment (<<=)

Operator

Der <code>&lt;&lt;=</code>-Operator verschiebt die Bits eines Wertes um <code>y</code> Stellen nach links und weist das Ergebnis der Variablen zu.

seit JavaScript ES2015 Kategorie: syntax

Signatur

x <<= y

Beschreibung

Der Left Shift Assignment-Operator (<<=) ist eine Kurzform für die Kombination aus bitweiser Linksverschiebung (<<) und Zuweisung. Die Anweisung x <<= y ist gleichbedeutend mit x = x << y. Dabei werden die Bits des Operanden x um y Stellen nach links verschoben; von rechts werden entsprechend viele Nullen eingeschoben. Bits, die über den 32-Bit-Bereich hinausgeschoben werden, gehen verloren.

Intern arbeitet der Operator mit 32-Bit-Ganzzahlen mit Vorzeichen (Two's Complement). Beide Operanden werden zunächst in 32-Bit-Integer konvertiert, dann wird das Ergebnis als JavaScript-Zahl (number) zurückgegeben. Eine Linksverschiebung um n Stellen entspricht einer Multiplikation mit 2n, solange kein Überlauf auftritt — was ihn zu einem schnellen Werkzeug für Zweierpotenzen macht.

Typische Einsatzgebiete sind Low-Level-Bitoperationen, Flags und Masken in Systemprogrammierung, Encoding/Decoding von Farbwerten (z. B. RGB), sowie performancekritischer Code, bei dem Multiplikationen durch Zweierpotenzen ersetzt werden sollen.

Der Operator verändert die Variable direkt (in place) und gibt den neuen Wert zurück. Er sollte nur bei ganzzahligen Werten eingesetzt werden; Fließkommazahlen werden vor der Operation zu einer 32-Bit-Ganzzahl gestutzt, was zu überraschenden Ergebnissen führen kann.

Parameter

Name Typ Default Beschreibung
$x Pflicht number | bigint Die Variable, deren Wert nach links verschoben und aktualisiert wird. Muss ein gültiger Zuweisungsziel-Ausdruck (L-Value) sein.
$y Pflicht number | bigint Die Anzahl der Bit-Positionen, um die nach links verschoben wird. Nur die unteren 5 Bits (0–31) werden berücksichtigt; höhere Bits werden ignoriert. Bei BigInt gibt es keine 32-Bit-Beschränkung.

Rückgabewert

Typ
number | bigint
Beschreibung
Der neue Wert von x nach der bitweisen Linksverschiebung um y Stellen.

Beispiele

Einfache Linksverschiebung

let flags = 0b0001; // 1
flags <<= 3;         // entspricht: flags = flags << 3
console.log(flags);          // 8
console.log(flags.toString(2)); // "1000"
8 1000

Schnelle Multiplikation mit Zweierpotenz

let value = 5;
value <<= 2; // 5 * 4 = 20
console.log(value); // 20

value <<= 1; // 20 * 2 = 40
console.log(value); // 40
20 40

RGB-Farbwert zusammensetzen

// Einen 24-Bit-Farbwert aus R, G, B bauen
const r = 255, g = 128, b = 64;

let color = r;
color <<= 8;
color |= g;
color <<= 8;
color |= b;

console.log(color.toString(16).toUpperCase()); // "FF8040"
FF8040

Überlauf bei Linksverschiebung

let n = 1;
n <<= 31;
console.log(n); // -2147483648 (Vorzeichenbit gesetzt)

n <<= 1;
console.log(n); // 0  (Bit komplett herausgeschoben)
-2147483648 0

// Wichtig · Fallstricke

32-Bit-Beschränkung: JavaScript konvertiert beide Operanden intern in 32-Bit-Ganzzahlen mit Vorzeichen. Werte außerhalb des Bereichs −2 147 483 648 bis 2 147 483 647 werden abgeschnitten. Das 31. Bit gilt als Vorzeichen-Bit.

Verschiebebereich: Der rechte Operand y wird automatisch auf den Bereich 0–31 beschränkt (y & 0x1F). Eine Angabe von 32 oder höher entspricht damit einer Verschiebung um y % 32.

Fließkommazahlen: Vor der Operation werden Fließkommazahlen per ToInt32-Algorithmus in 32-Bit-Integer umgewandelt — der Nachkommaanteil wird verworfen. 3.9 <<= 1 ergibt 6, nicht 7.

BigInt: Ab ES2020 unterstützt <<= auch BigInt-Werte. Es dürfen dabei keine gemischten Typen (BigInt und number) verwendet werden, da sonst ein TypeError geworfen wird.