Calculadora array de bytes a entero
Los bytes 0, 1, 2, 3 leídos en big-endian forman 66051, 0x00010203 en hexadecimal; leídos en little-endian forman 50462976. Introduzca de uno a ocho bytes, elija el orden y obtenga el entero exacto en decimal y hexadecimal. Gratis en su navegador.
- Gratis
- Funciona en su navegador
- Sin registro
- Sus datos no salen de su equipo
Ejecutar — gratis
Ejemplo resuelto
- Bytes
- 0, 1, 2, 3
- Orden de bytes
- Big
- Número de bytes
- 4
- Ancho en bits
- 32
- Decimal
- 66051
- Hex
- 0x00010203
Los protocolos binarios, los formatos de archivo y los paquetes de red almacenan enteros de varios bytes como secuencias ordenadas de octetos. Úsela para decodificar prefijos de longitud, números mágicos, contadores de secuencia y campos multi-byte a partir de volcados hex o capturas de paquetes.
Cómo el orden de bytes convierte un array en un entero
Un entero sin signo de varios bytes es simplemente un número posicional en base 256. El orden little-endian invierte la significancia, de modo que el primer elemento del array es el byte menos significativo: el valor es B0×256^0 + B1×256^1 + … + Bn−1×256^(n−1). Esas dos fórmulas explican por qué el mismo array [0x01, 0x02, 0x03, 0x04] se convierte en 0x01020304 (16909060 en decimal) en modo big-endian y en 0x04030201 (67305985 en decimal) en modo little-endian.
Protocolos de red como TCP/IP, la mayoría de formatos de cable y muchos encabezados de archivo usan big-endian (orden de red). Los mapas de memoria de máquinas x86 y x86-64, los campos PE de Windows y gran parte del ecosistema little-endian almacenan LSB primero. Esta capacidad no adivina su plataforma: usted debe indicar la endianness de forma explícita para que un volcado hex de una captura de red y un volcado de la memoria de un proceso Intel se conviertan correctamente.
La implementación acumula el entero con desplazamientos exactos de BigInt de ocho bits por byte, de modo que los resultados permanecen exactos bit a bit para cada anchura de uno a ocho bytes sin redondeo en coma flotante.
Dónde una herramienta de bytes a entero aporta valor real
La ingeniería inversa de protocolos, los retos binarios de CTF y el firmware embebido exigen convertir con frecuencia tramos cortos de bytes de volcados hex en enteros legibles para longitudes, desplazamientos, marcas de tiempo e identificadores. Los scripts de integración continua que analizan encabezados binarios fijos en Node o workers de borde se benefician de una función pura minúscula en lugar de arrastrar una biblioteca completa de análisis binario por un solo campo multi-byte. La validación fallida no consume saldo.
Mantenga las peticiones en como máximo ocho bytes (la anchura habitual de campos uint64), fije decimal y hex en sus pruebas, y obtendrá decodificación de enteros reproducible para laboratorios de paquetes, recorridos de volcados hex y automatización sin montar un ayudante de desplazamiento y máscara en cada lenguaje que publique.
Preguntas frecuentes
¿Cuál es la diferencia entre big-endian y little-endian?
Big-endian trata el primer elemento del array como el byte más significativo (orden de red). Little-endian trata el primer elemento como el byte menos significativo (habitual en anfitriones x86).
¿Por qué la longitud máxima es de ocho bytes?
Ocho bytes cubren anchuras sin signo hasta 64 bits (uint8–uint64), lo que coincide con la mayoría de campos de protocolos y formatos de archivo. Enteros multiprecisión más anchos quedan fuera del alcance de esta calculadora.
¿Qué orden de bytes usan los paquetes de red?
Los protocolos de red como TCP/IP, la mayoría de los formatos de transmisión y muchas cabeceras de archivo usan big-endian, también llamado orden de red. La memoria de x86 y las cabeceras de ejecutables de Windows usan little-endian, así que elija el orden según el origen de sus bytes.
¿Por qué el resultado hexadecimal conserva ceros a la izquierda?
Porque se rellena a dos dígitos hexadecimales por byte, de modo que el ancho del campo se ve siempre: cuatro bytes muestran ocho dígitos y un primer byte a cero nunca desaparece. El decimal, en cambio, se muestra sin ceros iniciales.
¿Cómo se convierte una lista de bytes en un solo número?
Cada byte es una cifra en base 256. En big-endian el primer byte es el más significativo y se multiplica por la mayor potencia de 256; en little-endian el primero es el que menos pesa. El resultado es exacto hasta ocho bytes.
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/dev/bytes-to-integer \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"bytes":[0,1,2,3],"endianness":"big"}'const res = await fetch("https://api.kit.forhosting.com/dev/bytes-to-integer", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"bytes": [
0,
1,
2,
3
],
"endianness": "big"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/dev/bytes-to-integer",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"bytes": [
0,
1,
2,
3
],
"endianness": "big"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/bytes-to-integer", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"bytes":[0,1,2,3],"endianness":"big"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"bytes":[0,1,2,3],"endianness":"big"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/bytes-to-integer", 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
{
"bytes": [
0,
1,
2,
3
],
"endianness": "big"
}Ejemplo de respuesta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.bytes_to_integer",
"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.
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
Los mismos cuatro octetos representan números totalmente distintos según se interpreten en big-endian o little-endian, por lo que ingenieros y estudiantes necesitan un método determinista para convertir un array de bytes en un solo entero sin adivinar el orden de los desplazamientos. Esta calculadora de array de bytes a entero acepta de uno a ocho valores de byte sin signo (cada uno entre 0 y 255) y una elección de endianness, y devuelve el entero sin signo combinado como cadena decimal exacta, un número seguro de JavaScript cuando cabe, y la forma hexadecimal rellenada con ceros y prefijo 0x.
Cómo el orden de bytes convierte un array en un entero
Con n bytes B0, B1, …, Bn−1 cada uno en el rango 0–255, el orden big-endian trata B0 como el byte más significativo: el valor es B0×256^(n−1) + B1×256^(n−2) + … + Bn−1×256^0. El campo opcional decimal_number aparece solo cuando el resultado sin signo cabe en el rango de enteros seguros de JavaScript (hasta 2^53−1); los valores más anchos siguen devolviendo la cadena decimal exacta y el hex para que los clientes no pierdan bits de bajo orden.
Contrato de entrada, campos de respuesta y errores de validación
La ausencia de endianness o un token no reconocido también falla con un mensaje claro que enumera los valores permitidos. Envíe un cuerpo JSON con dos campos obligatorios. bytes es un array no vacío de uno a ocho enteros de 0 a 255 (también se aceptan por elemento cadenas numéricas, hex con prefijo 0x y binario con prefijo 0b). endianness debe ser big o little; los alias aceptados incluyen be, le, big_endian, little_endian, msb y lsb para que los envoltorios SDK y los formularios humanos se mapeen al mismo manejador. Arrays vacíos, más de ocho elementos, no enteros y valores fuera de 0–255 fallan con invalid_input nombrando el problema; esos fallos no se facturan. En caso de éxito el cuerpo devuelve el array bytes normalizado y la endianness canónica (siempre big o little), más byte_count, bit_width (ocho veces la longitud), decimal como cadena en base 10 sin ceros a la izquierda salvo el propio cero, y hex como cadena en mayúsculas con prefijo 0x rellenada a dos dígitos por byte de entrada para que las anchuras de campo del paquete se vean estables. Cuando el entero es como máximo Number.MAX_SAFE_INTEGER, se incluye decimal_number como número JSON por comodidad en lenguajes que prefieren tipos numéricos; para valores sin signo mayores ese campo se omite en lugar de ponerse a null, siguiendo la regla del marco de que las salidas opcionales desaparecen en vez de contaminar a los clientes con null. Ejemplo: bytes [0, 1, 2, 3] con endianness big produce decimal 66051, hex 0x00010203, bit_width 32 y decimal_number 66051. Los mismos bytes con little endianness producen decimal 50462976 y hex 0x03020100.
Dónde una herramienta de bytes a entero aporta valor real
Los docentes que explican la endianness necesitan un oráculo en vivo que solo cambie el indicador de orden de bytes manteniendo el array fijo, para que el alumnado vea por qué el orden de red y el del anfitrión discrepan sobre el mismo volcado de memoria. Los sitios de documentación que compiten por «calculadora array de bytes a entero» o «conversor de endianness» ganan una ruta gratuita en el navegador que coincide byte a byte con la API de pago sobre el mismo módulo, de modo que los widgets de marketing no mienten sobre el comportamiento en producción. Como la implementación es pure parse de nivel A, cada llamada exitosa cuesta el precio base publicado $0.002 sin tokens de modelo ni red de salida.
Casos de integración
Decodificar campos multi-byte de volcados hex de paquetes
Pegue bytes de longitud, puerto o número de secuencia de una captura, elija big o little endian y lea el entero decimal exacto y el hex rellenado del campo.
Enseñar endianness con un array de bytes fijo
Mantenga fijos los bytes [0x12, 0x34, 0x56, 0x78], cambie la endianness y muestre al alumnado cómo el orden de red y el little-endian del anfitrión producen enteros distintos.
Comprobaciones CI de analizadores de encabezados binarios
Afirme que su desempaquetador específico del lenguaje coincide con este oráculo determinista en casos de 1–8 bytes big y little endian sin deriva de coma flotante.
Preguntas técnicas
¿Cómo convierto un array de bytes en un entero?
Envíe bytes como un array de 1–8 enteros de 0–255 y endianness como big o little. La API devuelve el valor sin signo combinado en decimal (cadena) y hex (prefijo 0x, rellenado con ceros).
¿Cuándo se omite decimal_number?
Cuando el resultado sin signo supera el rango de enteros seguros de JavaScript (2^53−1). La cadena decimal exacta y el hex siempre están presentes; el campo numérico opcional se omite en lugar de ser null.
¿Cuánto cuesta la calculadora de array de bytes a entero?
La herramienta del navegador es gratuita. Las peticiones API usan saldo prepago KIT a $0.002 por llamada exitosa; la entrada inválida no se factura.