Was bedeutet "Signed" / "Unsigned" im Tool?

**Unsigned** = jedes Bit ist Wert. 8-Bit unsigned hält 0 bis 255. **Signed** = das höchste Bit ist das Vorzeichen ([[Zweierkomplement||Standarddarstellung in fast jeder CPU]]). 8-Bit signed hält -128 bis +127. Das Tool zeigt **beide Interpretationen** gleichzeitig, der Switch entscheidet nur, ob arithmetische Ops (`A + B`, `A - B`) und arithmetischer Shift (`>>`) Werte als signed behandeln.

Was ist Popcount und wozu?

**[[Popcount||Population-Count, Anzahl der auf 1 gesetzten Bits]]** ist die Anzahl von 1en in der Binärdarstellung. `popcount(0b1011)` = 3. Nützlich in **Kompression**, **Algorithmen** (Hamming-Distanz zwischen Hashes), **Datenbanken** (Bitmap-Indexes), **Machine Learning** (Feature-Kardinalität). Moderne CPUs haben eine **dedizierte POPCNT-Instruktion** (x86 SSE4.2, ARM NEON). In JS reicht eine Loop oder der Kernighan-Trick: `while (n) { count++; n &= n-1; }` (jede Iteration nullt die niedrigste 1).

**Niedrigstes gesetztes Bit**: extrahiert das **niedrigste gesetzte Bit** einer Zahl. `0b1101100 & -(0b1101100)` = `0b100` = 4. Warum es funktioniert: `-A` im [[Zweierkomplement||bitweises NOT + 1]] erzeugt eine Zahl, in der alle Bits unter der niedrigsten 1 identisch und Bits darüber geflippt sind, AND behält nur die niedrigste 1. **Praktisch:** [[Fenwick-Tree||Binary Indexed Tree, Datenstruktur für Prefix-Sums]], Iteration über gesetzte Bits.

Warum braucht man BigInt für 64-Bit?

Weil JavaScript **jede bitweise Op in 32-Bit-signed-Integer konvertiert**. `(1 >`) funktionieren auf BigInts mit normaler Zweierkomplement-Semantik. Dieses Tool nutzt intern BigInt für jede Breite, garantiert korrekte 64-Bit-Ergebnisse.

Wie unterscheidet sich Rotation von Shift?

**Shift** droppt Bits über den Rand und füllt von der anderen Seite (0 oder Vorzeichen-Bit). **Rotation** wrappt, Bits, die rausfallen, kommen auf der anderen Seite wieder rein. Beispiel in 8-Bit: `0b10110000 << 1` = `0b01100000` (höchstes Bit verloren). `ROL 0b10110000 um 1` = `0b01100001` (höchste 1 zu Position 0 gewrappt). **In Krypto** (SHA-256 nutzt viele Rotationen), **Kompression**, **Hash-Algorithmen**. Die meisten CPU-Architekturen haben native ROL/ROR-Instruktionen.

Wie interpretiere ich Arithmetic-Overflow?

In 8-Bit unsigned: `200 + 100 = 300`, aber 300 passt nicht in 8 Bit (max 255). **Es wrappt**: `300 mod 256 = 44`. Das Tool flaggt das mit einer **gelben "Overflow"-Warnung**. In 8-Bit signed `100 + 50 = 150`, aber max signed 8-Bit ist 127, das Ergebnis wrappt ins Negative: `-106`. Die meisten Sprachen (Rust, Go, C im Debug-Modus) **panicen bei Overflow**, also zahlt es sich aus zu wissen, wann es passiert.

Was sind Bit-Flags und wann nehmen?

**Ein Pattern: eine Zahl hält viele Booleans.** Konstanten definieren: `FLAG_A = 1, FLAG_B = 2, FLAG_C = 4, FLAG_D = 8` (jede eine Zweierpotenz). **Setzen**: `flags |= FLAG_A | FLAG_C` (00000101). **Prüfen**: `if (flags & FLAG_A)`. **Löschen**: `flags &= ~FLAG_A`. **Pro**: 1 Int = 32 Booleans (Memory-Ersparnis, schnelle Checks). **Kontra**: Lesbarkeit. Nimm es für **Flag-Sammlungen in Protokollen, Konfig, File-Permissions, API-Optionen**. Vermeide es für 2-3 Booleans, benannte Felder lesen sich besser.

Wie prüfe ich, ob eine Zahl eine Zweierpotenz ist?

