Operadores bit a bit e operadores de deslocamento em Dart

Manipula cada bit individual da representação binária dos números, só funciona com números inteiros

Tabela de operadores bit a bit e operadores de deslocamento

Operador	Nome	Regra de cálculo
&	AND bit a bit	O bit resultado só vale 1 quando os bits binários correspondentes forem ambos 1, caso contrário vale 0
|	OR bit a bit	O bit resultado vale 1 se qualquer um dos bits binários correspondentes for 1, senão vale 0
^	XOR bit a bit (OU exclusivo)	O bit resultado vale 1 quando os bits binários correspondentes forem diferentes, se forem iguais vale 0
~expr	Negação bit a bit (operador unário)	Inverte todos os bits binários: 0 ↔ 1, 0 vira 1 e 1 vira 0
<<	Deslocamento à esquerda Shift left	Toda a sequência binária é deslocada N posições para a esquerda, completando com zeros no lado direito
>>	Deslocamento à direita com sinal Shift right	A sequência binária é movida N posições para a direita, completando no lado esquerdo com o bit de sinal (0 para números positivos, 1 para negativos)
>>>	Deslocamento à direita sem sinal Unsigned shift right	A sequência binária é deslocada N posições para a direita, sempre completando com zeros à esquerda; números negativos são convertidos primeiro para inteiro de 32 bits sem sinal antes do deslocamento

Operador AND bit a bit (&)

O bit resultado é 1 apenas se os dois bits correspondentes forem 1; se qualquer um for 0, o bit resultado será 0.

Bit do primeiro número	Bit do segundo número	Resultado da operação
1	1	1
1	0	0
0	1	0
0	0	0

Exemplo

void main() {
  // Validação de bit único
  assert((1 & 1) == 1);
  assert((1 & 0) == 0);
  assert((0 & 1) == 0);
  assert((0 & 0) == 0);

  // Exemplo com inteiro multi-bit
  final a = 0x22; // Binário 00100010
  final b = 0x0f; // Binário 00001111
  assert((a & b) == 0x02); // Resultado 00000010
}Code language: PHP (php)

Operador OR bit a bit (|)

O bit resultado vale 1 se qualquer um dos dois bits correspondentes for 1; só será 0 se ambos forem 0.

Bit do primeiro número	Bit do segundo número	Resultado da operação
1	1	1
1	0	1
0	1	1
0	0	0

void main() {
  // Validação de bit único
  assert((1 | 1) == 1);
  assert((1 | 0) == 1);
  assert((0 | 1) == 1);
  assert((0 | 0) == 0);

  // Exemplo com inteiro multi-bit
  final a = 0x22; // Binário 00100010
  final b = 0x0f; // Binário 00001111
  assert((a | b) == 0x2f); // Resultado 00101111
}Code language: PHP (php)

Operador XOR bit a bit (^)

O bit resultado vale 1 quando os dois bits correspondentes têm valores diferentes; se forem iguais o resultado é 0.

Bit do primeiro número	Bit do segundo número	Resultado da operação
1	1	0
1	0	1
0	1	1
0	0	0

Exemplo

void main() {
  // Validação de bit único
  assert((1 ^ 1) == 0);
  assert((1 ^ 0) == 1);
  assert((0 ^ 1) == 1);
  assert((0 ^ 0) == 0);

  // Exemplo com inteiro multi-bit
  final a = 0x22; // Binário 00100010
  final b = 0x0f; // Binário 00001111
  assert((a ^ b) == 0x2d); // Resultado 00101101
}Code language: PHP (php)

Operador de negação bit a bit (~)

Operador unário, precisa apenas de um operando, inverte cada bit binário individualmente: 0 vira 1 e 1 vira 0.

Bit original	Bit invertido
1	0
0	1

Exemplo

void main() {
  // Validação de bit único
  assert((~1 & 1) == 0);
  assert((~0 & 1) == 1);

  // Exemplo com inteiro multi-bit
  final a = 0x22; // Binário 00100010
  final mask = 0x0f; // Binário 00001111
  assert((a & ~mask) == 0x20); // Inverte mask e faz AND com a, limpa os 4 bits menos significativos
}Code language: PHP (php)

Veja um exemplo completo

void main() {
  // Definir valores de teste
  final value = 0x22;   // Hexadecimal 0x22 = decimal 34, binário 00100010
  final bitmask = 0x0f; // Hexadecimal 0x0f = decimal 15, binário 00001111

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

  // 2. AND com máscara invertida (& ~mask, muito usado para limpar bits baixos)
  print('value & ~bitmask = ${value & ~bitmask}'); // 0x20 = 32
  assert((value & ~bitmask) == 0x20);

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

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

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

  // 6. Deslocamento à direita com sinal >> (número positivo)
  print('value >> 4 = ${value >> 4}'); // 0x02 = 2
  assert((value >> 4) == 0x02);

  // 7. Deslocamento à direita com sinal >> (número negativo, comportamento varia entre plataformas)
  print('-value >> 4 = ${-value >> 4}'); // -0x03 = -3
  assert((-value >> 4) == -0x03);

  // 8. Deslocamento à direita sem sinal >>> (positivo, Dart2.14+)
  print('value >>> 4 = ${value >>> 4}'); // 0x02 = 2
  assert((value >>> 4) == 0x02);

  // 9. Deslocamento à direita sem sinal >>> (negativo, resultado sempre maior que 0)
  print('-value >>> 4 = ${-value >>> 4}');
  assert((-value >>> 4) > 0);
}Code language: PHP (php)

Saída da execução

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

Análise detalhada de cada exemplo

1 AND bit a bit

00100010
00001111
--------
00000010

O resultado final é 00000010, ou seja, o número decimal 2.

2 AND com máscara invertida & ~mask

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

A sequência 11110000 é o resultado de ~mask: todos os bits de 00001111 são invertidos, 0 vira 1 e 1 vira 0

3 OR bit a bit |

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

O bit resultado é 1 enquanto pelo menos um dos bits for 1; apenas se ambos forem 0 o resultado é 0

4 XOR bit a bit ^

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

Só obtemos 1 quando os bits superior e inferior forem diferentes; se forem iguais o resultado é 0

5 Deslocamento à esquerda << 4

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

6 Deslocamento à direita com sinal >> 4 (número positivo)

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

7 Deslocamento à direita com sinal >> 4 (número negativo)

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

8 Deslocamento à direita sem sinal >>> 4 (número positivo)

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

9 Deslocamento à direita sem sinal >>> 4 (número negativo)

-00100010 >>> 4 = (completa com 0 no lado esquerdo) 00001101...  // resultado sempre maior que 0Code language: JavaScript (javascript)