piapia123
es

Calculadora de operaciones bit a bit

Conversión

Todo se ejecuta en tu navegador: no se sube nada

Entrada
Arrastra un archivo aquí para cargarlo
Resultado

Diez operaciones bit a bit caben en una sola herramienta porque sus entradas y salidas son idénticas y solo cambia el operador: repartidas en diez páginas, el contenido sería casi el mismo y competirían por las mismas búsquedas. ¿Por qué no usar los operadores bit a bit del propio lenguaje? Porque convierten primero a enteros de 32 bits con signo: `1 << 31` da `-2147483648`, `0xFFFFFFFF` se lee como `-1` y lo que pasa de 32 bits se trunca en silencio, sin ningún error. Quien recurre a una herramienta así suele traer máscaras de 64 bits, fragmentos de hash y enteros sacados de UUID, y todos ellos salen mal. Aquí se usa BigInt de principio a fin: `<<` desplaza cuanto haga falta y `&` nunca se vuelve negativo. La anchura de bits define el módulo y la presentación. Con 32 bits los operandos se reducen antes módulo 2³² (así `-1` pasa a ser todo unos, que es justo lo que significa el complemento a dos) y los resultados se muestran rellenados a 32 bits. Con «sin límite» no se hace ninguna de las dos cosas, así que `~0` es `-1`: correcto en matemáticas, pero no lo que quiere quien trabaja con máscaras, y por eso el valor predeterminado es 32.

Funciones

  • Diez operaciones: AND, OR, XOR, XNOR, NAND, NOR, NOT, desplazamiento a la izquierda, a la derecha e inversión del orden de los bits
  • Cada resultado muestra decimal, binario, hexadecimal y número de bits en una fila que se puede copiar
  • La entrada admite los prefijos 0b / 0o / 0x y el decimal; los guiones bajos y los espacios sirven de separador
  • Anchura de 8, 16, 32 o 64 bits, o sin límite para precisión arbitraria
  • Con anchura fijada los operandos se reducen antes: `-1` en 8 bits pasa a 255, como se espera
  • El desplazamiento a la izquierda nunca desborda a negativo (como sí hace `1 << 31` en JavaScript)
  • Un operando por línea, así que toda una lista se puede operar con la misma máscara
  • Exacto con máscaras de 64 bits y enteros enormes: nada pasa por coma flotante

Cómo se usa

  1. Pega los operandos, uno por línea (se admiten los prefijos 0b / 0o / 0x)
  2. Elige la operación y la anchura de bits, y escribe el segundo operando
  3. El resultado se actualiza mientras escribes; copia un valor concreto desde su fila

Preguntas frecuentes

¿Por qué el resultado no coincide con el de mi código?
Lo más probable es que estés usando los operadores bit a bit de tu lenguaje, que trabajan con enteros de 32 bits con signo. Tres diferencias típicas: `1 << 31` allí es `-2147483648` y aquí `2147483648`; `0xFFFFFFFF` allí se lee como `-1`; y los operandos de más de 32 bits se truncan en silencio. Con la anchura en «sin límite» ves el resultado sin truncar, y con 32 bits coincides con el comportamiento del lenguaje salvo que se muestra sin signo.
¿Qué anchura de bits elijo?
La que corresponda a tu entorno de destino. `int` de C o aritmética de bits en JavaScript: 32 bits. Arrays uint8, canales RGB, campos de protocolo: 8 o 16 bits. Máscaras de 64 bits y hashes: 64 bits. Solo la respuesta matemática: sin límite. La anchura solo afecta a la reducción y al relleno de ceros; no cambia si la operación en sí es correcta.
¿El desplazamiento a la derecha es aritmético o lógico?
Lógico (sin signo). Al fijar una anchura los operandos ya se han reducido, así que todos son no negativos y no hay signo que extender. Por eso `0xFFFFFFFF >> 4` da `0x0FFFFFFF`. Si necesitas un desplazamiento aritmético (conservar el bit de signo de un valor negativo), pon la anchura en «sin límite»: ahí el `>>` de BigInt es aritmético para los negativos.

Herramientas relacionadas