Der klassische Trick: **`n > 0 && (n & (n - 1)) === 0`**. Warum: eine Zweierpotenz hat **genau ein gesetztes Bit**. `n - 1` nullt das niedrigste Bit und setzt alle Bits darunter. Bei einer Zweierpotenz ist ihr AND 0. Beispiel: `8 (0b1000) & 7 (0b0111) = 0`. Keine Zweierpotenz: `6 (0b110) & 5 (0b101) = 4`. **Genutzt in**: Optimierungen (Zweierpotenz = Shift statt Division), Algorithmen (Segment-Tree, Hashmap-Größe), GPU-Programmierung (Texturen müssen Zweierpotenzen sein).

Bitwise-Operationen Playground - kostenlos

Breite

VorzeichenHöchstes Bit als Vorzeichen (Zweierkomplement)

ABIN

Bit-Raster (klicken zum Umschalten)

HEX

0x000000B4

OCT

0o264

DEC

180

DEC (signed)

180

BIN

0b00000000000000000000000010110100

BBIN

Bit-Raster (klicken zum Umschalten)

HEX

0x00000035

OCT

0o65

DEC

DEC (signed)

BIN

0b00000000000000000000000000110101

Shift n

Positionen für Shift / Rotate

Bit-Index N

Bit für set / clear / toggle / test

Unterschiedliche Bits hervorheben

Logische Operatoren

A AND B

A & B

HEX 0x00000034

OCT 0o64

DEC(u) 52

DEC(s) 52

BIN 0b00000000000000000000000000110100

A OR B

A | B

HEX 0x000000B5

OCT 0o265

DEC(u) 181

DEC(s) 181

BIN 0b00000000000000000000000010110101

A XOR B

A ^ B

HEX 0x00000081

OCT 0o201

DEC(u) 129

DEC(s) 129

BIN 0b00000000000000000000000010000001

NOT A

~A

HEX 0xFFFFFF4B

OCT 0o37777777513

DEC(u) 4294967115

DEC(s) -181

BIN 0b11111111111111111111111101001011

NOT B

~B

HEX 0xFFFFFFCA

OCT 0o37777777712

DEC(u) 4294967242

DEC(s) -54

BIN 0b11111111111111111111111111001010

Shifts und Rotationen

n = 2

A << 2

Links-Shift (×2 pro Position)

HEX 0x000002D0

OCT 0o1320

DEC(u) 720

DEC(s) 720

BIN 0b00000000000000000000001011010000

A >> 2

Arithmetischer Rechts-Shift (erhält Vorzeichen)

HEX 0x0000002D

OCT 0o55

DEC(u) 45

DEC(s) 45

BIN 0b00000000000000000000000000101101

A >>> 2

Logischer Rechts-Shift (füllt mit 0)

HEX 0x0000002D

OCT 0o55

DEC(u) 45

DEC(s) 45

BIN 0b00000000000000000000000000101101

ROL A 2

Links rotieren (Bits laufen herum)

HEX 0x000002D0

OCT 0o1320

DEC(u) 720

DEC(s) 720

BIN 0b00000000000000000000001011010000

ROR A 2

Rechts rotieren (Bits laufen herum)

HEX 0x0000002D

OCT 0o55

DEC(u) 45

DEC(s) 45

BIN 0b00000000000000000000000000101101

Arithmetik

A + B

Addition (wickelt bei Überlauf)

HEX 0x000000E9

OCT 0o351

DEC(u) 233

DEC(s) 233

BIN 0b00000000000000000000000011101001

A - B

Subtraktion (wickelt bei Unterlauf)

HEX 0x0000007F

OCT 0o177

DEC(u) 127

DEC(s) 127

BIN 0b00000000000000000000000001111111

Bit-Tricks

bit N = 3

Bit 3 setzen

A | (1 << 3)

HEX 0x000000BC

OCT 0o274

DEC(u) 188

DEC(s) 188

BIN 0b00000000000000000000000010111100

Bit 3 löschen

A & ~(1 << 3)

HEX 0x000000B4

OCT 0o264

DEC(u) 180

DEC(s) 180

BIN 0b00000000000000000000000010110100

Bit 3 umschalten

A ^ (1 << 3)

HEX 0x000000BC

OCT 0o274

DEC(u) 188

DEC(s) 188

BIN 0b00000000000000000000000010111100

Bit 3 prüfen

(A >> 3) & 1

Niedrigstes gesetztes Bit

A & -A

0b00000000000000000000000000000100

