Bitweises UND (&) — Operator · JavaScript-Referenz

Signatur

a & b

Beschreibung

Der bitweise UND-Operator (&) vergleicht zwei Werte Bit für Bit. Das Ergebnis-Bit ist genau dann 1, wenn beide korrespondierenden Bits der Operanden ebenfalls 1 sind — andernfalls ist es 0. Zahlen vom Typ number werden dabei intern als 32-Bit-Ganzzahlen mit Vorzeichen (Two's-Complement) behandelt; das Ergebnis ist stets ein 32-Bit-Integer.

Typische Anwendungsfälle sind das Maskieren von Bits (einzelne Flags prüfen), das Löschen von Bits (bestimmte Stellen auf 0 setzen) sowie schnelle Ganzzahl-Konvertierungen (z. B. n & -1 als Äquivalent zu Math.trunc(n) für 32-Bit-Werte). Der Operator eignet sich auch hervorragend für einfache Paritätsprüfungen, z. B. zahl & 1, um festzustellen, ob eine Zahl gerade oder ungerade ist.

Wird einer oder beide Operanden als BigInt übergeben, arbeitet der Operator im BigInt-Modus — es findet keine Konvertierung in 32 Bit statt und das Ergebnis ist ein BigInt. Das Mischen von number und BigInt wirft einen TypeError.

Der &-Operator ist nicht mit dem logischen UND-Operator && zu verwechseln, der Kurzschlussauswertung (Short-Circuit) durchführt und einen der Operanden selbst zurückgibt, statt ein bitweises Ergebnis zu berechnen.

Parameter

Name	Typ	Default	Beschreibung
$a Pflicht	number \| bigint	—	Linker Operand. Bei `number`-Werten wird er in einen 32-Bit-Integer konvertiert.
$b Pflicht	number \| bigint	—	Rechter Operand. Muss denselben Typ wie `a` haben (`number` oder `bigint`); Mischtypen werfen einen `TypeError`.

Rückgabewert

Typ

number | bigint

Beschreibung

Ein 32-Bit-Integer (bei number-Operanden) oder ein BigInt (bei bigint-Operanden), dessen Bits an jeder Stelle 1 sind, wo beide Operanden eine 1 haben.

Beispiele

Grundlegendes Bitmuster-Beispiel

// Binär:  1010 (10)
//       & 1100 (12)
//       = 1000  (8)
const a = 10;  // 0b1010
const b = 12;  // 0b1100
console.log(a & b); // 8 (0b1000)

8

Gerade / Ungerade prüfen (Bit-Masking)

const isOdd = (n) => (n & 1) === 1;

console.log(isOdd(7));   // true  — 0b0111 & 0b0001 = 1
console.log(isOdd(42));  // false — 0b101010 & 0b000001 = 0

true false

Bit-Flags prüfen

const FLAG_READ    = 0b0001; // 1
const FLAG_WRITE   = 0b0010; // 2
const FLAG_EXECUTE = 0b0100; // 4

// Benutzer hat Lese- und Schreibrechte
const permissions = FLAG_READ | FLAG_WRITE; // 0b0011 = 3

const canRead    = (permissions & FLAG_READ)    !== 0;
const canWrite   = (permissions & FLAG_WRITE)   !== 0;
const canExecute = (permissions & FLAG_EXECUTE) !== 0;

console.log(canRead);    // true
console.log(canWrite);   // true
console.log(canExecute); // false

true true false

Verwendung mit BigInt

const x = 0b1111_0000n; // BigInt
const mask = 0b1010_1010n;
console.log(x & mask); // 0b1010_0000n = 160n

160n

// Wichtig · Fallstricke

32-Bit-Beschränkung bei number: Beide Operanden werden vor der Operation mit ToInt32 in vorzeichenbehaftete 32-Bit-Ganzzahlen umgewandelt. Zahlen außerhalb des Bereichs −2 147 483 648 bis 2 147 483 647 werden abgeschnitten. Gleitkommazahlen verlieren ihren Nachkommateil (z. B. 5.9 & 3.1 ergibt 1).

Typfehler vermeiden: 5n & 5 wirft einen TypeError — nie number und bigint mischen.
Nicht mit && verwechseln: && ist der logische UND-Operator mit Short-Circuit-Semantik; & wertet stets beide Operanden aus.
Performance: Bitweise Operationen sind in modernen JS-Engines sehr schnell, ihr Einsatz als „Optimierungstrick" (z. B. ~~x statt Math.trunc) ist aber in der Regel nicht notwendig und beeinträchtigt die Lesbarkeit.
Negative Zahlen: Da 32-Bit-Two's-Complement verwendet wird, kann -1 & x überraschend wirken — -1 ist binär 1111...1111 (alle 32 Bits gesetzt), sodass -1 & x immer x (als 32-Bit-Integer) ergibt.

Siehe auch

Bitweises ODER (|) Bitweises XOR (^) Bitweise Negation (~) Bitweises UND-Zuweisung (&=) Logisches UND (&&) Left Shift (<<) Right Shift (>>)