Right shift assignment (>>=) — Operator · JavaScript-Referenz

Signatur

x >>= y

Beschreibung

Der Operator >>= ist eine Kurzschreibweise für x = x >> y. Er führt zunächst eine vorzeichenbehaftete Rechtsverschiebung (signed right shift) des linken Operanden x um y Bit-Positionen nach rechts durch und speichert das Ergebnis direkt wieder in x.

Bei der vorzeichenbehafteten Rechtsverschiebung werden die herausfallenden Bits von rechts verworfen. Von links werden Kopien des Vorzeichenbits (MSB – Most Significant Bit) nachgeschoben, sodass das Vorzeichen negativer Zahlen erhalten bleibt. Dadurch unterscheidet sich >>= grundlegend vom vorzeichenlosen Rechtsverschiebungsoperator >>>=, bei dem stets Nullen von links eingeschoben werden.

Beide Operanden werden intern zu 32-Bit-Ganzzahlen mit Vorzeichen (Int32) konvertiert. Nur die unteren 5 Bits des rechten Operanden werden als Verschiebungsweite genutzt (Bereich 0–31). Ein Verschiebewert von 0 bewirkt effektiv keine Verschiebung, gibt aber dennoch die Int32-Konvertierung des linken Operanden zurück.

>>= wird typisch in Low-Level-Berechnungen, Bitfeld-Auswertungen, Bildverarbeitung, Protokoll-Parsing oder Performance-kritischen Divisionen durch Zweierpotenzen eingesetzt (z. B. n >>= 1 halbiert eine ganze Zahl, ohne Math.floor aufzurufen).

Parameter

Name	Typ	Default	Beschreibung
$x Pflicht	number \| bigint	—	Der linke Operand (Zieldvariable). Sein Wert wird bitweise nach rechts verschoben. Bei regulären Zahlen wird er in ein Int32 konvertiert; `BigInt`-Werte werden nativ verarbeitet.
$y Pflicht	number \| bigint	—	Die Verschiebungsweite in Bit-Positionen. Bei regulären Zahlen werden nur die unteren 5 Bits berücksichtigt (0–31). Bei `BigInt`-Operanden kann die Verschiebungsweite beliebig groß sein; ein negativer Wert entspricht einer Linksverschiebung.

Rückgabewert

Typ

number | bigint

Beschreibung

Das Ergebnis der Rechtsverschiebung als 32-Bit-Ganzzahl mit Vorzeichen (oder als BigInt, falls beide Operanden BigInt sind). Der Wert wird gleichzeitig x zugewiesen.

Beispiele

Grundlegende Verwendung mit positiven Zahlen

let a = 64;   // Binär: 00000000 00000000 00000000 01000000
a >>= 2;      // Verschiebt 2 Stellen nach rechts → 00000000 00000000 00000000 00010000
console.log(a); // 16

let b = 256;
b >>= 4;      // 256 / 2^4 = 16
console.log(b); // 16

16 16

Vorzeichen bleibt erhalten (negative Zahlen)

let n = -128;  // Binär (Int32): 11111111 11111111 11111111 10000000
n >>= 2;       // → 11111111 11111111 11111111 11100000 (-32)
console.log(n); // -32

// Vergleich: vorzeichenloser Shift würde eine positive Zahl liefern
let m = -128;
m >>>= 2;
console.log(m); // 1073741792 (Vorzeichen-Bit wird als normales Bit behandelt)

-32 1073741792

Schnelle Division durch Zweierpotenz (Performance-Trick)

// >>= 1 entspricht Math.floor(x / 2) für Ganzzahlen
const items = [100, 75, 32, 17, 9];
const halved = items.map(n => {
  let v = n;
  v >>= 1;
  return v;
});
console.log(halved); // [50, 37, 16, 8, 4]

[50, 37, 16, 8, 4]

Farb-Kanal aus einem 32-Bit-Farbwert extrahieren

// ARGB-Wert: 0xFF_AA_BB_CC
let color = 0xFFAABBCC;

// Grün-Kanal extrahieren (Bits 8–15)
let green = (color >> 8) & 0xFF;
console.log(green.toString(16)); // 'bb'

// Rotation mit >>= in einer Schleife (z.B. Checksummen-Berechnung)
let checksum = 0b11001010_11110000_10101010_01010101;
for (let i = 0; i < 4; i++) {
  checksum >>= 4;
}
console.log(checksum.toString(2)); // Wert nach 16-Bit-Verschiebung

bb

Verwendung mit BigInt

let big = 1024n;
big >>= 3n;
console.log(big); // 128n

let negativeBig = -256n;
negativeBig >>= 2n;
console.log(negativeBig); // -64n

128n -64n

// Wichtig · Fallstricke

Mischtypen verboten: Man darf nicht einen number- und einen BigInt-Operanden mischen — das wirft einen TypeError.

Nur 5 Bits der Verschiebungsweite: Bei normalen Zahlen werden nur die unteren 5 Bits von y ausgewertet. x >>= 32 entspricht damit x >>= 0 und lässt x (als Int32) unverändert.
Int32-Konvertierung: Fließkommazahlen werden vor der Operation zu einer vorzeichenbehafteten 32-Bit-Ganzzahl abgeschnitten (nicht gerundet). 1.9 >>= 0 ergibt 1.
Kein Operator-Chaining mit anderen Zuweisungen: a >>= b >>= c wertet von rechts nach links aus — also zuerst b >>= c, dann a >>= (Ergebnis). Das kann zu unerwarteten Ergebnissen führen.
Unterschied zu >>>=: Der vorzeichenlose Rechtsverschiebungs-Zuweisungsoperator schiebt stets Nullen von links ein, was bei negativen Zahlen zu einem völlig anderen (sehr großen positiven) Ergebnis führt.

Siehe auch

Right shift (>>) Unsigned right shift assignment (>>>=) Left shift assignment (<<=) Bitwise AND assignment (&=) Bitwise OR assignment (|=) Bitwise XOR assignment (^=)