Signatur
Beschreibung
Der Linksverschiebungsoperator (<<) ist ein binärer bitweiser Operator, der die Bits des linken Operanden a um die durch b angegebene Anzahl von Stellen nach links verschiebt. Jede verschobene Stelle entspricht einer Multiplikation mit 2, sodass x << n äquivalent zu x * 2n ist – solange kein Überlauf entsteht.
Beide Operanden werden vor der Operation intern in vorzeichenbehaftete 32-Bit-Integer umgewandelt (ToInt32). Das Ergebnis ist ebenfalls ein vorzeichenbehafteter 32-Bit-Integer. Von b werden nur die untersten 5 Bits ausgewertet (Werte 0–31), ein Schiebeweite von 32 oder mehr wird also auf den Modulo-32-Wert reduziert.
Der Operator eignet sich besonders für Performance-optimierte Ganzzahlarithmetik, Bitmasken und Flags. Typische Anwendungsfälle sind das Setzen einzelner Bits in einem Flags-Register, schnelle Potenzen-von-2-Multiplikationen oder die Kodierung mehrerer Werte in eine einzige Zahl (Bit-Packing).
Zu beachten ist, dass der Operator ausschließlich auf 32-Bit-Ebene arbeitet. Werte außerhalb des Bereichs –2 147 483 648 bis 2 147 483 647 werden abgeschnitten. Für sehr große Zahlen sollte stattdessen BigInt in Kombination mit dem gleichen Operator verwendet werden, da BigInt-Varianten beliebig breite Verschiebungen unterstützen.
Parameter
| Name | Typ | Default | Beschreibung |
|---|---|---|---|
| $a Pflicht | number | bigint | — | Der Wert, dessen Bits nach links verschoben werden sollen. Wird intern in einen vorzeichenbehafteten 32-Bit-Integer (bzw. BigInt) umgewandelt. |
| $b Pflicht | number | bigint | — | Anzahl der Bit-Positionen, um die verschoben wird. Nur die untersten 5 Bits (0–31) werden ausgewertet; bei BigInt muss die Schiebeweite nicht-negativ sein. |
Rückgabewert
number) bzw. als BigInt, wenn beide Operanden BigInt sind.Beispiele
Grundlegende Linksverschiebung
// 1 in Binär: 00000000 00000000 00000000 00000001
// Nach 3 Stellen links: 00000000 00000000 00000000 00001000 = 8
console.log(1 << 3); // 8
console.log(5 << 1); // 10 (5 * 2)
console.log(5 << 2); // 20 (5 * 4)
console.log(1 << 0); // 1 (keine Verschiebung)Bit-Flags mit Linksverschiebung setzen und prüfen
// Berechtigungen als Bit-Flags
const LESEN = 1 << 0; // 0001 = 1
const SCHREIBEN = 1 << 1; // 0010 = 2
const AUSFUEHREN = 1 << 2; // 0100 = 4
const berechtigungen = LESEN | SCHREIBEN; // 0011 = 3
const kannLesen = (berechtigungen & LESEN) !== 0;
const kannSchreiben = (berechtigungen & SCHREIBEN) !== 0;
const kannAusfuehren = (berechtigungen & AUSFUEHREN) !== 0;
console.log(`Lesen: ${kannLesen}`);
console.log(`Schreiben: ${kannSchreiben}`);
console.log(`Ausführen: ${kannAusfuehren}`);Schnelle Multiplikation mit Potenzen von 2
const verdoppeln = x => x << 1;
const vervierfachen = x => x << 2;
const mal256 = x => x << 8;
console.log(verdoppeln(7)); // 14
console.log(vervierfachen(3)); // 12
console.log(mal256(1)); // 256Linksverschiebung mit BigInt
// BigInt erlaubt Verschiebungen über 31 Stellen hinaus
const gross = 1n << 40n;
console.log(gross); // 1099511627776n
console.log(typeof gross); // bigint// Wichtig · Fallstricke
32-Bit-Beschränkung: Da beide Operanden (bei number) intern in vorzeichenbehaftete 32-Bit-Integer umgewandelt werden, gehen Bits oberhalb von Bit 31 verloren. 2147483647 << 1 ergibt z. B. -2 (Überlauf).
- Schiebeweite ≥ 32: Nur die untersten 5 Bits der Schiebeweite werden verwendet —
x << 32ist also identisch mitx << 0. - Gemischte Typen:
numberundBigIntkönnen nicht gemischt werden.1 << 2nwirft einenTypeError. - Negative Schiebeweiten bei BigInt: Eine negative Schiebeweite ist bei
BigIntnicht erlaubt und führt zu einemRangeError. Für Rechtsverschiebung bei BigInt den Operator>>verwenden. - Performance: In modernen JavaScript-Engines sind Bit-Operationen auf
numberoft schneller als allgemeine arithmetische Operationen, da die Engine intern direkt mit 32-Bit-Integern arbeiten kann.