Calculadora Adler-32
Obtenha o checksum Adler-32 de qualquer texto, a soma dupla usada dentro do zlib: Wikipedia dá 11e60398, com A em 920 e B em 4582. Útil para conferir dados comprimidos ou exercícios com a RFC 1950. 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
- Texto
- Wikipedia
- Resultado
- 11e60398
- Soma de verificação Adler32
- 11e60398
- Hex
- 11e60398
- Decimal
- 300.286.872
Adler-32 é um checksum de trinta e dois bits projetado por Mark Adler e usado no zlib e na família de formatos DEFLATE. Diferente de uma verificação de redundância cíclica, mantém duas somas correntes sobre os bytes da mensagem e as combina em um inteiro sem sinal rápido de calcular em CPUs comuns. Engenheiros que validam cargas comprimidas, estudantes da RFC 1950 e equipes de suporte que comparam trailers de logs de dispositivos costumam precisar do mesmo resultado de livro para uma string curta: A inicial igual a um, B inicial igual a zero, ambas reduzidas módulo sessenta e cinco mil quinhentos e vinte e um, depois B deslocada dezesseis bits à esquerda e combinada com A. Esta ferramenta de checksum Adler-32 aceita texto não vazio, codifica-o como UTF-8, executa esse laço determinístico e devolve o valor completo de trinta e dois bits como oito dígitos hexadecimais minúsculos junto com o inteiro decimal, os parciais A e B e um resumo curto.
O que o Adler-32 calcula e por que a palavra hex importa
Adler-32 trata cada mensagem como uma sequência de bytes e atualiza dois acumuladores. O primeiro, chamado A, começa em um e soma cada byte, reduzindo módulo sessenta e cinco mil quinhentos e vinte e um após cada passo. O segundo, chamado B, começa em zero e soma o valor atual de A depois de cada byte, de novo módulo o mesmo primo.
Quando o fluxo termina, o checksum é formado colocando B nos dezesseis bits altos e A nos dezesseis bits baixos de um inteiro sem sinal de trinta e dois bits. Essa construção é exatamente a definição da RFC 1950 e a implementação do zlib, de modo que a string de verificação conhecida Wikipedia produz o hexadecimal onze e seis zero três nove oito.
A resposta também ecoa o inteiro decimal, os valores A e B separados, o rótulo de algoritmo Adler-32, a contagem de bytes UTF-8 e o texto original para que os clientes mostrem uma linha de auditoria completa sem recalcular metadados. Como Adler-32 não é resistente a colisões nem possui chave, trate-o como verificação rápida de integridade ou de enquadramento, não como prova de autenticidade; prefira digests da família SHA quando a intenção de busca for hash criptográfico e não um checksum rolante no estilo zlib.
Para que serve um checksum Adler-32 na prática
Autores de compressão e estudantes de zlib usam uma calculadora de checksum Adler-32 para verificar parciais A e B calculados à mão contra a definição da RFC 1950 sem escrever um laço de soma modular em cada linguagem. Plataformas de ensino e plugins LMS precisam de um oráculo determinístico que rejeite entrada vazia em vez de devolver um para a mensagem vazia, para que autoavaliadores distingam respostas ausentes de um checksum real.
Sites de conteúdo que ranqueiam por Adler-32 checksum ou calculadora Adler32 se beneficiam de uma ferramenta ao vivo cujo caminho gratuito coincide byte a byte com a automação paga no mesmo módulo puro. Falhas de validação nunca consomem saldo após a rejeição. Combine com landings de CRC-32 ou de hash criptográfico somente quando a intenção de busca for além de uma checagem de duas somas no estilo zlib — mantenha esta página focada em Adler-32 para que a intenção SEO permaneça nítida e não canibalize landings de CRC-8 ou SHA-256.
Casos de uso
Checagens de trailer zlib e DEFLATE
Verifique se uma string de carga produz o trailer Adler-32 esperado segundo a RFC 1950 antes de comparar logs de fluxos comprimidos ou vetores de teste unitário.
Demonstrações de soma modular em sala
Professores mostram o valor clássico de verificação da Wikipedia e deixam os alunos recalcular outras strings curtas sem instalar uma biblioteca de compressão.
Perguntas frequentes
Quais parâmetros Adler-32 esta ferramenta usa?
O perfil padrão do zlib: módulo 65521, A começa em 1, B começa em 0, o checksum é (B deslocado 16 à esquerda) ou A. A verificação documentada para Wikipedia em ASCII é 11e60398.
O que acontece se o texto estiver vazio?
Uma string não vazia é obrigatória; entrada vazia não é tratada como checksum bem-sucedido de 00000001.
A calculadora de checksum Adler-32 é gratuita?
A ferramenta no navegador roda grátis no seu dispositivo.
Adler-32 é um hash criptográfico?
Não. Adler-32 é uma verificação rápida de integridade de trinta e dois bits usada pelo zlib. Use SHA-256 ou similar quando precisar de resistência a colisões ou autenticação.
Por que o checksum muda com acentos ou emojis?
Porque o texto vira bytes UTF-8 antes das somas, e caracteres como é ou um emoji ocupam mais de um byte. Cada um desses bytes conta, exatamente como um compressor veria o mesmo texto em UTF-8.
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/enc/adler32 \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"Wikipedia"}'const res = await fetch("https://api.kit.forhosting.com/enc/adler32", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "Wikipedia"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/enc/adler32",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "Wikipedia"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/enc/adler32", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"Wikipedia"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"Wikipedia"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/enc/adler32", 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
{
"text": "Wikipedia"
}Exemplo de resposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.adler32",
"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
Entrada vazia é rejeitada com invalid_input para que quem chama nunca confunda um campo ausente com o checksum conhecido da mensagem vazia, que vale um.
Contrato de entrada, erros de string vazia e formato JSON da resposta
Entrada vazia é rejeitada de propósito em vez de devolver o valor teórico da mensagem vazia zero zero zero zero zero zero zero um, para que a UX do produto e os autoavaliadores distingam respostas ausentes de um checksum real. Fixe tanto um caminho de sucesso quanto o erro de entrada vazia na integração contínua para que mudanças acidentais de módulo ou de inicialização não sejam publicadas sem aviso. Campos nulos opcionais são omitidos em vez de emitidos como null, conforme o contrato do renderizador declarativo para formulários web limpos. Envie um corpo JSON com um único campo de string obrigatório chamado text: qualquer sequência não vazia de caracteres que você deseja verificar. Os aliases input, value, s, data, message e payload são aceitos para o mesmo campo, para que stubs de SDK e posts de formulário permaneçam flexíveis. A string é codificada como UTF-8 antes do laço Adler, de forma que caracteres multi-byte contribuem com cada unidade de código exatamente como um compressor faria ao receber o mesmo fluxo UTF-8. text ausente, valor que não é string ou string vazia falham com invalid_input e uma mensagem clara de que uma string não vazia é obrigatória; essas falhas não são cobradas na API pré-paga. Em sucesso o corpo inclui result, adler32 e hex com o mesmo checksum hexadecimal de oito dígitos minúsculos; decimal com o inteiro sem sinal de trinta e dois bits; a e b com os parciais finais de dezesseis bits baixo e alto; algorithm fixo em Adler-32; input_bytes igual ao comprimento UTF-8; text ecoando a entrada; e message resumindo a contagem de bytes e o resultado hex.
Onde uma API de checksum Adler-32 se paga e como funciona o preço
Use a ferramenta gratuita no navegador para checagens pontuais; use a API KIT pré-paga a partir de backends, funções serverless e SDKs quando precisar de um contrato estável sob saldo a US$ 0,002 por item bem-sucedido. Mantenha as cargas em tamanhos de texto ordinários adequados a uma chamada de item em um Worker isolate; esta ferramenta é para strings curtas e trechos de protocolo, não para blobs binários de vários megabytes.
Casos de integração
Fixtures de CI para ajudas de integridade
Pipelines fixam saídas hex Adler-32 determinísticas e o erro de entrada vazia para que mudanças acidentais de módulo ou de inicialização falhem rápido.
Perguntas técnicas
Como calcular um checksum Adler-32 de um texto?
Envie JSON com um campo de string não vazio text. A API codifica a string em UTF-8, executa Adler-32 conforme zlib e a RFC 1950, e devolve o valor de trinta e dois bits como oito dígitos hex minúsculos em result, adler32 e hex.