ForHosting KIT · Strumenti per sviluppatori

Checksum Fletcher-32

Ottenga un checksum rapido che si accorge dell'ordine: 123456789 dà il valore Fletcher-32 df09d509, e scambiare caratteri di solito lo cambia. Serve a scoprire corruzioni accidentali o un testo incollato a metà, non come hash di sicurezza. Gratis nel suo browser.

Gratis
Funziona nel suo browser
Senza registrazione
I suoi dati restano sul dispositivo

Esegui gratis nel browser Vedi l'API

Usalo da WebAPIEmailTelegramApp presto

Esempio risolto

Se inserisce

Testo: 123456789

Ottiene

Fletcher32: df09d509
Fletcher32 come intero: 3.741.963.529
Byte: 9
Parole: 5

Fletcher-32 è una checksum rapida e sensibile alla posizione che riduce un messaggio a un residuo a trentadue bit scorrendo parole a sedici bit con due somme modulari. A differenza di un semplice XOR o di una parità additiva, la seconda somma accumula la prima, così l'ordine delle parole conta e molti errori di trasposizione modificano il digest. Questo strumento di checksum Fletcher-32 accetta testo semplice, lo serializza come UTF-8, impacchetta i byte in parole little-endian a sedici bit e restituisce una stringa hex di otto cifre in minuscolo, l'intero senza segno equivalente, i conteggi di byte e parole, e un indicatore empty quando la stringa di origine ha lunghezza zero.

Cosa significa Fletcher-32 e come si formano le parole a sedici bit

Fletcher-32 mantiene due totali accumulati, chiamati per convenzione sum1 e sum2, entrambi ridotti modulo sessantacinquemila cinquecentotrentacinque—cioè due elevato a sedici meno uno. Per ogni parola a sedici bit del messaggio, sum1 viene aumentato della parola e ridotto, e sum2 viene aumentato del nuovo sum1 e ridotto allo stesso modo. La checksum finale colloca sum2 nei sedici bit alti e sum1 nei sedici bit bassi, producendo un valore a trentadue bit di solito mostrato come otto cifre esadecimali.

Questa capacità codifica la stringa di input come UTF-8 affinché caratteri multi-byte come lettere accentate o emoji contribuiscano con i loro byte reali sul filo, poi impacchetta quei byte in little-endian: il primo byte di ogni coppia diventa la metà bassa della parola e il secondo la metà alta. Se la lunghezza UTF-8 è dispari, l'ultima parola è riempita con zero nella metà alta così ogni byte partecipa senza inventare dati extra oltre a un solo pad zero.

L'input vuoto elabora zero parole e produce otto cifre hex zero con empty true, coerente con l'identità naturale delle somme. Fletcher-32 è pensato per controlli rapidi di integrità contro corruzione accidentale e incolla troncati; non è un hash crittografico e non deve essere usato dove serve resistenza deliberata alle collisioni. Se uno strumento di terzi discorda sugli stessi byte UTF-8, usa quasi sempre impacchettamento big-endian, un modulo diverso, Fletcher-16 al posto di Fletcher-32, o Adler-32 con sum1 iniziale diverso.

Casi d'uso

Etichette di integrità rapide per testo breve

Calcoli il Fletcher-32 di frammenti di configurazione, campioni di protocollo o basi di nomi quando le serve un residuo hex compatto sensibile all'ordine delle parole.

Dimostrazioni in aula e supporto

Mostri a studenti e operatori come riordinare o modificare alcuni caratteri cambia l'hex Fletcher-32 senza installare utility locali o librerie crittografiche.

Domande frequenti

Come si formano le parole a sedici bit dal mio testo?

La stringa è codificata in UTF-8 e ogni coppia di byte diventa una parola little-endian (primo byte basso). Un byte finale dispari è riempito con zero nella metà alta. Entrambe le somme si riducono modulo 65535.

Fletcher-32 è un hash crittografico?

No. Fletcher-32 rileva rapidamente corruzione accidentale e molti riordinamenti; non è progettato per resistere a collisione o falsificazione deliberate. Usi strumenti della famiglia SHA quando le serve un digest crittografico.

Come si calcola il checksum Fletcher-32?

Si tengono due somme progressive, entrambe ridotte modulo 65535. Ogni parola da sedici bit si aggiunge alla prima, poi la prima si aggiunge alla seconda. Il risultato mette la seconda somma nei sedici bit alti e la prima in quelli bassi.

Perché un altro strumento dà un risultato Fletcher-32 diverso?

Con gli stessi byte, la causa è quasi sempre una ricetta diversa: parole composte in big-endian invece che in little-endian, un altro modulo, Fletcher-16 al posto di Fletcher-32, oppure Adler-32, che parte con la prima somma a un valore diverso.

Qual è il checksum Fletcher-32 di un testo vuoto?

È 00000000, e il risultato viene segnato come vuoto. Il testo vuoto è ammesso di proposito, così i dati facoltativi ricevono sempre lo stesso valore stabile invece di un errore.

Strumenti correlati

Per sviluppatori — accesso via API

Tutto quello che vedi in questa pagina è disponibile anche via API. Questa sezione è per i team che vogliono integrarlo nei propri sistemi; chi non ne ha bisogno può semplicemente usare lo strumento qui sopra.

Endpoint

