Signatur
Beschreibung
Der bitweise XOR-Operator (^) vergleicht zwei Operanden Bit für Bit und setzt das jeweilige Ergebnisbit auf 1, wenn die entsprechenden Bits der Operanden verschieden sind (d. h. genau eines ist 1, das andere 0). Sind beide Bits gleich (0/0 oder 1/1), ist das Ergebnisbit 0. Diese Logik wird „exklusives Oder" (XOR) genannt.
Zahlen vom Typ number werden vor der Operation intern in 32-Bit-Ganzzahlen mit Vorzeichen (Two's-Complement) umgewandelt; das Ergebnis ist wieder ein regulärer JavaScript-number-Wert. Bei BigInt-Operanden operiert ^ direkt auf der vollen Bitbreite ohne Trunkierung. Gemischte Typen (number ^ BigInt) werfen einen TypeError.
Typische Einsatzbereiche sind Bit-Flags (ein einzelnes Flag umschalten), Vertauschen von Integer-Werten ohne Hilfsvariable, einfache Checksummen/Hash-Berechnungen sowie Verschlüsselungsalgorithmen (z. B. XOR-Cipher). Außerdem lässt sich mit n ^ 1 elegant zwischen 0 und 1 wechseln.
Zu beachten ist, dass der ^-Operator nicht der Potenzierungsoperator ist — dafür steht **. Außerdem sollte man ihn nicht mit dem logischen XOR verwechseln, das in JavaScript kein eigenes Symbol hat (stattdessen nutzt man !!(a) !== !!(b)).
Parameter
| Name | Typ | Default | Beschreibung |
|---|---|---|---|
| $a Pflicht | number | bigint | — | Linker Operand. number-Werte werden auf eine 32-Bit-Ganzzahl mit Vorzeichen reduziert; BigInt-Werte werden direkt bitweise verarbeitet. |
| $b Pflicht | number | bigint | — | Rechter Operand. Muss denselben Typ wie a haben — eine Mischung aus number und BigInt wirft einen TypeError. |
Rückgabewert
number) bzw. ein BigInt, dessen Bits überall dort 1 sind, wo sich die Operandenbits unterscheiden.Beispiele
Grundlegende Bit-Operationen
// Binär: 0101 (5)
// ^ 0011 (3)
// = 0110 (6)
console.log(5 ^ 3); // 6
console.log(0b1111 ^ 0b0101); // 10 (0b1010)
console.log(0xFF ^ 0x0F); // 240 (0xF0)
console.log(-1 ^ 0); // -1 (alle Bits bleiben gesetzt)Bit-Flag umschalten
const FLAG_READ = 0b0001; // 1
const FLAG_WRITE = 0b0010; // 2
const FLAG_EXECUTE = 0b0100; // 4
let permissions = FLAG_READ | FLAG_WRITE; // 3 (0b0011)
// WRITE-Flag umschalten (an → aus):
permissions ^= FLAG_WRITE;
console.log(permissions.toString(2)); // '1' → nur READ
// WRITE-Flag erneut umschalten (aus → an):
permissions ^= FLAG_WRITE;
console.log(permissions.toString(2)); // '11' → READ + WRITEZwei Zahlen ohne Hilfsvariable tauschen
let x = 42;
let y = 17;
x ^= y;
y ^= x;
x ^= y;
console.log(x, y); // 17 42BigInt-Unterstützung und TypeError-Falle
// BigInt XOR — volle Bitbreite, kein 32-Bit-Limit
const a = 0xDEADBEEFn ^ 0x0F0F0F0Fn;
console.log(a.toString(16)); // 'd1a2b1e0'
// Gemischte Typen werfen einen TypeError
try {
console.log(5 ^ 3n);
} catch (e) {
console.error(e instanceof TypeError, e.message);
}// Wichtig · Fallstricke
32-Bit-Trunkierung: Alle number-Operanden werden intern mit ToInt32() konvertiert. Werte außerhalb von −2 147 483 648 bis 2 147 483 647 sowie Gleitkommazahlen werden dabei abgeschnitten: 2.9 ^ 0 ergibt 2, nicht 3.
Kein logisches XOR: ^ arbeitet auf Bit-Ebene. Für ein logisches „exklusives Oder" auf Wahrheitswerten verwendet man !!(a) !== !!(b).
Nicht mit Potenzierung verwechseln: Der Potenzierungsoperator in JavaScript lautet ** (z. B. 2 ** 8 === 256), nicht ^ wie in manchen anderen Sprachen.
Performance: Bitweise Operatoren sind in modernen JS-Engines sehr schnell und eignen sich für enge Schleifen, in denen Zahlen als Bit-Masken genutzt werden. Für allgemeine Arithmetik mit großen Zahlen ist BigInt vorzuziehen, da es die 32-Bit-Grenze überwindet.