4 dec • 0x00000004

Popcount (Anzahl gesetzter Bits)

Anzahl der auf 1 gesetzten Bits in A

Was bedeuten "&", "|", "^" im Code und wie setze ich Bit 5?

Bitweise Operatoren sind die Grundlage vieler Low-Level-Tricks: Permission-Masks (Unix `chmod`), Bit-Flags, numerische Optimierungen (`x & 1` statt `x % 2`), Parsing von Netzwerkprotokollen (TCP-Flags, RGBA-Farben), Memory-Management.

Zwei Zahlen in A und B tippen (als dec, hex 0x, bin 0b, oct 0o, auto-erkannt), eine Breite wählen (8-Bit, 16-Bit, 32-Bit, 64-Bit) und jede Operation live sehen: AND, OR, XOR, NOT, Shifts, Rotationen, Popcount, niedrigstes gesetztes Bit.

Jedes Ergebnis im Bit-Grid (Bit klicken zum Flippen), in Binär, dec (signed + unsigned), hex und oct. Berechnet mit BigInt, sodass 64-Bit-Werte auch über `Number.MAX_SAFE_INTEGER` korrekt funktionieren.

So nutzt du das Tool

Eine Breite wählen: 8 / 16 / 32 / 64 Bit. Entscheidet, wie viele Bits der Operand hat und wie Overflow erkannt wird.

Signed aktivieren, wenn Werte als Zweierkomplement interpretiert werden sollen (z. B. -1 in 8-Bit = 0b11111111).

A und B eintragen. Jedes Format akzeptiert: `255`, `0xFF`, `0b11111111`, `0o377`. Format wird am Präfix erkannt.

Ein Bit im Grid klicken, um es zu flippen (toggle). Operationen rechnen sofort neu, alle 12+ Ergebnisse updaten live.

Für Shifts und Rotationen n mit dem Slider setzen. Für Single-Bit-Ops (set/clear/toggle/test) Bit N setzen.

"Differing Bits hervorheben" zeigt orange, welche Bits die Operation verändert hat, perfekt um zu sehen, was `XOR` oder `<<` wirklich macht.

Jedes Ergebnis in jedem Format (BIN, HEX, OCT, DEC) mit einem Klick kopieren.

Wann das nützlich ist

Echte Situationen, in denen du bitweise Operationen kennen musst:

Unix-Datei-Permissions: `chmod 755` ist eine Bitmaske. `rwxr-xr-x` = `0b111101101` = 0o755 = 493 dec. Jedes Bit ist ein Flag (read/write/execute × owner/group/other).
TCP/IP-Flags: der TCP-Header hat 9 Flag-Bits (SYN, ACK, FIN, RST, PSH, URG...). Ein Parser dekodiert sie mit Masken: `flags & 0x01` ist FIN, `flags & 0x02` ist SYN etc.
RGBA-Farben: 32-Bit packt 4 Kanäle zu je 8 Bit. `red = (color >> 24) & 0xFF`, `green = (color >> 16) & 0xFF` und so weiter.
Konfigurations-Flags: C-/Rust-Libraries übergeben Dutzende Optionen als einen Int. `OPT_ASYNC | OPT_VERBOSE | OPT_RETRY`. Prüfen: `if (opts & OPT_ASYNC)`.
Hash-Funktionen und Krypto: Implementierungen von MD5, SHA, AES nutzen Rotationen (`ROL`, `ROR`), XORs und Shifts. Meist 32-Bit.
Bitmap-Indexes in Datenbanken: Postgres, Oracle, MySQL nutzen bitweise Ops fürs Filtern.
Hardware-GPIO: Arduino, ESP32, Raspberry Pi steuern Pins mit `PORTB |= (1 << 5)`. Jedes Bit = Pin-Zustand.
Netzwerk-Adressmasken: `192.168.1.0/24` ist Maske `0xFFFFFF00`. Prüfen, ob eine IP im Netz ist: `(ip & mask) == network`.
Algorithmen: Bitset als kompaktes Set, Brian-Kernighan-Trick für Popcount, Sieb des Eratosthenes auf Bits, Fenwick-Tree.

Um zwischen Zahlensystemen umzurechnen, schau unseren Zahlenbasis-Konverter. Für Byte-Größen schau Dateigrößen-Konverter.

Fragen und Antworten

