Bitweise Operationen erklärt: AND, OR, XOR, Shifts und Masken
Du öffnest eine alte PostgreSQL-Migration und siehst permissions & 0b100. Eine Kollegin rollt ein Feature-Flag-System aus, das 32 Booleans in einen einzigen Integer packt. Eine Kubernetes-Subnetzberechnung liefert 192.168.1.0/24, und du musst die Netzadresse im Code extrahieren. Drei Situationen, eine Fähigkeit dahinter: bitweise Operationen.
Die meisten Application-Layer-Entwickler greifen in einer Webapp nie zu & oder ^, bis sie es plötzlich müssen. Dieser Leitfaden zeigt die sechs bitweisen Operatoren, das Zweierkomplement, neun Muster, die sich zu merken lohnen, und die sprachspezifischen Fallen (besonders in JavaScript). Code in JS, Python, Go und C, jedes Beispiel lauffähig.
Öffne unseren Zahlensystem-Konverter am besten in einem weiteren Tab. Mehrere Abschnitte fordern dich auf, eine Zahl einzugeben und das Bitmuster live zu beobachten.
Warum bitweise Operationen 2026 noch wichtig sind
Hochsprachen haben bitweise Operationen nicht überflüssig gemacht, sondern nur versteckt, wo sie stattfinden. Einige Stellen, an denen du dich heute darauf verlässt, bewusst oder nicht:
- PostgreSQL Row-Level Security speichert ACL-Privilegien (
SELECT,INSERT,UPDATE,DELETE, …) als Bitmap in einem Integer. - Linux Capabilities ersetzen das alte Root-oder-nichts-Modell durch über 40 Permission-Bits, die mit
|kombiniert werden. - JWT-Algorithmus-Header kodieren das Hash-Verfahren in einem kleinen Feld, in dem Bibliotheken auf Bitebene vergleichen.
- Snowflake, ULID und UUIDv7 packen Zeitstempel, Maschinen-ID und Sequenznummer via Linksshift in einen 64- oder 128-Bit-Integer.
BITCOUNTundBITOPin Redis stellen bitweise Primitive direkt für Application-Code bereit, etwa für Kardinalitätsschätzungen und A/B-Bucketing.- Bildverarbeitung liest 32-Bit-RGBA-Pixel und extrahiert Kanäle mit
&und>>.
Bitweise Operationen bleiben auf CPU-Instruktionsebene O(1). 32 Booleans in einen Integer zu packen spart 31 Byte Speicher, und noch wichtiger: Du kannst „ist irgendeines dieser 32 Flags gesetzt?” mit einem einzigen != 0-Test beantworten.
Binär-Grundlagen, die du zuerst brauchst
Dieser Leitfaden setzt voraus, dass du Binärdarstellung verstehst. Falls du eine Auffrischung brauchst, lies zuerst unseren Guide zur Zahlensystemumrechnung und komm zurück.
Kurzer Vokabelcheck vorab:
- Ein Bit ist 0 oder 1.
- Ein Nibble sind 4 Bits (eine Hexadezimalstelle).
- Ein Byte sind 8 Bits.
- Ein Wort ist je nach CPU typischerweise 32 oder 64 Bits.
Integer haben in den meisten Sprachen feste Breiten: 8, 16, 32, 64. Die Breite ist für bitweise Operationen wichtig, weil Shifts Bits über den Rand hinausschieben können und das Vorzeichenbit bei signed Integers ganz links sitzt.
Probier es gleich aus: Öffne den Zahlensystem-Konverter, gib 170 dezimal ein und schau auf die Binärausgabe. Du solltest 10101010 sehen, ein abwechselndes Muster, auf das wir mehrfach zurückkommen.
Die sechs bitweisen Operatoren
Jede Mainstream-Sprache bietet dieselben sechs Operatoren, mit kleinen Syntaxunterschieden. Die Symbole &, |, ^, ~, <<, >> funktionieren in JavaScript, Python, Go, Rust, C, C++, Java und C# gleich. JavaScript hat zusätzlich >>>, den vorzeichenlosen Rechtsshift.
AND (&): Bit-Filter
Das Ergebnisbit ist nur dann 1, wenn beide Eingabebits 1 sind.
| A | B | A & B |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
Stell dir AND als Tor vor: Nur Bits, die in beiden Operanden gesetzt sind, überleben. Der häufigste Einsatz ist Maskieren, also bestimmte Bits behalten und den Rest auf null setzen.
// Untere 4 Bits (das rechte Nibble) extrahieren
const value = 0b11010110; // 214
const low4 = value & 0x0F; // 0b00000110 = 6
// Parität prüfen
const isOdd = (n) => (n & 1) === 1;
isOdd(7); // true
isOdd(42); // false# Gleich in Python
value = 0b11010110
low4 = value & 0x0F # 6
def is_odd(n):
return (n & 1) == 1OR (|): Bit-Setter
Das Ergebnisbit ist 1, wenn mindestens ein Eingabebit 1 ist.
| A | B | A | B |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 1 |
OR kombiniert Flags. Mit READ = 1, WRITE = 2, EXECUTE = 4 ergibt READ | WRITE den Wert 3, also beide Rechte aktiv.
const READ = 0b001;
const WRITE = 0b010;
const EXEC = 0b100;
const rw = READ | WRITE; // 0b011 = 3READ, WRITE, EXEC = 0b001, 0b010, 0b100
rw = READ | WRITE # 3XOR (^): Bit-Umschalter
Das Ergebnisbit ist 1, wenn sich die Eingabebits unterscheiden.
| A | B | A ^ B |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |
XOR hat drei algebraische Eigenschaften, die einige der cleversten Tricks der Informatik stützen:
a ^ a = 0: alles XOR mit sich selbst hebt sich auf.a ^ 0 = a: XOR mit null ist die Identität.a ^ b ^ a = b: XOR ist seine eigene Umkehrung.
Die letzte Eigenschaft erklärt, warum XOR überall auftaucht: von Paritätsprüfungen über Stromchiffren bis zur berüchtigten Interviewfrage „finde die einzige nicht verdoppelte Zahl im Array”.
// Die einzige Zahl finden, die sich nicht wiederholt
const findUnique = (arr) => arr.reduce((a, b) => a ^ b, 0);
findUnique([4, 1, 2, 1, 2]); // 4from functools import reduce
from operator import xor
find_unique = lambda arr: reduce(xor, arr, 0)
find_unique([4, 1, 2, 1, 2]) # 4NOT (~): Bit-Inverter
Unäres ~ kippt jedes Bit: 0 wird 1, 1 wird 0.
~0b00001111 // -16 (JavaScript erzwingt 32-Bit signed)
~5 // -6~5 # -6// Go nutzt ^ als unäres NOT, Symbol beachten
var x int8 = 5
fmt.Println(^x) // -6Dass ~5 in fast allen Mainstream-Sprachen -6 ergibt, überrascht Einsteiger. Der Grund ist das Zweierkomplement, das im nächsten Abschnitt folgt. Merk dir vorerst: In jeder Sprache, die negative Zahlen als Zweierkomplement darstellt (also allen wichtigen), gilt ~x = -(x + 1).
Linksshift (<<): Multiplizieren mit Zweierpotenzen
x << n schiebt alle Bits von x um n Positionen nach links und füllt rechts mit Nullen. Mathematisch multipliziert das mit 2ⁿ.
1 << 0 // 1 (2^0)
1 << 1 // 2 (2^1)
1 << 3 // 8 (2^3)
1 << 10 // 1024 (2^10 = 1 KiB)
// Flags aufbauen
const FLAG_ADMIN = 1 << 0;
const FLAG_EDITOR = 1 << 1;
const FLAG_REVIEWER = 1 << 2;Der Witz an 1 << n: Es erzeugt eine Zahl mit genau einem Bit an Position n. Dieses Bit wird zum Flag.
Vorsicht bei Überläufen. In JavaScript ist 1 << 31 gleich -2147483648 (nicht 2147483648), weil bitweise Operationen in JS auf 32-Bit signed Integers arbeiten.
Rechtsshift (>> vs. >>>): signiert oder nullgefüllt?
Rechtsshift bewegt Bits nach rechts. Frage: Was füllt die frei werdenden linken Positionen?
>>(arithmetischer Rechtsshift) behält das Vorzeichenbit. Negative Zahlen bleiben negativ.>>>(logischer oder vorzeichenloser Rechtsshift) füllt mit Nullen. Nur JavaScript hat dafür einen eigenen Operator.
-8 >> 1 // -4 (Vorzeichen erhalten)
-8 >>> 1 // 2147483644 (Vorzeichenbit als Datenbit behandelt)
8 >> 1 // 4
8 >> 2 // 2In C ist es für signed Types implementation-defined, ob >> arithmetisch oder logisch ist. Die meisten Compiler wählen arithmetisch, aber verlass dich nicht blind darauf. Go verlangt, dass die Shift-Menge ein unsigned Integer ist, und unterscheidet strikt zwischen signed und unsigned Types. Python hat kein >>>, weil es keine festen Breiten gibt.
Zweierkomplement: wie Rechner Negative speichern
Wenn Bits nur 0 und 1 sind, wie codiert man -5? Die Antwort, auf die sich die Welt in den 1960ern geeinigt hat, heißt Zweierkomplement, und jede moderne CPU nutzt es.
Der naive Ansatz, ein Bit für das Vorzeichen zu reservieren, hat zwei Probleme. Erstens bekommst du +0 und -0, was unschön ist. Zweitens müssten Additions- und Subtraktionsschaltungen das Vorzeichenbit prüfen, was die Hardware komplizierter macht. Zweierkomplement löst beides.
Die Regel ist kurz:
- Positive Binärdarstellung schreiben.
- Jedes Bit kippen (das ist das „Einerkomplement”).
- 1 addieren.
Beispiel: -5 als 8-Bit-Zweierkomplement codieren:
5 binär: 0000 0101
alle Bits kippen: 1111 1010 (das ist -6 im Zweierkomplement!)
1 addieren: 1111 1011 ← das ist -5Prüfe das mit unserem Konverter: Gib 251 (dezimal) in den Zahlensystem-Konverter ein, und die Binärausgabe ist 11111011. In einem 8-Bit-signed-Kontext ist 11111011 gleich -5. In 8-Bit unsigned ist dasselbe Bitmuster 251. Die Bits sind identisch, nur die Interpretation unterscheidet sich.
Damit löst sich die ~5 = -6-Verwirrung auf. Bitweises NOT invertiert alle Bits und liefert das Einerkomplement. Das Zweierkomplement ist Einerkomplement plus 1. Also:
~x = -(x + 1) // gilt in jeder Zweierkomplement-Sprache
~5 = -6
~(-3) = 2Für n-Bit signed Integer reicht der darstellbare Bereich von -2ⁿ⁻¹ bis 2ⁿ⁻¹ − 1. 8 Bit signed deckt -128 bis 127, 32 Bit signed etwa -2,1 Milliarden bis +2,1 Milliarden.
Neun nützliche Bit-Manipulations-Muster
Diese neun Muster decken geschätzt 95 % aller Bit-Manipulationen ab, die du je schreiben wirst. Lern sie auswendig, dann erkennst du sie überall im Systemcode.
Bit setzen: x | (1 << n)
Bit n einschalten, die anderen unverändert lassen.
let flags = 0b0100;
flags = flags | (1 << 0); // 0b0101Bit löschen: x & ~(1 << n)
Bit n ausschalten, Rest bleibt. ~(1 << n) ist eine Maske mit jedem Bit gesetzt außer n.
let flags = 0b0111;
flags = flags & ~(1 << 1); // 0b0101Bit umschalten: x ^ (1 << n)
Bit n kippen, egal wie es steht.
let flags = 0b0100;
flags = flags ^ (1 << 2); // 0b0000
flags = flags ^ (1 << 2); // 0b0100 wiederBit prüfen: (x >> n) & 1
Liefert 1, falls Bit n gesetzt ist, sonst 0. Äquivalent: (x & (1 << n)) !== 0.
const flags = 0b0101;
const isBit2Set = (flags >> 2) & 1; // 1Niedrigstes gesetztes Bit isolieren: x & -x
Liefert einen Wert, der nur das niedrigste 1-Bit von x enthält. Der Trick funktioniert, weil im Zweierkomplement -x gleich ~x + 1 ist und alle Bits bis einschließlich des niedrigsten gesetzten Bits kippt.
const x = 0b10110100;
const lowest = x & -x; // 0b00000100 = 4Das ist der Kernkniff hinter Fenwick-Bäumen (Binary Indexed Trees) für O(log n)-Präfixsummen.
Gesetzte Bits zählen (popcount)
Anzahl der 1-Bits in einem Integer. Die meisten Sprachen haben native Funktionen:
// JavaScript (manuelle Variante)
const popcount = (n) => {
let count = 0;
while (n) { count += n & 1; n >>>= 1; }
return count;
};
popcount(0b10110100); // 4# Python 3.10+
(0b10110100).bit_count() # 4// Go
import "math/bits"
bits.OnesCount(0b10110100) // 4XOR-Swap ohne temporäre Variable
Ein klassischer Partytrick: zwei Integer ohne dritte Variable tauschen. Nie in Produktion verwenden (langsamer als ein Temp und kaputt, wenn a und b auf denselben Speicher zeigen), aber lehrreich.
let a = 5, b = 9;
a = a ^ b; // a = 5 ^ 9
b = a ^ b; // b = (5 ^ 9) ^ 9 = 5
a = a ^ b; // a = (5 ^ 9) ^ 5 = 9
// a = 9, b = 5Zweierpotenz erkennen: (x & (x - 1)) === 0
Eine Zweierpotenz hat genau ein gesetztes Bit. Minus 1 kippt genau dieses Bit aus und setzt alle niedrigeren. Das AND wird null nur für Zweierpotenzen (und für 0 selbst, deshalb der x > 0-Schutz).
const isPow2 = (x) => x > 0 && (x & (x - 1)) === 0;
isPow2(16); // true
isPow2(17); // falseSchneller Odd-Check: x & 1
In manchen Sprachen schneller als x % 2, in anderen nach Optimierung gleichauf. In heißen Schleifen oder wenn Lesbarkeit zweitrangig ist, lohnt es sich.
const isOdd = (x) => (x & 1) === 1;Bitmaske-Flags in echtem Code
Hier werden bitweise Operationen vom Trick zur Praxis.
32 Booleans als Feature-Flags
Statt eines 32-Feld-Structs voller Booleans alles in einen Integer packen.
const FLAGS = {
DARK_MODE: 1 << 0,
NEW_NAV: 1 << 1,
AI_SUGGESTIONS: 1 << 2,
BETA_EDITOR: 1 << 3,
// ... bis 1 << 31
};
let userFlags = 0;
userFlags |= FLAGS.DARK_MODE | FLAGS.AI_SUGGESTIONS; // aktivieren
if (userFlags & FLAGS.AI_SUGGESTIONS) {
showSuggestions();
}
userFlags &= ~FLAGS.DARK_MODE; // deaktivieren32 Booleans in 4 Byte, jede Teilmenge per Single-AND abfragbar. Datenbanken lieben dieses Muster: eine Spalte statt 32.
Unix-Dateiberechtigungen
chmod 755 ist reine Bitarithmetik. Die drei Oktalziffern entsprechen drei 3-Bit-Gruppen:
7 = 111 (Owner: rwx)
5 = 101 (Group: r-x)
5 = 101 (Others: r-x)Probier es aus: Im Zahlensystem-Konverter Quellbasis auf Oktal stellen, 755 eingeben, und die Binärausgabe lautet 111101101. Genau so speichert das Dateisystem das Permission-Feld.
Nur „Group Write” hinzufügen:
const perms = 0o755;
const withGroupWrite = perms | 0o020; // 0o775IP-Subnetzmaske
Gegeben 192.168.1.10/24. Die Netzadresse per AND mit der Maske extrahieren:
const ip = 0xC0A8010A; // 192.168.1.10
const mask = 0xFFFFFF00; // 255.255.255.0 (/24)
const network = ip & mask; // 0xC0A80100 = 192.168.1.0Gepackte IDs: Snowflake
Twitters Snowflake packt Zeitstempel, Maschinen-ID und Sequenz in einen 64-Bit-Integer:
┌─ 1 Bit ─┬─── 41 Bits ───┬─ 10 Bits ─┬─ 12 Bits ─┐
│Vorzeichen│ Zeitstempel │ Maschine │ Seq │
└─────────┴───────────────┴───────────┴───────────┘Eine ID zu codieren sind zwei Shifts und zwei ORs:
const id = (BigInt(timestamp) << 22n) |
(BigInt(machineId) << 12n) |
BigInt(sequence);Decodieren kehrt das um: Rechtsshift und Maskieren. Für die Wahl zwischen Snowflake, ULID und UUIDv7 siehe unseren Vergleich verteilter IDs.
Sprachspezifische Fallen
JavaScript: 32-Bit-Coercion-Falle
JavaScript konvertiert Operanden vor jeder bitweisen Operation in 32-Bit signed Integers und danach zurück zu Number. Jeder Wert über 2³¹ − 1 = 2147483647 läuft über:
2147483647 | 0 // 2147483647 (noch okay)
2147483648 | 0 // -2147483648 (übergelaufen)
4294967295 | 0 // -1 (alle Bits 1, signed interpretiert)Für 64-Bit-Arbeit nimm BigInt mit eigenen bitweisen Operatoren ohne Breitenlimit:
(2n ** 40n) | 1n // 1099511627777nPräzedenz-Bugs
Einer der häufigsten Bitoperator-Bugs in der Praxis:
// Bug: wird gelesen als (x & (1 == 0)), weil == enger bindet als &
if (x & 1 == 0) { /* ... */ }
// Richtig: Klammern
if ((x & 1) == 0) { /* ... */ }In C, JavaScript, Python, Go und den meisten Nachkommen binden Vergleichsoperatoren enger als bitweises AND/OR/XOR. Im Zweifel klammern.
Sprachvergleich
| Sprache | Breiten-Coercion | Negativer >> | BigInt-Unterstützung |
|---|---|---|---|
| JavaScript | Erzwingt 32-Bit signed; >>> ist unsigned | arithmetisch | BigInt mit eigenen Operatoren |
| Python | Beliebige Präzision, keine feste Breite | arithmetisch | Nativ |
| Go | Strikt, Shift-Menge muss unsigned sein | arithmetisch für signed Types | math/big |
| C/C++ | Richtet sich nach Typ (int, unsigned, …) | bei signed implementation-defined | Nichts eingebaut |
| Rust | Strikt, Panic bei Overflow im Debug | arithmetisch für signed Types | u128 / externe Crates |
Pythons unendliche Breite
Python-Integers haben keine feste Breite, also dehnt sich die Zweierkomplement-Logik konzeptuell bis ins Unendliche nach links aus. Deshalb ist ~5 gleich -6 (nicht 250 oder 65530): Python behandelt das Ergebnis als negative Zahl, nicht als Bitmuster fester Breite. Brauchst du Wrap-Around-Semantik, maskiere explizit:
# 8-Bit-NOT simulieren
(~5) & 0xFF # 250Performance-Check 2026
Eine verbreitete Weisheit lautet: Bitweise Operationen sind „immer schneller”. 2026 stimmt das nur noch zur Hälfte.
Compiler erledigen offensichtliche Umschreibungen längst selbst. Moderne Optimierer verwandeln x * 2 automatisch in x << 1. Wer x << 1 im Anwendungscode aus Geschwindigkeitsgründen schreibt, betreibt Cargo-Cult-Performance: hilft nichts und schadet der Lesbarkeit.
Wo bitweiser Code wirklich gewinnt:
- Heiße Zahlenloops: popcount, leading/trailing-zero-Count, Bitboard-Schach-Engines.
- Kompakte Datenstrukturen: Bloom-Filter, Roaring-Bitmaps, Fenwick-Bäume.
- Hardware-Register und Memory-Mapped I/O: Embedded, Kernel, Firmware.
- Kryptografie-Primitive: AES, ChaCha20, SHA, allesamt aus XOR, Rotationen und Shifts gebaut.
- Kompression und Dekompression: Huffman, Run-Length, gepackte Integer.
- Datenbank-Engines: Bitmap-Indexes, Spaltenformate wie Parquet-Dictionary-Encoding.
Wo es nichts bringt: x % 2 durch x & 1 in einer Business-Logic-Funktion zu ersetzen, die pro Request zweimal läuft. Die Beschleunigung ist nicht messbar, der Lesbarkeitspreis echt.
Der einzige Fall, in dem Bitmanipulation immer gewinnt, ist der Speicherbedarf. 32 Flags in einem int zu packen spart 31 Byte gegenüber 32 Booleans. Im Maßstab, also bei Millionen Nutzerdatensätzen oder Milliarden Events, ist das der Unterschied zwischen cache-freundlichem Layout und Cache-Miss-Sturm.
Schnell-Referenz
| Operation | Operator | Beispiel | Ergebnis | Typischer Einsatz |
|---|---|---|---|---|
| AND | & | 0b1100 & 0b1010 | 0b1000 | Maskieren/extrahieren |
| OR | | | 0b1100 | 0b1010 | 0b1110 | Flags kombinieren |
| XOR | ^ | 0b1100 ^ 0b1010 | 0b0110 | Toggle / Diff |
| NOT | ~ | ~0b1100 | ...11110011 | Invertierungsmaske |
| Linksshift | << | 1 << 3 | 8 | Multiplizieren mit 2ⁿ |
| Rechtsshift | >> | 16 >> 2 | 4 | Dividieren durch 2ⁿ (signed) |
| Unsigned-Rechtsshift (JS) | >>> | -1 >>> 0 | 4294967295 | Als unsigned behandeln |
Bit n setzen | | | x | (1 << n) | Bit an | |
Bit n löschen | & ~ | x & ~(1 << n) | Bit aus | |
Bit n umschalten | ^ | x ^ (1 << n) | Bit kippen | |
Bit n prüfen | & | (x >> n) & 1 | 0 oder 1 | Bit testen |
| Niedrigstes Bit | & - | x & -x | Bit isolieren | |
| Zweierpotenz | & | x > 0 && (x & (x-1)) == 0 | bool | Potenz testen |
FAQ
Was ist der Unterschied zwischen logischem (&&) und bitweisem (&) AND?
Logisches AND arbeitet auf ganzen Booleans und kürzt ab: false && expr wertet expr nie aus. Bitweises AND arbeitet auf einzelnen Bits von Integern, wertet immer beide Seiten aus und liefert wieder einen Integer. Nimm && für Kontrollflussbedingungen und & für Bitmanipulation, also Masken, Flag-Prüfungen und Subnetz-Berechnungen.
Warum ist ~1 in den meisten Sprachen -2?
Bitweises NOT kippt jedes Bit und liefert das Einerkomplement. In Zweierkomplement-Darstellung, die jede moderne CPU nutzt, entspricht das Kippen aller Bits von x dem Wert -(x + 1). Daher gilt ~1 = -2, ~0 = -1 und ~(-1) = 0. Willst du stattdessen ein Bitmuster fester Breite sehen, maskiere das Ergebnis etwa mit & 0xFF für 8 Bit.
Ist x << 1 wirklich schneller als x * 2?
In der Praxis nicht. Jeder moderne Compiler und JIT erkennt x * 2 als Zweierpotenz-Multiplikation und emittiert denselben Shift-Befehl. Nimm x * 2 für Klarheit und << nur, wenn du bewusst in Bits denkst, etwa beim Bauen einer Maske, beim Packen von IDs oder beim Arbeiten mit Hardware-Registern. Mikro-Benchmarks bestätigen die Gleichheit.
Unterstützt JavaScript 64-Bit-Bitoperationen?
Nicht mit den Standardoperatoren &, |, ^, <<, >> und >>>: Sie erzwingen alle Operanden auf 32-Bit signed Integers und verlieren höhere Bits. Für 64-Bit-Arbeit oder beliebige Präzision nimm BigInt-Literale wie 1n << 40n. Die BigInt-Varianten der bitweisen Operatoren haben keine feste Breite und verhalten sich wie Python.
Wie zähle ich gesetzte Bits effizient?
Am schnellsten mit der Sprach-Builtin: bits.OnesCount in Go, Integer.bitCount in Java, .bit_count() in Python ab 3.10, __builtin_popcount in GCC/Clang und std::popcount in C++20. Alle bilden auf eine einzige POPCNT-CPU-Instruktion auf modernen x86- und ARM-Prozessoren ab und sind deutlich schneller als jede manuelle Schleife.
Wann Bitmaske-Flags statt einer Boolean-Struct?
Wähle Bitmasken, wenn viele Flags kompakt gespeichert werden müssen (Datenbanken, Netzprotokolle, Dateiformate) oder wenn Kombinationen mit einem einzigen flags & REQUIRED_MASK prüfbar sein sollen. Wähle eine Struct, wenn Felder unterschiedliche Typen haben, sich selten als Gruppe abfragen lassen oder wenn Lesbarkeit für das Team wichtiger ist als der Speicher-Vorteil.
Was passiert, wenn ich über die Bitbreite hinaus shifte?
Undefiniert in C/C++. In JavaScript wird die Shift-Menge modulo 32 genommen, also ist 1 << 32 gleich 1, nicht 0. In Python gibt es keine Breite, 1 << 100 ist einfach ein größerer Integer. Verlass dich nie auf Overshift-Verhalten; maskiere die Shift-Menge selbst, falls nötig.
Warum liefert Pythons ~5 -6 und nicht 2?
Python-Integers haben keine feste Breite, also dehnt sich das Zweierkomplement konzeptuell unendlich nach links aus. ~5 ist daher -(5 + 1) = -6, genau wie in jeder anderen Zweierkomplement-Sprache. Willst du den 8-Bit-invertierten Wert 250 sehen, maskiere das Ergebnis explizit mit (~5) & 0xFF. Für 16 oder 32 Bit analog mit 0xFFFF oder 0xFFFFFFFF.
Ist XOR-Verschlüsselung sicher?
Ein One-Time-Pad mit echtem Zufallsschlüssel in Nachrichtenlänge ist informationstheoretisch unbrechbar. Denselben Schlüssel über mehrere Nachrichten wiederzuverwenden ist katastrophal unsicher; „XOR-Verschlüsselung” mit kurzem, sich wiederholendem Schlüssel lässt sich trivial brechen. Echte Chiffren wie AES und ChaCha20 nutzen XOR intern, aber nur als einen Schritt unter vielen.
Wie stelle ich eine negative Zahl im Zweierkomplement von Hand dar?
Positiven Wert in der Zielbreite binär aufschreiben, jedes Bit kippen, 1 addieren. Beispiel: -5 in 8 Bit = 00000101 → kippen zu 11111010 → plus 1 = 11111011. Prüfe das mit unserem Zahlensystem-Konverter: Konvertiere 251 (die unsigned-Interpretation von 11111011), und die Binärausgabe ist 11111011.
Verwandte Tools und weiterführende Lektüre
- Zahlensystem-Konverter: Zahl eintippen und Bitmuster live sehen.
- Guide zur Zahlensystemumrechnung: Vorlektüre zu Binär, Oktal, Hex.
- UUID v4 vs. v7 vs. ULID vs. Snowflake: Bit-Packing in verteilten IDs.
- Security Best Practices: Permission-Bitmaps und ihre Fallstricke.