Bitwise Operaties

Bitwise operaties werken rechtstreeks op de individuele bits van een getal — positie per positie. Ze zijn razendsnel en duiken op in allerlei praktische toepassingen: kleurmanipulatie, bestandsrechten, netwerkmaskering en encryptie.

Je kunt bitwise operaties uitvoeren in de browser console (F12 → Console) of in een C#-project. De operators zijn in beide talen identiek.

AND (&)

AND geeft een 1 als beide bits 1 zijn, anders 0.

A	B	A & B
0	0	0
0	1	0
1	0	0
1	1	1

Bit voor bit:

  1010
& 1100
------
  1000

$1010_2 \mathbin{\&} 1100_2 = 1000_2 = 8_{10}$

// JavaScript
console.log(0b1010 & 0b1100); // 8
console.log(10 & 12);          // 8

// C#
Console.WriteLine(0b1010 & 0b1100); // 8
Console.WriteLine(10 & 12);          // 8

AND gebruik je als bitmask: je selecteert specifieke bits en legt de rest op 0.

---

OR (|)

OR geeft een 1 als minstens één van de bits 1 is.

A	B	A | B
0	0	0
0	1	1
1	0	1
1	1	1

Bit voor bit:

  1010
| 0101
------
  1111

$1010_2 \mathbin{|} 0101_2 = 1111_2 = 15_{10}$

// JavaScript
console.log(0b1010 | 0b0101); // 15
console.log(10 | 5);           // 15

// C#
Console.WriteLine(0b1010 | 0b0101); // 15
Console.WriteLine(10 | 5);           // 15

OR gebruik je om specifieke bits aan te zetten in een getal.

---

XOR (^)

XOR (eXclusive OR) geeft een 1 als de bits verschillend zijn.

A	B	A ^ B
0	0	0
0	1	1
1	0	1
1	1	0

Bit voor bit:

  1010
^ 1100
------
  0110

$1010_2 \oplus 1100_2 = 0110_2 = 6_{10}$

// JavaScript
console.log(0b1010 ^ 0b1100); // 6
console.log(10 ^ 12);          // 6

// C#
Console.WriteLine(0b1010 ^ 0b1100); // 6
Console.WriteLine(10 ^ 12);          // 6

XOR heeft een bijzondere eigenschap: twee keer XOR-ten met dezelfde waarde geeft het origineel terug. Dat maakt het nuttig voor toggle-operaties en eenvoudige encryptie.

---

NOT (~)

NOT keert alle bits om: 0 wordt 1, 1 wordt 0.

A	~A
0	1
1	0

  00001010   (10)
~
  11110101

// JavaScript
console.log(~10); // -11
console.log(~0);  // -1

// C#
Console.WriteLine(~10); // -11
Console.WriteLine(~0);  // -1

NOT en negatieve getallen

~ werkt op 32-bit signed integers. Het resultaat is altijd -(n + 1), dus ~5 = -6 en ~10 = -11. Dit heeft te maken met hoe negatieve getallen in binair worden opgeslagen (two's complement).

---

Bit shifts

Bit shifts schuiven alle bits een of meerdere posities naar links of rechts.

Left shift (<<)

Schuif bits naar links, vul rechts aan met nullen.

  00000001  (1)
<< 3
  00001000  (8)

Links shiften met $n$ = vermenigvuldigen met $2^n$.

$1 \ll 3 = 1 \times 2^3 = 8$

// JavaScript
console.log(1 << 3); // 8
console.log(5 << 2); // 20

// C#
Console.WriteLine(1 << 3); // 8
Console.WriteLine(5 << 2); // 20

Right shift (>>)

Schuif bits naar rechts, bits die rechts uitvallen gaan verloren.

  00001000  (8)
>> 2
  00000010  (2)

Rechts shiften met $n$ = gehele deling door $2^n$.

$8 \gg 2 = 8 \div 4 = 2$

// JavaScript
console.log(8 >> 1); // 4
console.log(8 >> 2); // 2

// C#
Console.WriteLine(8 >> 1); // 4
Console.WriteLine(8 >> 2); // 2

---

Praktische voorbeelden

Kleurkanalen uitlezen

Een CSS-kleur zoals #FF5733 is intern één 24-bit getal. Met shifts en AND haal je de afzonderlijke kanalen eruit:

// JavaScript
const kleur = 0xFF5733;
const rood  = (kleur >> 16) & 0xFF; // 255
const groen = (kleur >> 8)  & 0xFF; // 87
const blauw =  kleur        & 0xFF; // 51

// C#
int kleur = 0xFF5733;
int rood  = (kleur >> 16) & 0xFF; // 255
int groen = (kleur >> 8)  & 0xFF; // 87
int blauw =  kleur        & 0xFF; // 51

Oneven of even controleren

De laatste bit is 1 bij oneven getallen en 0 bij even:

// JavaScript
const isOneven = (getal & 1) === 1;

// C#
bool isOneven = (getal & 1) == 1;

Snel vermenigvuldigen of delen door 2

// JavaScript
const verdubbeld = getal << 1; // × 2
const gehalveerd = getal >> 1; // ÷ 2 (geheel)

// C#
int verdubbeld = getal << 1; // × 2
int gehalveerd = getal >> 1; // ÷ 2 (geheel)