Start · Sprachen · JavaScript · Referenz · Bitweises OR-Zuweisung (|=)

Bitweises OR-Zuweisung (|=)

Operator

Der <code>|=</code>-Operator führt ein bitweises OR auf zwei Operanden aus und weist das Ergebnis dem linken Operanden zu.

seit JavaScript ES1 Kategorie: syntax

Signatur

x |= y

Beschreibung

Der bitweise OR-Zuweisungsoperator (|=) ist eine Kurzschreibweise für x = x | y. Er verknüpft die 32-Bit-Ganzzahl-Darstellungen beider Operanden per bitweisem OR: Jedes Bit des Ergebnisses ist 1, wenn mindestens eines der entsprechenden Bits der beiden Operanden 1 ist.

Intern konvertiert JavaScript beide Operanden zunächst in vorzeichenbehaftete 32-Bit-Ganzzahlen (Int32). Dezimalzahlen, Strings oder andere Typen werden dabei automatisch in Ganzzahlen umgewandelt – Nachkommastellen werden abgeschnitten. Das Ergebnis ist stets eine vorzeichenbehaftete 32-Bit-Ganzzahl, die als normaler JavaScript-number-Wert zurückgegeben wird.

Typische Anwendungsfälle sind das gezielte Setzen einzelner Bits in einem Flags-Register oder Bitmask-System, z. B. um Berechtigungen, Zustände oder Optionen kompakt in einer einzigen Ganzzahl zu speichern. Durch Kombination mehrerer Bit-Flags mit |= lassen sich mehrere Zustände gleichzeitig aktivieren.

Für boolesche Werte funktioniert |= ebenfalls, verhält sich jedoch nicht wie der logische ||=-Operator: Es wird kein Short-Circuit-Verhalten angewendet, und das Ergebnis ist 0 oder 1 (Zahl), nicht true/false. Soll stattdessen ein logisches OR mit Kurzschlussauswertung verwendet werden, ist ||= die richtige Wahl.

Parameter

Name Typ Default Beschreibung
$x Pflicht number | bigint Linker Operand und Zuweisungsziel. Wird in eine vorzeichenbehaftete 32-Bit-Ganzzahl konvertiert (bei BigInt-Werten wird die BigInt-Variante des Operators verwendet).
$y Pflicht number | bigint Rechter Operand. Wird ebenfalls in eine vorzeichenbehaftete 32-Bit-Ganzzahl konvertiert und bitweise OR-verknüpft mit x.

Rückgabewert

Typ
number | bigint
Beschreibung
Der neue Wert von x nach dem bitweisen OR. Bei regulären Zahlen stets eine vorzeichenbehaftete 32-Bit-Ganzzahl als number; bei BigInt-Operanden ein BigInt.

Beispiele

Einzelne Bits in einem Flags-Register setzen

// Bitmask-Konstanten für Benutzerrechte
const READ    = 0b0001; // 1
const WRITE   = 0b0010; // 2
const EXECUTE = 0b0100; // 4

let permissions = 0b0000; // Keine Rechte

// Lese- und Schreibrecht hinzufügen
permissions |= READ;
permissions |= WRITE;

console.log(permissions.toString(2)); // "11"  (READ + WRITE aktiv)
console.log(permissions);             // 3

// Ausführungsrecht ebenfalls hinzufügen
permissions |= EXECUTE;
console.log(permissions.toString(2)); // "111" (alle drei Rechte)
console.log(permissions);             // 7
"11" 3 "111" 7

Mehrere Feature-Flags auf einmal setzen

const DARK_MODE    = 1 << 0; // Bit 0
const NOTIFICATIONS = 1 << 1; // Bit 1
const AUTO_SAVE    = 1 << 2; // Bit 2
const ANALYTICS    = 1 << 3; // Bit 3

let userSettings = 0;

// Dunkelmodus und automatisches Speichern aktivieren
userSettings |= DARK_MODE | AUTO_SAVE;
console.log(userSettings.toString(2)); // "101"  → Bit 0 und Bit 2 gesetzt

// Prüfen ob ein bestimmtes Flag gesetzt ist
const hasDarkMode = (userSettings & DARK_MODE) !== 0;
console.log(hasDarkMode); // true

// Erneutes Setzen eines bereits gesetzten Bits ändert nichts
userSettings |= DARK_MODE;
console.log(userSettings.toString(2)); // "101"  → unverändert
"101" true "101"

Verhalten mit nicht-ganzzahligen und nicht-numerischen Werten

let a = 5.9;
a |= 2;
console.log(a); // 7  → 5.9 wird zu 5 (0101), OR mit 2 (0010) = 7 (0111)

let b = '12'; // String
b |= 1;
console.log(b); // 13 → '12' wird zu 12 (1100), OR mit 1 (0001) = 13 (1101)

let c = null;
c |= 8;
console.log(c); // 8  → null wird zu 0 (0000), OR mit 8 (1000) = 8
7 13 8

// Wichtig · Fallstricke

Kein Short-Circuit: Im Gegensatz zum logischen OR-Zuweisungsoperator (||=) wertet |= den rechten Operanden immer aus, unabhängig vom Wert des linken Operanden. Seiteneffekte auf der rechten Seite werden daher stets ausgeführt.

  • 32-Bit-Begrenzung: Werte außerhalb des Int32-Bereichs (−2 147 483 648 bis 2 147 483 647) werden vor der Verknüpfung abgeschnitten. Für größere Ganzzahlen müssen BigInt-Werte verwendet werden (1n |= 2n).
  • Kein Einsatz für boolesche Logik: Das Ergebnis von |= ist stets 0 oder eine Ganzzahl – niemals ein echter Boolean. Für boolesche OR-Zuweisung ist ||= zu bevorzugen.
  • Browser-Kompatibilität: |= ist seit ES1 Teil der Sprache und in allen relevanten Umgebungen (Browser, Node.js, Deno) ohne Einschränkungen verfügbar.
  • BigInt-Mischung verboten: Ein number-Wert kann nicht direkt mit einem BigInt per |= verknüpft werden – das wirft einen TypeError.