Conversor hex a binario
0xFF en binario es 11111111: cada dígito hexadecimal equivale a cuatro bits, así que F se convierte en 1111. Pegue el valor con o sin el prefijo 0x y obtenga el binario corto y la versión alineada por grupos de cuatro. Gratis en su navegador.
- Gratis
- Funciona en su navegador
- Sin registro
- Sus datos no salen de su equipo
Ejecutar — gratis
Ejemplo resuelto
- Valor hexadecimal
- 0xFF
- Entrada original
- 0xFF
- Hex mayúsculas
- FF
- Hex minúsculas
- ff
- Con prefijo
- 0xFF
Un conversor hexadecimal a binario transforma una cadena de dígitos base 16 en el patrón de bits exacto que necesita para máscaras de bits, volcados de firmware y comprobaciones de valor posicional en clase. Pegue un valor como FF, 0xFF o deadbeef; la herramienta valida cada dígito, elimina un prefijo 0x o 0X opcional, mapea cada nibble hex a cuatro bits y devuelve la representación binaria con una lista breve de pasos que puede copiar a notas o pruebas. Esta página se dirige a quienes buscan un conversor hexadecimal a binario, no una calculadora hex a decimal.
Qué significa hexadecimal y cómo se mapea a binario
Hexadecimal es base dieciséis: cada posición de dígito es una potencia de dieciséis, y los dígitos van del cero al nueve y luego de A a F para diez a quince. Binario es base dos: cada posición es una potencia de dos y cada dígito es solo cero o uno. El mapeo entre ambos es especialmente limpio porque dieciséis es dos a la cuarta, de modo que cada dígito hex codifica exactamente cuatro bits—un nibble.
Por eso F se mapea a 1111, A a 1010 y 0 a 0000 al expandir nibble a nibble. Los programadores escriben el prefijo 0x para que una cadena solo de dígitos no se confunda con un literal decimal; este conversor acepta el prefijo cuando está presente y trata las cadenas desnudas igual una vez validados los dígitos. Mayúsculas y minúsculas no importan: a, b, c, d, e, f y sus formas en mayúscula son idénticas.
La forma binaria mínima elimina ceros iniciales (salvo el valor cero), mientras que la forma rellena conserva cuatro bits por cada dígito hex de entrada para que los volcados de registros sigan alineados en límites de nibble. Hojas de trabajo de clase y manuales de CPU usan hex porque un byte son dos dígitos hex y una palabra de treinta y dos bits son ocho.
Convertir a mano es propenso a errores más allá de pocas posiciones; un paso determinista de nibble y valor posicional elimina ese riesgo y sigue mostrando la expansión en entradas cortas para que el alumnado audite el mapeo de bits. Si algún carácter no es un dígito hex tras quitar el prefijo opcional, la conversión se detiene con un error de dígito hex no válido—no hay análisis de mejor esfuerzo que omita basura o invente bits.
Consejos prácticos, límites y búsquedas relacionadas
Prefiera enviar una cadena aunque el valor parezca numérico: los números desnudos solo se aceptan cuando son enteros no negativos escritos con dígitos decimales del cero al nueve, una comodidad para volcados pequeños, no una segunda base. No incruste espacios, comas ni separadores de guion bajo; elimínelos en su cliente antes de llamar si su fuente usa nibbles agrupados.
Sesenta y cuatro dígitos hex cubren enteros de doscientos cincuenta y seis bits, suficiente para la mayoría de palabras de máquina anchas y visualizaciones de hash truncadas; las cadenas más largas se rechazan en lugar de truncarse en silencio.
Esta página se dirige a quienes buscan un conversor hexadecimal a binario, una calculadora hex a binario o una herramienta base 16 a base 2; no es un selector de color, no es un conversor hex a decimal (use ese hermano cuando necesite enteros base 10) y no es una calculadora general de base arbitraria con un parámetro from-base.
Prefiera esta capacidad cuando la fuente ya se sabe hex y solo necesita la cadena de bits; si también debe convertir a decimal, llame a la herramienta hex-a-decimal correspondiente en un segundo paso.
Qué puede hacer con ella
Comprobación de deberes de mapeo hex a bits
El alumnado pega literales hex cortos de hojas de trabajo y compara mapas de nibble escritos a mano y el binario final con un resultado determinista antes de entregar.
Volcados de campos de bits de firmware y registros
Las canalizaciones embebidas convierten valores de registro con prefijo 0x de los registros en cadenas de bits para máscaras, alertas y documentación que muestra cada nibble alineado.
Preguntas frecuentes
¿Qué es la conversión de hexadecimal a binario?
Mapea una cadena de dígitos base 16 a una cadena de bits base 2 equivalente. Como 16 es 2^4, cada dígito hex se expande a exactamente cuatro bits (un nibble).
¿Necesito el prefijo 0x?
No. El prefijo es opcional. Tanto FF como 0xFF se convierten a 11111111.
¿Es gratis el conversor hexadecimal a binario?
La herramienta del navegador es gratis y se ejecuta en local.
¿Por qué cada dígito hexadecimal da exactamente cuatro bits?
Porque dieciséis es dos elevado a la cuarta, de modo que un dígito hexadecimal siempre ocupa cuatro bits, lo que se llama un nibble. Por eso F es 1111, A es 1010 y 0 es 0000.
¿Qué diferencia hay entre el binario corto y el binario completo?
El corto elimina los ceros a la izquierda, salvo cuando el valor es cero. El completo conserva cuatro bits por cada dígito hexadecimal escrito, para que los volcados de registros y las máscaras de bits queden alineados.
Herramientas relacionadas
Para desarrolladores — acceso por API
Todo lo de esta página está disponible por programación. Esta sección es para equipos que quieren integrarlo en sus sistemas; el resto puede usar la herramienta de arriba sin más.
Endpoint de API
¿Prefiere automatizarlo? Un POST autenticado crea la tarea; el resultado llega por webhook o enlace firmado. La misma capacidad también se ejecuta aquí en la web, por email y desde Telegram — y pronto también desde nuestra app.
Llámela desde su stack
curl -X POST https://api.kit.forhosting.com/fmt/hex-binary \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"hex":"0xFF"}'const res = await fetch("https://api.kit.forhosting.com/fmt/hex-binary", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"hex": "0xFF"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/fmt/hex-binary",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"hex": "0xFF"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/fmt/hex-binary", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"hex":"0xFF"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"hex":"0xFF"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/fmt/hex-binary", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Ejemplo de solicitud
{
"hex": "0xFF"
}Ejemplo de respuesta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "fmt.hex_binary",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}La API es asíncrona: la llamada devuelve un task_id al instante y el resultado llega por webhook. El polling está limitado a 1 req/s por tarea.
Precio
Precio publicado — sin tokens ni créditos inventados. Una tarea fallida no se cobra.
Límites
max_hex_digits | 64 |
Errores
| HTTP | Código | Significado |
|---|---|---|
401 | unauthorized | API key ausente o inválida. |
402 | insufficient_balance | El saldo no cubre el precio de la tarea. |
404 | unknown_type | El tipo de tarea no existe. |
429 | rate_limited | Demasiadas peticiones. Use el webhook en vez de sondear. |
Notas técnicas
Caracteres no válidos—letras fuera de A–F, espacios, guiones bajos o un 0x vacío—lanzan un error invalid_input claro en lugar de una cadena de bits incorrecta en silencio. Estudiantes que revisan deberes, ingenieros embebidos que leen volcados de registros y clientes API que normalizan direcciones de memoria necesitan el mismo camino determinista: sin red, sin semillas aleatorias, sin dependencia del reloj.
Cómo llamar a la API y qué devuelve
El valor puede incluir un 0x o 0X inicial; después solo se permiten caracteres del cero al nueve y de A a F (cualquier capitalización). Envíe un cuerpo JSON con un campo de cadena obligatorio hex (alias value, text, n e input). La longitud absoluta está limitada a sesenta y cuatro dígitos hex para que las respuestas de Worker y navegador se mantengan acotadas. Si tiene éxito, la respuesta repite la entrada recortada, establece hex como la cadena de dígitos en mayúsculas sin prefijo, hex_lower en minúsculas, prefixed como un 0x canónico más dígitos en mayúsculas, had_prefix según si el cliente envió 0x, binary como la cadena de bits base 2 mínima sin ceros iniciales (salvo el cero), binary_padded como la expansión de cuatro bits por dígito que conserva la alineación de nibble, base_from dieciséis y base_to dos, digit_count al número de dígitos hex, bit_count a la longitud de la cadena binaria mínima, message a un resumen de una línea y steps a una lista ordenada que registra el manejo del prefijo, la validación, el mapeo de nibble y el binario final. La validación fallida—hex ausente, dígitos vacíos tras 0x, espacios o guiones bajos, caracteres fuera del alfabeto hex o más de sesenta y cuatro dígitos—devuelve invalid_input y nunca se cobra. El precio es un $0.002 fijo por petición correcta con unidad item y precio unitario marginal cero. Prefiera binary cuando necesite una cadena de bits compacta para código, y binary_padded cuando necesite nibbles de ancho fijo para enseñanza o diagramas de campos de bits.
Consejos prácticos, límites y búsquedas relacionadas
Al enseñar, empareje ejemplos: 0xFF se mapea a 11111111, 0xA a 1010, y G o 0x producen invalid_input para que el alumnado vea la ruta de error. Las tareas fallidas que devuelven invalid_input no consumen saldo de prepago, lo que mantiene baratos los scripts exploratorios al fuzzear dígitos no válidos. Las comprobaciones de ida y vuelta son fáciles: convierta un valor conocido como 0xFF a mano o con otra biblioteca de confianza y confirme que binary coincide con 11111111, luego confirme que cambiar una letra a un carácter no válido cambia la respuesta a invalid_input con un mensaje que nombra el dígito malo.
Casos de integración
Pruebas unitarias de analizadores y serializadores
Genere pares hex→binario conocidos y casos deliberados de dígito no válido para que los valores esperados de kata de código se mantengan estables entre lenguajes.
Preguntas técnicas
¿Qué ocurre con un dígito hex no válido?
La API devuelve invalid_input y nombra el problema (por ejemplo una letra inesperada). La validación fallida nunca se cobra.
¿Cuál es la diferencia entre binary y binary_padded?
binary es la cadena de bits mínima sin ceros iniciales (salvo el propio cero). binary_padded conserva cuatro bits por cada dígito hex para preservar la alineación de nibble.