Opérateurs bit à bit et opérateurs de décalage Dart

Opère sur chaque bit binaire des nombres, ne s’utilise qu’avec des entiers

Tableau des opérateurs bit à bit et opérateurs de décalage

Opérateur	Nom	Règle de calcul
&	ET bit à bit (AND)	Le bit résultat vaut 1 uniquement si les deux bits binaires correspondants valent tous les deux 1, sinon 0
|	OU bit à bit (OR)	Le bit résultat vaut 1 si au moins un des bits binaires correspondants vaut 1, sinon 0
^	OU exclusif bit à bit (XOR)	Le bit résultat vaut 1 quand les bits binaires correspondants sont différents, identiques → 0
~expr	Complément bit à bit (opérateur unaire)	Inverse tous les bits binaires : 0 ↔ 1, 0 devient 1 et 1 devient 0
<<	Décalage vers la gauche Shift left	Toute la séquence binaire est décalée de N positions à gauche, complété par des 0 à droite
>>	Décalage droit signé Shift right	Décalage binaire de N positions à droite, complété à gauche par le bit de signe (0 pour positifs, 1 pour négatifs)
>>>	Décalage droit non signé Unsigned shift right	Décalage binaire de N positions à droite, complété systématiquement par des 0 à gauche ; les nombres négatifs sont d’abord convertis en entier 32 bits non signé avant décalage

Opérateur ET bit à bit (&)

Le bit résultat est 1 seulement si les deux bits correspondants valent 1 ; si l’un vaut 0, le bit résultat est 0.

Bit premier nombre	Bit second nombre	Résultat
1	1	1
1	0	0
0	1	0
0	0	0

Exemple

void main() {
  // Vérification bit unique
  assert((1 & 1) == 1);
  assert((1 & 0) == 0);
  assert((0 & 1) == 0);
  assert((0 & 0) == 0);

  // Exemple entier multi-bit
  final a = 0x22; // Binaire 00100010
  final b = 0x0f; // Binaire 00001111
  assert((a & b) == 0x02); // Résultat 00000010
}Langage du code : PHP (php)

Opérateur OU bit à bit (|)

Le bit résultat vaut 1 si au moins un des deux bits correspondants est 1 ; seulement 0 si les deux bits valent 0.

Bit premier nombre	Bit second nombre	Résultat
1	1	1
1	0	1
0	1	1
0	0	0

void main() {
  // Vérification bit unique
  assert((1 | 1) == 1);
  assert((1 | 0) == 1);
  assert((0 | 1) == 1);
  assert((0 | 0) == 0);

  // Exemple entier multi-bit
  final a = 0x22; // Binaire 00100010
  final b = 0x0f; // Binaire 00001111
  assert((a | b) == 0x2f); // Résultat 00101111
}Langage du code : PHP (php)

Opérateur XOR bit à bit (^)

Le bit résultat vaut 1 quand les deux bits correspondants ont des valeurs différentes ; valeurs identiques → résultat 0.

Bit premier nombre	Bit second nombre	Résultat
1	1	0
1	0	1
0	1	1
0	0	0

Exemple

void main() {
  // Vérification bit unique
  assert((1 ^ 1) == 0);
  assert((1 ^ 0) == 1);
  assert((0 ^ 1) == 1);
  assert((0 ^ 0) == 0);

  // Exemple entier multi-bit
  final a = 0x22; // Binaire 00100010
  final b = 0x0f; // Binaire 00001111
  assert((a ^ b) == 0x2d); // Résultat 00101101
}Langage du code : PHP (php)

Opérateur complément bit à bit (~)

Opérateur unaire, ne requiert qu’un seul opérande, inverse chaque bit binaire un par un : 0 devient 1, 1 devient 0.

Bit initial	Bit inversé
1	0
0	1

Exemple

void main() {
  // Vérification bit unique
  assert((~1 & 1) == 0);
  assert((~0 & 1) == 1);

  // Exemple entier multi-bit
  final a = 0x22; // Binaire 00100010
  final mask = 0x0f; // Binaire 00001111
  assert((a & ~mask) == 0x20); // Inverse mask puis ET avec a, efface les 4 bits faibles
}Langage du code : PHP (php)

Exemple complet à analyser

void main() {
  // Définition des valeurs de test
  final value = 0x22;   // Hexadécimal 0x22 = décimal 34, binaire 00100010
  final bitmask = 0x0f; // Hexadécimal 0x0f = décimal 15, binaire 00001111

  // 1. ET bit à bit &
  print('value & bitmask = ${value & bitmask}'); // 0x02 = 2
  assert((value & bitmask) == 0x02);

  // 2. ET avec masque inversé (& ~mask, très utilisé pour effacer les bits bas)
  print('value & ~bitmask = ${value & ~bitmask}'); // 0x20 = 32
  assert((value & ~bitmask) == 0x20);

  // 3. OU bit à bit |
  print('value | bitmask = ${value | bitmask}'); // 0x2f = 47
  assert((value | bitmask) == 0x2f);

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

  // 5. Décalage gauche <<
  print('value << 4 = ${value << 4}'); // 0x220 = 544
  assert((value << 4) == 0x220);

  // 6. Décalage droit signé >> (nombre positif)
  print('value >> 4 = ${value >> 4}'); // 0x02 = 2
  assert((value >> 4) == 0x02);

  // 7. Décalage droit signé >> (nombre négatif, comportement variable selon plateforme)
  print('-value >> 4 = ${-value >> 4}'); // -0x03 = -3
  assert((-value >> 4) == -0x03);

  // 8. Décalage droit non signé >>> (positif, Dart2.14+)
  print('value >>> 4 = ${value >>> 4}'); // 0x02 = 2
  assert((value >>> 4) == 0x02);

  // 9. Décalage droit non signé >>> (négatif, résultat toujours supérieur à 0)
  print('-value >>> 4 = ${-value >>> 4}');
  assert((-value >>> 4) > 0);
}Langage du code : PHP (php)

Résultat de l’exécution

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

Détail pas à pas de chaque exemple

1 ET bit à bit

00100010
00001111
--------
00000010

Le résultat final est 00000010, soit le nombre décimal 2.

2 ET avec masque inversé & ~mask

00100010
11110000  // ~00001111
---------
00100000  // 0x20 = 32Langage du code : JavaScript (javascript)

La suite 11110000 est le résultat de ~mask : tous les bits de 00001111 sont inversés, 0 devient 1 et 1 devient 0

3 OU bit à bit |

00100010
00001111
---------
00101111  // 0x2f = 47Langage du code : JavaScript (javascript)

Le bit résultat vaut 1 tant qu’au moins un bit est 1 ; seulement 0 si les deux bits valent 0

4 XOR bit à bit ^

00100010
00001111
---------
00101101  // 0x2d = 45Langage du code : JavaScript (javascript)

On obtient 1 uniquement quand les bits du haut et du bas sont différents ; identiques → 0

5 Décalage gauche << 4

00100010 << 4 = 001000100000
Résultat : 0x220 = 544

6 Décalage droit signé >> 4 (nombre positif)

00100010 >> 4 = 00000010
Résultat : 0x02 = 2

7 Décalage droit signé >> 4 (nombre négatif)

-00100010 >> 4 = -00000011
Résultat : -0x03 = -3

8 Décalage droit non signé >>> 4 (nombre positif)

00100010 >>> 4 = 00000010
Résultat : 0x02 = 2

9 Décalage droit non signé >>> 4 (nombre négatif)

-00100010 >>> 4 = (complété par des 0 à gauche) 00001101...  // résultat toujours supérieur à 0Langage du code : JavaScript (javascript)