Operadores bit a bit y de desplazamiento Dart

Opera con cada bit individual de la representación binaria de los números, solo se usa con números enteros

Tabla de operadores bit a bit y operadores de desplazamiento

Operador	Nombre	Regla de cálculo
&	AND bit a bit	El bit resultado solo es 1 cuando los bits binarios correspondientes son ambos 1, en cualquier otro caso es 0
|	OR bit a bit	El bit resultado es 1 si al menos uno de los bits binarios coincidentes vale 1, sino es 0
^	XOR bit a bit (OR exclusivo)	El bit resultado es 1 cuando los bits binarios correspondientes son distintos, si son iguales vale 0
~expr	Negación bit a bit (operador unario)	Invierte todos los bits binarios: 0 ↔ 1, el 0 pasa a ser 1 y el 1 pasa a ser 0
<<	Desplazamiento hacia la izquierda Shift left	Toda la secuencia binaria se desplaza N posiciones a la izquierda, rellenando con ceros por la derecha
>>	Desplazamiento derecho con signo Shift right	La cadena binaria se mueve N posiciones a la derecha, rellenando por la izquierda con el bit de signo (0 para positivos, 1 para negativos)
>>>	Desplazamiento derecho sin signo Unsigned shift right	La secuencia binaria se desplaza N posiciones a la derecha, siempre rellenando con ceros por la izquierda; los números negativos se convierten primero a entero de 32 bits sin signo antes de desplazar

Operador AND bit a bit (&)

El bit resultado vale 1 únicamente si ambos bits correspondientes son 1; en cualquier otro caso el bit es 0.

Bit primer número	Bit segundo número	Resultado operación
1	1	1
1	0	0
0	1	0
0	0	0

Ejemplo

void main() {
  // Comprobación bit individual
  assert((1 & 1) == 1);
  assert((1 & 0) == 0);
  assert((0 & 1) == 0);
  assert((0 & 0) == 0);

  // Ejemplo con entero multi-bit
  final a = 0x22; // Binario 00100010
  final b = 0x0f; // Binario 00001111
  assert((a & b) == 0x02); // Resultado 00000010
}Lenguaje del código: PHP (php)

Operador OR bit a bit (|)

El bit resultado es 1 si al menos uno de los dos bits coincidentes es 1; solo será 0 si ambos bits son 0.

Bit primer número	Bit segundo número	Resultado operación
1	1	1
1	0	1
0	1	1
0	0	0

void main() {
  // Comprobación bit individual
  assert((1 | 1) == 1);
  assert((1 | 0) == 1);
  assert((0 | 1) == 1);
  assert((0 | 0) == 0);

  // Ejemplo con entero multi-bit
  final a = 0x22; // Binario 00100010
  final b = 0x0f; // Binario 00001111
  assert((a | b) == 0x2f); // Resultado 00101111
}Lenguaje del código: PHP (php)

Operador XOR bit a bit (^)

El bit resultado es 1 cuando los dos bits correspondientes tienen valores distintos; si son iguales el resultado es 0.

Bit primer número	Bit segundo número	Resultado operación
1	1	0
1	0	1
0	1	1
0	0	0

Ejemplo

void main() {
  // Comprobación bit individual
  assert((1 ^ 1) == 0);
  assert((1 ^ 0) == 1);
  assert((0 ^ 1) == 1);
  assert((0 ^ 0) == 0);

  // Ejemplo con entero multi-bit
  final a = 0x22; // Binario 00100010
  final b = 0x0f; // Binario 00001111
  assert((a ^ b) == 0x2d); // Resultado 00101101
}Lenguaje del código: PHP (php)

Operador negación bit a bit (~)

Operador unario, solo requiere un operando, invierte cada bit binario uno por uno: el 0 pasa a ser 1 y el 1 pasa a ser 0.

Bit original	Bit invertido
1	0
0	1

Ejemplo

void main() {
  // Comprobación bit individual
  assert((~1 & 1) == 0);
  assert((~0 & 1) == 1);

  // Ejemplo con entero multi-bit
  final a = 0x22; // Binario 00100010
  final mask = 0x0f; // Binario 00001111
  assert((a & ~mask) == 0x20); // Niega mask y hace AND con a, borra los 4 bits bajos
}Lenguaje del código: PHP (php)

Veamos un ejemplo completo

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

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

  // 2. AND con máscara negada (& ~mask, usado habitualmente para borrar bits bajos)
  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. Desplazamiento izquierdo <<
  print('value << 4 = ${value << 4}'); // 0x220 = 544
  assert((value << 4) == 0x220);

  // 6. Desplazamiento derecho con signo >> (número positivo)
  print('value >> 4 = ${value >> 4}'); // 0x02 = 2
  assert((value >> 4) == 0x02);

  // 7. Desplazamiento derecho con signo >> (número negativo, comportamiento variable entre plataformas)
  print('-value >> 4 = ${-value >> 4}'); // -0x03 = -3
  assert((-value >> 4) == -0x03);

  // 8. Desplazamiento derecho sin signo >>> (positivo, Dart2.14+)
  print('value >>> 4 = ${value >>> 4}'); // 0x02 = 2
  assert((value >>> 4) == 0x02);

  // 9. Desplazamiento derecho sin signo >>> (negativo, resultado siempre mayor que 0)
  print('-value >>> 4 = ${-value >>> 4}');
  assert((-value >>> 4) > 0);
}Lenguaje del código: PHP (php)

Salida de ejecución

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

Desglose paso a paso de cada ejemplo

1 AND bit a bit

00100010
00001111
--------
00000010

El resultado final es 00000010, es decir el número decimal 2.

2 AND con máscara negada & ~mask

00100010
11110000  // ~00001111
---------
00100000  // 0x20 = 32Lenguaje del código: JavaScript (javascript)

La secuencia 11110000 es el resultado de ~mask: se invierten todos los bits de 00001111, 0 pasa a 1 y 1 pasa a 0

3 OR bit a bit |

00100010
00001111
---------
00101111  // 0x2f = 47Lenguaje del código: JavaScript (javascript)

El bit resultado es 1 mientras al menos uno de los bits sea 1; solo si ambos son 0 el resultado es 0

4 XOR bit a bit ^

00100010
00001111
---------
00101101  // 0x2d = 45Lenguaje del código: JavaScript (javascript)

Solo se obtiene 1 cuando los bits superior e inferior son distintos; si coinciden el resultado es 0

5 Desplazamiento izquierdo << 4

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

6 Desplazamiento derecho con signo >> 4 (número positivo)

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

7 Desplazamiento derecho con signo >> 4 (número negativo)

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

8 Desplazamiento derecho sin signo >>> 4 (número positivo)

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

9 Desplazamiento derecho sin signo >>> 4 (número negativo)

-00100010 >>> 4 = (rellena con 0 por la izquierda) 00001101...  // resultado siempre mayor que 0Lenguaje del código: JavaScript (javascript)