Dart Bit- und Shift-Operatoren

Bearbeitet jedes einzelne Bit der Binärdarstellung von Zahlen und wird nur mit Ganzzahlen verwendet

Tabelle der Bitoperatoren und Shift-Operatoren

Operator	Bezeichnung	Berechnungsregel
&	Bitweises UND (AND)	Ergebnisbit ist nur dann 1, wenn die beiden entsprechenden Binärbits gleichzeitig 1 sind, sonst 0
|	Bitweises ODER (OR)	Ergebnisbit ist 1, wenn mindestens eines der passenden Binärbits 1 ist, sonst 0
^	Bitweises XOR (Exklusiv-ODER)	Ergebnisbit ist 1, wenn die entsprechenden Binärbits unterschiedlich sind, bei identischen Werten 0
~expr	Bitweise Negation (unärer Operator)	Alle Binärbits werden umgekehrt: 0 ↔ 1, aus 0 wird 1 und aus 1 wird 0
<<	Linksverschiebung Shift left	Die gesamte Binärfolge wird um N Stellen nach links verschoben, rechts werden Nullen aufgefüllt
>>	Vorzeichenbehaftete Rechtsverschiebung Shift right	Binärfolge um N Stellen nach rechts schieben, links wird das Vorzeichenbit aufgefüllt (bei positiven Zahlen 0, bei negativen Zahlen 1)
>>>	Vorzeichenlose Rechtsverschiebung Unsigned shift right	Binärfolge um N Stellen nach rechts schieben, links werden durchgängig Nullen eingefügt; negative Zahlen werden zuerst als vorzeichenlose 32-Bit-Ganzzahl umgewandelt, dann verschoben

Bitweises UND (&)

Das Ergebnisbit ist 1 nur dann, wenn beide zugehörigen Binärbits gleichzeitig 1 sind; sonst ist das Ergebnisbit 0.

Erste Zahl (Bit)	Zweite Zahl (Bit)	Ergebnis
1	1	1
1	0	0
0	1	0
0	0	0

Beispiel

void main() {
  // Ein-Bit Test
  assert((1 & 1) == 1);
  assert((1 & 0) == 0);
  assert((0 & 1) == 0);
  assert((0 & 0) == 0);

  // Mehrbit Ganzzahl Beispiel
  final a = 0x22; // Binär 00100010
  final b = 0x0f; // Binär 00001111
  assert((a & b) == 0x02); // Ergebnis 00000010
}Code-Sprache: PHP (php)

Bitweises ODER (|)

Das Ergebnisbit ist 1, falls mindestens eines der beiden passenden Binärbits 1 ist; sonst 0.

Erste Zahl (Bit)	Zweite Zahl (Bit)	Ergebnis
1	1	1
1	0	1
0	1	1
0	0	0

void main() {
  // Ein-Bit Test
  assert((1 | 1) == 1);
  assert((1 | 0) == 1);
  assert((0 | 1) == 1);
  assert((0 | 0) == 0);

  // Mehrbit Ganzzahl Beispiel
  final a = 0x22; // Binär 00100010
  final b = 0x0f; // Binär 00001111
  assert((a | b) == 0x2f); // Ergebnis 00101111
}Code-Sprache: PHP (php)

Bitweises XOR (^)

Ergebnisbit ist 1, wenn die beiden zugehörigen Binärbits unterschiedliche Werte haben; bei identischen Werten wird 0 ausgegeben.

Erste Zahl (Bit)	Zweite Zahl (Bit)	Ergebnis
1	1	0
1	0	1
0	1	1
0	0	0

Beispiel

void main() {
  // Ein-Bit Test
  assert((1 ^ 1) == 0);
  assert((1 ^ 0) == 1);
  assert((0 ^ 1) == 1);
  assert((0 ^ 0) == 0);

  // Mehrbit Ganzzahl Beispiel
  final a = 0x22; // Binär 00100010
  final b = 0x0f; // Binär 00001111
  assert((a ^ b) == 0x2d); // Ergebnis 00101101
}Code-Sprache: PHP (php)

Bitweise Negation (~)

Unärer Operator, benötigt nur einen Operanden; er kehrt jedes einzelne Binärbit um: aus 0 wird 1, aus 1 wird 0.

Eingangsbit	Ergebnisbit
1	0
0	1

Beispiel

void main() {
  // Ein-Bit Test
  assert((~1 & 1) == 0);
  assert((~0 & 1) == 1);

  // Mehrbit Ganzzahl Beispiel
  final a = 0x22; // Binär 00100010
  final mask = 0x0f; // Binär 00001111
  assert((a & ~mask) == 0x20); // Negiere mask und UND mit a, lösche untere 4 Bits
}Code-Sprache: PHP (php)