POSThttps://api.kit.forhosting.com/enc/fletcher32

Autenticazione con Bearer token: un POST mette in coda l'attività e il risultato arriva via webhook o link firmato.

Chiamala dal tuo stack

curl -X POST https://api.kit.forhosting.com/enc/fletcher32 \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"123456789"}'

const res = await fetch("https://api.kit.forhosting.com/enc/fletcher32", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "text": "123456789"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/enc/fletcher32",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "text": "123456789"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/enc/fletcher32", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"text":"123456789"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"text":"123456789"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/enc/fletcher32", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Esempio di richiesta

{
  "text": "123456789"
}

Esempio di risposta

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "enc.fletcher32",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

L'API è asincrona: ricevi subito un task_id e puoi fare polling fino a 1 richiesta al secondo.

Prezzi

per richiesta$0.002

Prezzo pubblicato, senza token né crediti. Se l'attività fallisce, non paghi.

Errori

HTTP	Codice	Significato
`401`	`unauthorized`	Chiave API mancante o non valida: controlla l'header Authorization.
`402`	`insufficient_balance`	Credito esaurito: ricarica per continuare a eseguire attività.
`404`	`unknown_type`	Tipo di attività sconosciuto: controlla il campo type della richiesta.
`429`	`rate_limited`	Troppe richieste in poco tempo: rallenta e riprova tra qualche secondo.

Note tecniche

Nessuna chiamata di rete, sale casuale o orologio di parete entra nel calcolo: ogni percorso riuscito è aritmetica pura al prezzo base pubblicato $0.002.

Contratto di input, campi di risposta e comportamento con input vuoto

La stringa vuota è consentita di proposito: molte pipeline riassumono campi opzionali e necessitano di un residuo zero stabile invece di un fallimento duro. Algorithm è sempre l'etichetta Fletcher-32 e modulus è sempre la stringa decimale sei-cinque-cinque-tre-cinque così esempi OpenAPI e risposte di supporto citano il profilo senza ambiguità. Non c'è selettore di modalità per Fletcher-16, Adler-32 o CRC-32: se le servono quei digest, usi una capacità dedicata affinché ogni pagina di atterraggio corrisponda a una sola intenzione di ricerca e slug SEO. Invii un corpo JSON con il campo obbligatorio text uguale alla stringa di cui desidera calcolare la checksum. Gli alias input, value, s, string e content sono accettati così form e client brevi restano collegati. Numeri finiti e big integer sono convertiti in stringa prima del calcolo; oggetti, array, booleani, null, Infinity e NaN sollevano invalid_input e non sono fatturati. Quando la lunghezza di origine è zero, la risposta imposta empty a true, fletcher32 a otto zeri, fletcher32_int a zero, bytes a zero e words a zero. Con input non vuoto empty è false, bytes uguaglia la lunghezza UTF-8, words è il soffitto di quella lunghezza diviso due, fletcher32 è il residuo hex a otto cifre in minuscolo senza prefisso zero-x, e fletcher32_int è lo stesso valore come intero senza segno a trentadue bit, utile nei linguaggi che preferiscono i numeri alle stringhe.

Dove un'API di checksum Fletcher-32 genera valore

Gli sviluppatori incollano brevi frammenti di configurazione, campioni di protocollo e basi di nomi file in una calcolatrice Fletcher-32 quando serve un'etichetta di integrità compatta più economica di un hash crittografico e più sensibile all'ordine di una somma semplice. Gli ingegneri di supporto ricalcolano i residui dal testo del ticket per confermare che un dump incollato non sia stato troncato o riordinato in transito. I laboratori didattici usano lo stesso endpoint per mostrare che scambiare due parole a sedici bit cambia il digest hex, illustrando la sensibilità alla posizione senza macchinari crittografici. Poiché l'implementazione è parse pura di livello A, ogni chiamata riuscita costa il prezzo base pubblicato $0.002 senza token di modello né rete in uscita; la validazione fallita non consuma saldo. Mantenga i payload sotto il tetto di caratteri documentato, tratti il campo hex come destinazione canonica di incolla, e otterrà valori Fletcher-32 riproducibili per documentazione, SDK, worker edge e demo in aula senza erigere un servizio di checksum separato.

Casi di integrazione

Vettori golden di CI e fixture di input vuoto

Fissi una stringa nota → digest hex fisso e vuoto → 00000000 così l'integrazione continua intercetta subito derive di endianness, modulo o codifica UTF-8.

Domande tecniche

Come si calcola la checksum Fletcher-32 di un testo?

Invii JSON con text uguale alla sua stringa. Il campo fletcher32 restituisce otto cifre hex minuscole del residuo su byte UTF-8 impacchettati come parole little-endian a sedici bit; fletcher32_int è lo stesso valore come intero senza segno.

Cosa succede con input vuoto?

Il testo vuoto è valido. La risposta imposta empty a true, fletcher32 a 00000000, fletcher32_int a 0, bytes a 0 e words a 0. Un text assente o non stringa solleva invalid_input.

Quanto costa lo strumento di checksum Fletcher-32?

Il widget del browser è gratuito. Le richieste API usano saldo KIT prepagato a $0.002 per chiamata riuscita; l'input non valido non viene fatturato.

Leggi la documentazione completa del KIT →

Esegui gratis nel browser