Convertitore testo in binario
«Hi» diventa 01001000 01101001: ogni byte del suo testo scritto con otto zeri e uno, un gruppo per byte, mentre accenti ed emoji occupano da due a quattro gruppi in UTF-8. Incolli gruppi binari per riavere il testo. Gratis nel suo browser.
- Gratis
- Funziona nel suo browser
- Senza registrazione
- I suoi dati restano sul dispositivo
Esegui gratis nel browser
Esempio risolto
- Testo
- Hi
- Modalità di calcolo
- Encode
- Risultato
- 01001000 01101001
- Ingresso
- Hi
- Binario
- 01001000 01101001
- Gruppi
- 01001000, 01101001
Un convertitore da testo a binario trasforma i caratteri ordinari nei pattern a otto bit che i computer memorizzano, e il percorso da binario a testo inverte quella mappatura per recuperare la stringa originale. Inserisca testo UTF-8 semplice e scelga encode per ricevere gruppi di otto zeri e uni separati da spazi—un gruppo per byte—oppure incolli gruppi binari e scelga decode per ricostruire il testo.
Come il testo diventa binario a 8-bit e perché conta la lunghezza del gruppo
I computer non memorizzano le lettere come forme; memorizzano sequenze di byte, e ogni byte è otto bit. Per le lettere inglesi nell’intervallo latino di base, un carattere spesso mappa un byte il cui valore decimale è il codice ASCII classico—ad esempio la H maiuscola è settantadue, che in binario è zero-uno-zero-zero-uno-zero-zero-zero. Il testo moderno è UTF-8, quindi lettere accentate, emoji e script non latini possono richiedere due, tre o quattro byte e quindi due, tre o quattro gruppi a otto bit.
La codifica scorre la sequenza di byte UTF-8 da sinistra a destra e scrive ogni byte come otto cifre con il bit più significativo per primo, unendo i gruppi con un solo spazio così da contare gli ottetti a colpo d’occhio. La decodifica fa l’inverso: suddivide l’input in gruppi candidati, richiede che ogni gruppo corrisponda esattamente a otto caratteri zero o uno, converte ogni gruppo in un valore di byte tra zero e duecentocinquantacinque, poi interpreta l’array di byte come UTF-8.
Se un gruppo ha sette bit, nove bit o un carattere non binario, il convertitore deve fallire. Il binario continuo senza spazi è consentito solo quando la lunghezza totale è multipla di otto, perché ogni fetta di otto cifre consecutive resta un ottetto.
Casi d'uso
Controlli dei compiti su pattern di bit ASCII e UTF-8
Gli studenti codificano frasi brevi, confrontano gruppi a otto bit scritti a mano con il risultato deterministico e decodificano il binario fornito dall’insegnante senza un foglio di calcolo.
Demo didattiche di protocolli e reti
I workshop mostrano come le etichette stampabili diventano ottetti sul cavo e forzano gruppi di bit incompleti per illustrare regole di framing rigorose.
Domande frequenti
Cosa produce il convertitore da testo a binario?
In modalità encode restituisce gruppi a otto bit separati da spazi (uno per byte UTF-8), più array di groups e valori interi di byte. In modalità decode restituisce il testo UTF-8 recuperato.
Supporta UTF-8 e emoji?
Sì. La codifica usa UTF-8, quindi i caratteri multi-byte diventano più gruppi a otto bit. La decodifica rifiuta sequenze di byte che non sono UTF-8 valido.
Posso incollare binario senza spazi?
Sì, se la stringa continua contiene solo 0 e 1 e la lunghezza è multipla di otto.
Il convertitore da testo a binario è gratuito?
Lo strumento nel browser è gratuito e gira in locale.
Perché il mio binario non si decodifica?
Ogni gruppo deve avere esattamente otto cifre, tutte 0 o 1. Un gruppo di sette o nove bit, o qualsiasi altro carattere, si ferma con un messaggio chiaro invece di essere completato o tagliato, e il binario senza spazi funziona solo se la lunghezza è un multiplo di otto.
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/binary-text \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"Hi"}'const res = await fetch("https://api.kit.forhosting.com/enc/binary-text", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "Hi"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/enc/binary-text",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "Hi"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/enc/binary-text", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"Hi"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"Hi"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/enc/binary-text", 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": "Hi"
}Esempio di risposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.binary_text",
"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
Ogni gruppo di bit deve avere esattamente otto cifre; un gruppo corto o lungo, o una stringa continua la cui lunghezza non è multipla di otto, restituisce un errore invalid_input chiaro invece di inventare un padding. Il percorso è aritmetica puramente deterministica sui byte UTF-8—senza rete, senza semi casuali, senza dipendenza dall’orologio—così l’esecutore gratuito del browser e l’API prepagata restituiscono lo stesso JSON ogni volta che la chiama.
Come il testo diventa binario a 8-bit e perché conta la lunghezza del gruppo
Un padding silenzioso con zeri o un troncamento cambierebbero il payload e nasconderebbero gli errori del foglio di lavoro. Questa pagina si rivolge a chi cerca un convertitore testo in binario, uno strumento binario in testo o un codificatore ASCII e UTF-8 a otto bit online; non è un visualizzatore di bit in virgola mobile IEEE né un mappatore di cifre esadecimali in binario.
Come chiamare l’API e cosa contiene la risposta
La modalità predefinita è encode: i byte UTF-8 di text diventano gruppi binari a otto bit separati da spazi. La modalità decode tratta text come gruppi binari—ottetti separati da spazi bianchi o una stringa continua di zeri e uni la cui lunghezza è multipla di otto—e restituisce la stringa UTF-8 recuperata. In caso di successo decode, la risposta include mode, input, result e text con la stringa UTF-8 decodificata, binary normalizzato in gruppi separati da spazi, gli stessi array groups e bytes, i conteggi e un messaggio corrispondente. Invii un corpo JSON con un campo stringa obbligatorio text (alias input, value e data) e un mode opzionale che sia encode o decode. La lunghezza dell’input è limitata a centomila caratteri così una singola richiesta non esaurisce la memoria del Worker con stringhe enormi. In caso di successo encode, la risposta include mode, input, result e binary con la stessa stringa di bit separata da spazi, groups come array di stringhe di otto caratteri, bytes come i valori interi di byte, byte_count e bit_count, e un breve messaggio. Una validazione fallita—text assente, text non stringa, input troppo grande, mode sconosciuto, gruppo di bit che non ha otto cifre, caratteri non binari in un gruppo, o byte decodificati che non sono UTF-8 valido—restituisce invalid_input e non viene mai addebitata. Il prezzo è un fisso di $0.002 per richiesta andata a buon fine con unità item e prezzo unitario marginale zero.
Consigli pratici, limiti e strumenti correlati
Preferisca decode quando ha già stringhe di bit da un libro di testo o da un dump di pacchetti e vuole i caratteri indietro. I controlli andata e ritorno sono il test di fumo più rapido: codifichi una parola breve come Hi, confermi che i due gruppi corrispondono ai byte ASCII noti di H e i, poi decodifichi quei gruppi e confermi di recuperare la stringa originale. Preferisca questa capacità quando l’intento di ricerca è caratteri di testo contro gruppi binari a otto bit; usi un formattatore hex-a-binario quando l’input è già in cifre esadecimali, e un visualizzatore di bit in virgola mobile quando le servono i campi segno, esponente e mantissa. Nell’insegnamento, mostri lo stesso emoji o la stessa lettera accentata accanto a una lettera ASCII semplice così gli studenti vedono gli ottetti UTF-8 multi-byte come gruppi a otto bit aggiuntivi anziché un unico codice misterioso. Invii deliberatamente un frammento a sette bit o una stringa binaria continua la cui lunghezza non è multipla di otto per asserire che il Suo client gestisce invalid_input e il messaggio di errore che indica che ogni gruppo deve avere otto cifre. Mantenga i payload sotto il limite di caratteri pubblicato; i dump multi-megabyte restano offline. Questo strumento non è un convertitore esadecimale—le cifre hex sono in base sedici, non in base due—e non è un ispettore di bit in virgola mobile IEEE-754. Le attività fallite che restituiscono invalid_input non consumano il saldo prepagato, il che mantiene economici gli script esplorativi quando gli allievi incollano gruppi di bit incompleti.
Casi di integrazione
Fixture di test unitari per codec e parser
Generi stringhe binarie note da testo di fixture e asserisca che decode recupera gli stessi byte UTF-8 in CI senza helper ad hoc di packing dei bit.
Domande tecniche
Perché ogni gruppo di bit deve avere otto cifre?
Un byte è otto bit. Gruppi di altra lunghezza sarebbero ambigui senza regole di padding, quindi i gruppi incompleti o troppo lunghi restituiscono invalid_input.