Weiteres Beispiel

void main() {
  // Testwerte definieren
  final value = 0x22;   // Hex 0x22 = Dez 34, Binär 00100010
  final bitmask = 0x0f; // Hex 0x0f = Dez 15, Binär 00001111

  // 1. Bitweises UND &
  print('value & bitmask = ${value & bitmask}'); // 0x02 = 2
  assert((value & bitmask) == 0x02);

  // 2. UND mit negierter Maske (& ~mask, häufig zum Löschen niederer Bits)
  print('value & ~bitmask = ${value & ~bitmask}'); // 0x20 = 32
  assert((value & ~bitmask) == 0x20);

  // 3. Bitweises ODER |
  print('value | bitmask = ${value | bitmask}'); // 0x2f = 47
  assert((value | bitmask) == 0x2f);

  // 4. Bitweises XOR ^
  print('value ^ bitmask = ${value ^ bitmask}'); // 0x2d = 45
  assert((value ^ bitmask) == 0x2d);

  // 5. Linksverschiebung <<
  print('value << 4 = ${value << 4}'); // 0x220 = 544
  assert((value << 4) == 0x220);

  // 6. Vorzeichenbehaftete Rechtsverschiebung >> (positive Zahl)
  print('value >> 4 = ${value >> 4}'); // 0x02 = 2
  assert((value >> 4) == 0x02);

  // 7. Vorzeichenbehaftete Rechtsverschiebung >> (negative Zahl, plattformabhängiges Verhalten)
  print('-value >> 4 = ${-value >> 4}'); // -0x03 = -3
  assert((-value >> 4) == -0x03);

  // 8. Vorzeichenlose Rechtsverschiebung >>> (positiv, ab Dart2.14)
  print('value >>> 4 = ${value >>> 4}'); // 0x02 = 2
  assert((value >>> 4) == 0x02);

  // 9. Vorzeichenlose Rechtsverschiebung >>> (negativ, Ergebnis immer positiv)
  print('-value >>> 4 = ${-value >>> 4}');
  assert((-value >>> 4) > 0);
}Code-Sprache: PHP (php)

Ausgabeergebnis

D:\dartdemo\firstdart>dart run
Building package executable...
Built firstdart:firstdart.
value & bitmask = 2
value & ~bitmask = 32
value | bitmask = 47
value ^ bitmask = 45
value << 4 = 544
value >> 4 = 2
-value >> 4 = -3
value >>> 4 = 2
-value >>> 4 = 1152921504606846973

Einzelne Aufschlüsselung der Beispiele

1 Bitweises UND

00100010
00001111
--------
00000010

Das Endergebnis ist 00000010, also die Dezimalzahl 2.

2 Bitweises UND mit negierter Maske & ~mask

00100010
11110000  // ~00001111
---------
00100000  // 0x20 = 32Code-Sprache: JavaScript (javascript)

11110000 ist das Ergebnis von ~mask: bei 00001111 werden alle Bits umgekehrt, 0 wird zu 1 und 1 zu 0.

3 Bitweises ODER |

00100010
00001111
---------
00101111  // 0x2f = 47Code-Sprache: JavaScript (javascript)

Das Ergebnisbit ist 1, solange mindestens ein Bit 1 ist; nur wenn beide Bits 0 sind, ergibt sich 0.

4 Bitweises XOR ^

00100010
00001111
---------
00101101  // 0x2d = 45Code-Sprache: JavaScript (javascript)

Nur bei unterschiedlichen oberen und unteren Bits wird 1 ausgegeben, bei identischen Bits steht 0.

5 Linksverschiebung << 4

00100010 << 4 = 001000100000
Ergebnis: 0x220 = 544

6 Vorzeichenbehaftete Rechtsverschiebung >> 4 (positive Zahl)

00100010 >> 4 = 00000010
Ergebnis: 0x02 = 2

7 Vorzeichenbehaftete Rechtsverschiebung >> 4 (negative Zahl)

-00100010 >> 4 = -00000011
Ergebnis: -0x03 = -3

8 Vorzeichenlose Rechtsverschiebung >>> 4 (positive Zahl)

00100010 >>> 4 = 00000010
Ergebnis: 0x02 = 2

9 Vorzeichenlose Rechtsverschiebung >>> 4 (negative Zahl)

-00100010 >>> 4 = (links mit 0 aufgefüllt) 00001101...  // Ergebnis ist immer größer als 0Code-Sprache: JavaScript (javascript)