Codificatore e decodificatore Base16 RFC 4648
Codifichi testo in Base16 secondo la RFC 4648, l'esadecimale standard maiuscolo in cui ogni byte diventa due caratteri: Hello diventa 48656C6C6F. In decodifica accetta dump con spazi o due punti e rifiuta ciò che è malformato. Gratis nel suo browser.
- Gratis
- Funziona nel suo browser
- Senza registrazione
- I suoi dati restano sul dispositivo
Esegui gratis nel browser
Esempio risolto
- Testo
- Hello
- Modalità di calcolo
- Encode
- Risultato
- 48656C6C6F
- Dato in ingresso
- Hello
- Base 16
- 48656C6C6F
- Esadecimale
- 48656C6C6F
RFC 4648 Base16 è la codifica esadecimale standardizzata in maiuscolo: ogni byte in ingresso diventa esattamente due caratteri dell'alfabeto 0-9 e A-F, senza riempimento e senza glifi ambigui. Questo strumento codifica testo UTF-8 semplice in quella forma canonica Base16 e decodifica le stringhe hex Base16 di nuovo in testo, così Lei può incollare in entrambe le direzioni senza installare una libreria crittografica. La codifica emette sempre cifre maiuscole come richiede lo standard; la decodifica accetta il rumore tipico dei copia-incolla, come spazi, due punti e maiuscole e minuscole miste, poi normalizza e convalida prima di convertire.
Che cos'è RFC 4648 Base16 e come funziona l'alfabeto
Base16 è definito nella RFC 4648 come una codifica da binario a testo che mappa ogni ottetto di otto bit su due simboli di un alfabeto di sedici caratteri: le cifre decimali da zero a nove seguite dalle lettere latine maiuscole dalla A alla F. Quell'alfabeto è identico alla nota notazione esadecimale maiuscola usata nei documenti di protocollo, nelle tracce dei pacchetti e in molti manuali hardware.
La codifica scorre l'input da sinistra a destra, divide ogni byte in un nibble alto e uno basso e mappa ogni nibble su un carattere dell'alfabeto, producendo una stringa la cui lunghezza è sempre il doppio del numero di byte. Non esiste un carattere di riempimento né una regola di a capo nella codifica di base; i consumatori che hanno bisogno di interruzioni di riga o separatori li aggiungono solo per la visualizzazione. La decodifica inverte la mappa: ogni due cifre hex consecutive diventano un byte.
Le implementazioni che dichiarano conformità alla RFC 4648 codificano con A–F maiuscole; molti decodificatori accettano anche a–f minuscole per interoperabilità con strumenti che emettono case misto. Spazi e separatori decorativi come due punti, trattini bassi o trattini compaiono spesso nei dump editati a mano e vanno eliminati prima dei controlli di lunghezza e alfabeto; la stringa continua rimanente deve avere lunghezza pari. Quando compare un carattere fuori da 0-9A-Fa-f, o quando il conteggio delle cifre è dispari, il decodificatore deve fallire in modo evidente.
Questa pagina si rivolge a chi cerca un codificatore Base16, un convertitore hex RFC 4648 o codifica e decodifica esadecimale maiuscola online; non è Base64, non è Base32, non è Base58 e non è un convertitore generale di basi per interi grandi arbitrari.
Casi d'uso
Insegnare la RFC 4648 e la notazione esadecimale
In aula si codifica Hello in 48656C6C6F, si ispeziona l'alfabeto 0-9A-F e poi si forza una lunghezza dispari o caratteri non validi per mostrare la convalida rigorosa.
Domande frequenti
Quale alfabeto usa questo codificatore Base16?
L'alfabeto Base16 della RFC 4648: 0123456789ABCDEF. La codifica produce sempre A–F maiuscole; la decodifica accetta anche a–f minuscole e i separatori comuni.
Base16 è uguale a Base64?
No. Base16 mappa ogni byte su due cifre hex di un alfabeto di sedici simboli. Base64 usa sessantaquattro simboli, un impacchettamento più denso e caratteri di riempimento opzionali.
Converte grandi interi hex in decimale?
No. Tratta l'input come una sequenza opaca di byte secondo la RFC 4648 Base16, non come un singolo intero a precisione multipla. Usi gli strumenti dei formati numerici per convertire numeri interi da hex a decimale.
Il codificatore Base16 è gratuito?
Lo strumento del browser è gratuito e funziona in locale.
Posso decodificare hex con spazi, due punti o minuscole?
Sì. Spazi, due punti, trattini bassi e trattini vengono tolti e le minuscole dalla a alla f sono accettate, quindi un dump copiato da un log si decodifica così com'è. Ciò che resta deve avere un numero pari di cifre.
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
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/base16-rfc4648 \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"Hello"}'const res = await fetch("https://api.kit.forhosting.com/enc/base16-rfc4648", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "Hello"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/enc/base16-rfc4648",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "Hello"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/enc/base16-rfc4648", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"Hello"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"Hello"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/enc/base16-rfc4648", 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": "Hello"
}Esempio di risposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.base16_rfc4648",
"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
Prezzo pubblicato, senza token né crediti. Se l'attività fallisce, non paghi.
Limiti
max_chars | 100000 |
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
Un input malformato — un numero dispari di cifre hex, un carattere fuori dall'alfabeto o byte che non sono UTF-8 valido — restituisce un errore invalid_input chiaro invece di una corruzione silenziosa. Il percorso è aritmetica di byte pura e deterministica — niente rete, niente semi casuali, niente orologio — quindi l'esecutore gratuito nel browser e l'API prepagata restituiscono sempre lo stesso JSON.
Come chiamare l'API e cosa contiene la risposta
La modalità predefinita è encode: i byte UTF-8 di text diventano una stringa Base16 maiuscola secondo l'alfabeto della RFC 4648. Invii un corpo JSON con un campo stringa obbligatorio text (alias input, value e data) e un mode opzionale che è encode oppure decode. La modalità decode tratta text come un payload Base16 — opzionalmente con spazi o separatori di due punti e case misto — e restituisce la stringa UTF-8 recuperata dopo la normalizzazione. La lunghezza dell'input è limitata a centomila caratteri affinché una singola richiesta non possa esaurire la memoria del Worker con dump patologici. In caso di successo con encode, la risposta include mode, input, result oltre a base16 e hex con la stessa stringa codificata, alphabet con la costante di sedici caratteri 0123456789ABCDEF, alphabet_name con il valore rfc4648_base16, standard con RFC 4648 Base16, input_bytes come conteggio dei byte UTF-8, output_length come conteggio dei caratteri codificati e un breve messaggio in inglese. In caso di successo con decode, la risposta include mode, input, result e text con la stringa UTF-8 decodificata, base16_normalized con la forma continua maiuscola, gli stessi campi alphabet e standard, input_length, output_bytes e un messaggio corrispondente. Una convalida fallita — text mancante, text non stringa, input oltre il limite, un mode sconosciuto, una lunghezza hex dispari, un carattere Base16 non valido o byte decodificati che non sono UTF-8 valido — restituisce invalid_input e non viene mai addebitata. Il prezzo è una tariffa fissa di $0.002 per richiesta riuscita con unità item e prezzo marginale unitario zero.
Consigli pratici, limiti e differenze rispetto ad altre codifiche
I controlli di andata e ritorno sono lo smoke test più rapido: codifichi una parola nota come Hello, confermi il classico risultato maiuscolo 48656C6C6F, poi decodifichi quella stringa e confermi di recuperare la frase originale byte per byte. Non è nemmeno Base58, che elimina i glifi ambigui per la trascrizione umana. E non è un convertitore di basi per interi o float: per convertire un singolo numero hex in decimale o binario, usi le capacità dedicate ai formati numerici invece di trattare le cifre come una stringa opaca di byte. Preferisca Base16 quando le serve un dump 1:1 leggibile per nibble conforme alla RFC 4648 e all'hex dei manuali; preferisca Base64 quando la densità conta più della leggibilità. Per insegnare, mostri la stessa frase codificata in Base16 e Base64 una accanto all'altra così gli studenti vedono perché l'hex è più lungo, sempre di lunghezza pari, e perché A–F maiuscole è la forma standardizzata della Tabella 5 della RFC 4648. Preferisca encode quando parte da testo leggibile o da brevi payload UTF-8 che vuole come dump hex canonico maiuscolo per specifiche, ticket o test unitari. Invii di proposito una stringa hex di lunghezza dispari o un glifo non hex come G o Z in una richiesta decode per verificare che il suo client gestisca invalid_input e il messaggio di errore che cita la regola. Mantenga i payload sotto il limite di caratteri pubblicato; i dump di svariati megabyte appartengono al lavoro offline o a strumenti binari dedicati. Questo strumento non è Base64 né Base64URL: quegli alfabeti usano sessantaquattro simboli con riempimento e un impacchettamento più denso. Le attività fallite che restituiscono invalid_input non consumano saldo prepagato, il che mantiene economici gli script esplorativi quando prova hex malformato.
Casi di integrazione
Dump hex di protocolli e fixture nei test
Generi Base16 canonico maiuscolo da testo di fixture e verifichi che decode recuperi gli stessi byte UTF-8 in CI senza dipendenze crittografiche.
Debug di log e tracce di pacchetti incollati
Incolli dump hex con spazi o due punti, li decodifichi in testo leggibile quando il payload è UTF-8, oppure li ricodifichi dopo le modifiche per controlli di andata e ritorno.
Domande tecniche
Cosa succede se decodifico una stringa hex di lunghezza dispari o un carattere non hex?
L'API restituisce invalid_input, spiega la lunghezza dispari o indica il carattere errato e il suo indice, e ricorda che Base16 richiede un numero pari di cifre 0-9A-F. Le attività fallite non vengono addebitate.