`>>` ist arithmetischer Right-Shift: behält das Vorzeichen-Bit. `-8 >> 1` = `-4` (bei negativen Zahlen "repliziert" es die 1 links). `>>>` ist logischer Right-Shift: füllt mit Nullen. `-8 >>> 1` = `2147483644` (behandelt Bits als unsigned). Die meisten Sprachen haben nur `>>` (es respektiert den signed/unsigned-Typ der Variable). JavaScript hat beide, weil jede Zahl für bitweise Ops in 32-Bit signed konvertiert wird.

Was bedeuten "&", "|", "^" im Code und wie setze ich Bit 5?

So nutzt du das Tool

Eine Breite wählen: 8 / 16 / 32 / 64 Bit. Entscheidet, wie viele Bits der Operand hat und wie Overflow erkannt wird.

Signed aktivieren, wenn Werte als Zweierkomplement interpretiert werden sollen (z. B. -1 in 8-Bit = 0b11111111).

A und B eintragen. Jedes Format akzeptiert: `255`, `0xFF`, `0b11111111`, `0o377`. Format wird am Präfix erkannt.

Ein Bit im Grid klicken, um es zu flippen (toggle). Operationen rechnen sofort neu, alle 12+ Ergebnisse updaten live.

Für Shifts und Rotationen n mit dem Slider setzen. Für Single-Bit-Ops (set/clear/toggle/test) Bit N setzen.

"Differing Bits hervorheben" zeigt orange, welche Bits die Operation verändert hat, perfekt um zu sehen, was `XOR` oder `<<` wirklich macht.

Jedes Ergebnis in jedem Format (BIN, HEX, OCT, DEC) mit einem Klick kopieren.

Wann das nützlich ist

Echte Situationen, in denen du bitweise Operationen kennen musst:

Unix-Datei-Permissions: `chmod 755` ist eine Bitmaske. `rwxr-xr-x` = `0b111101101` = 0o755 = 493 dec. Jedes Bit ist ein Flag (read/write/execute × owner/group/other).
TCP/IP-Flags: der TCP-Header hat 9 Flag-Bits (SYN, ACK, FIN, RST, PSH, URG...). Ein Parser dekodiert sie mit Masken: `flags & 0x01` ist FIN, `flags & 0x02` ist SYN etc.
RGBA-Farben: 32-Bit packt 4 Kanäle zu je 8 Bit. `red = (color >> 24) & 0xFF`, `green = (color >> 16) & 0xFF` und so weiter.
Konfigurations-Flags: C-/Rust-Libraries übergeben Dutzende Optionen als einen Int. `OPT_ASYNC | OPT_VERBOSE | OPT_RETRY`. Prüfen: `if (opts & OPT_ASYNC)`.
Hash-Funktionen und Krypto: Implementierungen von MD5, SHA, AES nutzen Rotationen (`ROL`, `ROR`), XORs und Shifts. Meist 32-Bit.
Bitmap-Indexes in Datenbanken: Postgres, Oracle, MySQL nutzen bitweise Ops fürs Filtern.
Hardware-GPIO: Arduino, ESP32, Raspberry Pi steuern Pins mit `PORTB |= (1 << 5)`. Jedes Bit = Pin-Zustand.
Netzwerk-Adressmasken: `192.168.1.0/24` ist Maske `0xFFFFFF00`. Prüfen, ob eine IP im Netz ist: `(ip & mask) == network`.
Algorithmen: Bitset als kompaktes Set, Brian-Kernighan-Trick für Popcount, Sieb des Eratosthenes auf Bits, Fenwick-Tree.

Um zwischen Zahlensystemen umzurechnen, schau unseren Zahlenbasis-Konverter. Für Byte-Größen schau Dateigrößen-Konverter.

Fragen und Antworten

Bitwise-Operationen Playground

Logische Operatoren

Shifts und Rotationen

Arithmetik

Bit-Tricks

Was bedeuten "&", "|", "^" im Code und wie setze ich Bit 5?

So nutzt du das Tool

Wann das nützlich ist

Fragen und Antworten

Passende Tools

Zahlen-Basen-Umrechner

Regex-Tester

Wort- und Zeichen-Zähler

Bitwise-Operationen Playground

Logische Operatoren

Shifts und Rotationen

Arithmetik

Bit-Tricks

Was bedeuten "&", "|", "^" im Code und wie setze ich Bit 5?

So nutzt du das Tool

Wann das nützlich ist

Fragen und Antworten

Passende Tools

Zahlen-Basen-Umrechner

Regex-Tester

Wort- und Zeichen-Zähler