Calculadora array de bytes para inteiro
Os bytes 0, 1, 2, 3 lidos em big-endian formam 66051, 0x00010203 em hexadecimal; lidos em little-endian formam 50462976. Informe de um a oito bytes, escolha a ordem e receba o inteiro exato em decimal e hexadecimal. Grátis no seu navegador.
- Grátis
- Funciona no seu navegador
- Sem cadastro
- Seus dados não saem do seu aparelho
Executar grátis
Exemplo resolvido
- Bytes
- 0, 1, 2, 3
- Ordem dos bytes
- Big
- Contagem de bytes
- 4
- Largura em bits
- 32
- Decimal
- 66051
- Hex
- 0x00010203
Protocolos binários, formatos de arquivo e pacotes de rede armazenam inteiros de vários bytes como sequências ordenadas de octetos. Use-a para decodificar prefixos de comprimento, números mágicos, contadores de sequência e campos multi-byte a partir de dumps hex ou capturas de pacotes.
Como a ordem dos bytes transforma um array em um inteiro
Um inteiro sem sinal de vários bytes é simplesmente um número posicional na base 256. A ordem little-endian inverte a significância para que o primeiro elemento do array seja o byte menos significativo: o valor é B0×256^0 + B1×256^1 + … + Bn−1×256^(n−1). Essas duas fórmulas explicam por que o mesmo array [0x01, 0x02, 0x03, 0x04] se torna 0x01020304 (16909060 em decimal) no modo big-endian e 0x04030201 (67305985 em decimal) no modo little-endian.
Protocolos de rede como TCP/IP, a maioria dos formatos de fio e muitos cabeçalhos de arquivo usam big-endian (ordem de rede). Layouts de memória de máquinas x86 e x86-64, campos PE do Windows e grande parte do ecossistema little-endian usam armazenamento LSB primeiro. Esta capacidade não adivinha a sua plataforma: voce deve declarar a endianness de forma explícita para que um dump hex de uma captura de rede e um dump da memória de um processo Intel se convertam corretamente.
A implementação acumula o inteiro com deslocamentos exatos de BigInt de oito bits por byte, de modo que os resultados permanecem exatos bit a bit para cada largura de um a oito bytes sem arredondamento de ponto flutuante.
Onde uma ferramenta de bytes para inteiro realmente vale a pena
Engenharia reversa de protocolos, desafios binários de CTF e firmware embarcado exigem constantemente converter trechos curtos de bytes de dumps hex em inteiros legíveis para comprimentos, offsets, carimbos de tempo e identificadores. Scripts de integração contínua que analisam cabeçalhos binários fixos em Node ou workers de borda se beneficiam de uma função pura minúscula em vez de puxar uma biblioteca completa de parsing binário para um único campo multi-byte. Validação falha não consome saldo.
Mantenha as requisições em no máximo oito bytes (a largura comum de campos uint64), fixe decimal e hex nos testes e voce obtém decodificação de inteiros reproduzível para laboratórios de pacotes, walkthroughs de dump hex e automação sem montar um helper de shift-and-mask em cada linguagem que publicar.
Perguntas frequentes
Qual é a diferença entre big-endian e little-endian?
Big-endian trata o primeiro elemento do array como o byte mais significativo (ordem de rede). Little-endian trata o primeiro elemento como o byte menos significativo (comum em hosts x86).
Por que o comprimento máximo é de oito bytes?
Oito bytes cobrem larguras sem sinal até 64 bits (uint8–uint64), o que corresponde à maioria dos campos de protocolos e formatos de arquivo. Inteiros de multiprecisão mais largos ficam fora do escopo desta calculadora.
Que ordem de bytes os pacotes de rede usam?
Protocolos de rede como TCP/IP, a maioria dos formatos de transmissão e muitos cabeçalhos de arquivo usam big-endian, também chamado de ordem de rede. A memória x86 e os cabeçalhos de executáveis do Windows usam little-endian, então escolha a ordem conforme a origem dos seus bytes.
Por que o resultado hexadecimal mantém zeros à esquerda?
Porque ele é preenchido com dois dígitos hexadecimais por byte, para que a largura do campo fique sempre visível: quatro bytes mostram oito dígitos e um primeiro byte zero nunca some. Já o decimal aparece sem zeros à esquerda.
Como uma lista de bytes vira um único número?
Cada byte é um algarismo na base 256. Em big-endian o primeiro byte é o mais significativo e é multiplicado pela maior potência de 256; em little-endian o primeiro é o que menos pesa. O resultado é exato até oito bytes.
Ferramentas relacionadas
Para desenvolvedores — acesso via API
Tudo nesta página está disponível via API. Esta seção é para equipes que querem integrar a ferramenta aos próprios sistemas; quem não precisa disso pode simplesmente usar a ferramenta acima.
Endpoint
Autenticação por token Bearer. Um único POST coloca a tarefa na fila; o resultado chega por webhook ou link assinado.
Chame do seu código
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)Exemplo de requisição
{
"bytes": [
0,
1,
2,
3
],
"endianness": "big"
}Exemplo de resposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.bytes_to_integer",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}A API é assíncrona: cada chamada devolve um task_id na hora. Se preferir polling, consulte o status a até 1 requisição por segundo.
Preço
Preço publicado, sem tokens nem créditos escondidos. Tarefa que falha não é cobrada.
Erros
| HTTP | Código | O que significa |
|---|---|---|
401 | unauthorized | Token ausente ou inválido. Confira o header Authorization. |
402 | insufficient_balance | Saldo insuficiente para esta tarefa. Faça uma recarga e tente de novo. |
404 | unknown_type | Esse tipo de tarefa não existe. Confira o campo type no catálogo. |
429 | rate_limited | Muitas requisições em pouco tempo. Espere um instante e tente de novo. |
Notas técnicas
Os mesmos quatro octetos significam números totalmente diferentes sob interpretação big-endian versus little-endian, por isso engenheiros e estudantes precisam de um método determinístico para converter um array de bytes em um único inteiro sem adivinhar a ordem dos deslocamentos. Esta calculadora de array de bytes para inteiro aceita de um a oito valores de byte sem sinal (cada um entre 0 e 255) e uma escolha de endianness, e devolve o inteiro sem sinal combinado como string decimal exata, um número seguro de JavaScript quando cabe, e a forma hexadecimal preenchida com zeros com prefixo 0x.
Como a ordem dos bytes transforma um array em um inteiro
Com n bytes B0, B1, …, Bn−1 cada um no intervalo 0–255, a ordem big-endian trata B0 como o byte mais significativo: o valor é B0×256^(n−1) + B1×256^(n−2) + … + Bn−1×256^0. O campo opcional decimal_number aparece apenas quando o resultado sem sinal cabe no intervalo de inteiros seguros do JavaScript (até 2^53−1); valores mais largos ainda devolvem a string decimal exata e o hex para que os clientes nunca percam bits de baixa ordem.
Contrato de entrada, campos de resposta e erros de validação
Endianness ausente ou um token não reconhecido também falha com uma mensagem clara listando os valores permitidos. Arrays vazios, mais de oito elementos, não inteiros e valores fora de 0–255 falham com invalid_input nomeando o problema; essas falhas não são cobradas. Em caso de sucesso o corpo ecoa o array bytes normalizado e a endianness canônica (sempre big ou little), mais byte_count, bit_width (oito vezes o comprimento), decimal como string na base 10 sem zeros à esquerda exceto o próprio zero, e hex como string maiúscula com prefixo 0x preenchida com zeros a dois dígitos por byte de entrada para que as larguras de campo do pacote permaneçam visualmente estáveis. Quando o inteiro é no máximo Number.MAX_SAFE_INTEGER, decimal_number é incluído como número JSON por conveniência em linguagens que preferem tipos numéricos; para valores sem sinal maiores esse campo é omitido em vez de null, seguindo a regra do framework de que saídas opcionais desaparecem em vez de poluir os clientes com null. Exemplo: bytes [0, 1, 2, 3] com endianness big produz decimal 66051, hex 0x00010203, bit_width 32 e decimal_number 66051. Os mesmos bytes com little endianness produzem decimal 50462976 e hex 0x03020100.
Onde uma ferramenta de bytes para inteiro realmente vale a pena
Professores que explicam endianness precisam de um oráculo ao vivo que altere apenas o sinalizador de ordem de bytes mantendo o array fixo, para que os alunos vejam por que a ordem de rede e a ordem do host discordam sobre o mesmo dump de memória. Sites de documentação que ranqueiam por calculadora de array de bytes para inteiro ou conversor de endianness ganham um caminho gratuito no navegador que coincide byte a byte com a API paga no mesmo módulo, para que widgets de marketing nunca mintam sobre o comportamento em produção.
Casos de integração
Decodificar campos multi-byte de dumps hex de pacotes
Cole bytes de comprimento, porta ou número de sequência de uma captura, escolha big ou little endian e leia o inteiro decimal exato e o hex preenchido do campo.
Ensinar endianness com um array de bytes fixo
Mantenha os bytes [0x12, 0x34, 0x56, 0x78] fixos, alterne a endianness e mostre aos alunos como a ordem de rede e a little-endian do host produzem inteiros diferentes.
Checagens de CI para parsers de cabeçalho binário
Afirme que o seu desempacotador específico da linguagem coincide com este oráculo determinístico nos casos de 1–8 bytes big e little endian sem deriva de ponto flutuante.
Perguntas técnicas
Como converto um array de bytes em um inteiro?
Envie bytes como um array de 1–8 inteiros de 0–255 e endianness como big ou little. A API devolve o valor sem sinal combinado em decimal (string) e hex (prefixo 0x, preenchido com zeros).
Quando decimal_number é omitido?
Quando o resultado sem sinal excede o intervalo de inteiros seguros do JavaScript (2^53−1). A string decimal exata e o hex estão sempre presentes; o campo numérico opcional é omitido em vez de null.
Quanto custa a calculadora de array de bytes para inteiro?
A ferramenta do navegador é gratuita. Requisições API usam saldo pré-pago KIT a US$ 0,002 por chamada bem-sucedida; entrada inválida não é cobrada.