Convertire testo in binario
«Hi» diventa 01001000 01101001: un gruppo di otto zeri e uno per ogni byte, la sequenza che il computer memorizza davvero. Incolli di nuovo i gruppi e il testo originale ritorna, accenti ed emoji compresi. 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
- Input
- Hi
- Binario
- 01001000 01101001
- Gruppi
- 01001000, 01101001
Convertire il testo in una rappresentazione binaria associa ogni carattere ai pattern di otto bit che i computer memorizzano davvero, e convertire il binario in testo inverte tale mappatura per recuperare la stringa originale. Inserisca testo UTF-8 semplice e scelga encode per ricevere gruppi separati da spazi di otto zeri e uni—un gruppo per byte—oppure incolli gruppi binari e scelga decode per ricostruire i caratteri.
Come il testo diventa rappresentazione binaria a 8 bit e perché conta la lunghezza del gruppo
I computer non memorizzano le lettere come disegni; memorizzano sequenze di byte, e ogni byte sono otto bit. Per le lettere inglesi nell'intervallo latino di base, un carattere spesso corrisponde a 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 scritture non latine possono richiedere due, tre o quattro byte e quindi due, tre o quattro gruppi da 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'ingresso 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 è multiplo di otto, perché ogni fettina di otto cifre consecutive resta un ottetto.
Casi d'uso
Controllo compiti su pattern di bit ASCII e UTF-8
Gli studenti codificano frasi brevi, confrontano gruppi da otto bit scritti a mano con il risultato deterministico e decodificano il binario dell'insegnante senza un foglio di calcolo.
Demo didattiche di protocolli e reti
I workshop mostrano come etichette stampabili diventino ottetti sul filo, poi forzano gruppi di bit incompleti per illustrare regole di framing rigorose.
Domande frequenti
Cosa restituisce convertire testo in rappresentazione binaria?
In mode encode restituisce gruppi da otto bit separati da spazi (uno per byte UTF-8), più array di groups e valori interi di byte. In mode 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 da otto bit. La decodifica rifiuta sequenze di byte che non sono UTF-8 valido.
Posso incollare binario senza spazi?
Sì, se la stringa continua è solo 0 e 1 e la lunghezza è multiplo di otto.
Convertire testo in binario è gratis?
Lo strumento nel browser è gratis e gira in locale.
Cosa succede se un gruppo ha sette o nove cifre?
La conversione si ferma con un messaggio chiaro invece di tirare a indovinare. Ogni gruppo deve avere esattamente otto zeri e uno, perché completare o tagliare in silenzio cambierebbe il testo e nasconderebbe un errore nell'esercizio.
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/text/text-to-binary \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"Hi"}'const res = await fetch("https://api.kit.forhosting.com/text/text-to-binary", {
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/text/text-to-binary",
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/text/text-to-binary", 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/text/text-to-binary", 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": "text.text_to_binary",
"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_tokens | 20000 |
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 in direzione inversa deve avere esattamente otto cifre; un gruppo corto o lungo, o una stringa continua la cui lunghezza non è multiplo di otto, restituisce un chiaro errore invalid_input invece di inventare un riempimento. Il percorso è aritmetica puramente deterministica su 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 a ogni chiamata.
Come il testo diventa rappresentazione binaria a 8 bit e perché conta la lunghezza del gruppo
Un riempimento silenzioso con zeri o un troncamento cambierebbe il payload e nasconderebbe errori del foglio di lavoro. Questa pagina serve chi cerca di convertire testo in rappresentazione binaria, di riportare gruppi binari a testo leggibile o di verificare la codifica a otto bit online; non è un visualizzatore di bit IEEE in virgola mobile né un mappatore hex-verso-binario di cifre già in base sedici.
Come chiamare l'API e cosa contiene la risposta
Il mode predefinito è encode: i byte UTF-8 del testo diventano gruppi binari da otto bit separati da spazi. Il mode decode tratta text come gruppi binari—ottetti separati da spazi bianchi o una stringa continua di zeri e uni la cui lunghezza è multiplo di otto—e restituisce la stringa UTF-8 recuperata. In caso di successo per decode, la risposta include mode, input, result e text con la stringa UTF-8 decodificata, binary normalizzato a gruppi separati da spazi, gli stessi array groups e bytes, i conteggi e un messaggio equivalente. Invii un corpo JSON con un campo stringa obbligatorio text (alias input, value e data) e un mode opzionale encode o decode. La lunghezza in ingresso è limitata a centomila caratteri affinché una sola richiesta non esaurisca la memoria del Worker su stringhe enormi. In caso di successo per encode, la risposta include mode, input, result e binary con la stessa stringa di bit separata da spazi, groups come array di stringhe da otto caratteri, bytes come valori interi di byte, byte_count e bit_count, e un breve messaggio. La validazione fallita—text mancante, text non stringa, ingresso troppo grande, mode sconosciuto, un 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 $0.002 per richiesta riuscita con unità item e prezzo unitario marginale zero.
Consigli pratici, limiti e quando usare strumenti correlati
Preferisca decode quando ha già stringhe di bit da un manuale 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 coincidono con i 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 è convertire caratteri di testo in una rappresentazione binaria a otto bit o recuperare testo da quei gruppi; usi un formattatore hex-verso-binario quando l'ingresso è già in cifre esadecimali, e un visualizzatore di bit di float 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 apparire come gruppi extra da otto bit invece di un solo misterioso code point sulla pagina. Inoltri di proposito un frammento a sette bit o una stringa binaria continua la cui lunghezza non è multiplo di otto per verificare che il suo client gestisca invalid_input e il messaggio che indica che ogni gruppo deve avere otto cifre. Tenga i payload sotto il limite di caratteri pubblicato; i dump da più 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 di float IEEE-754. Le attività fallite che restituiscono invalid_input non consumano il saldo prepagato, il che mantiene economici gli script esplorativi quando gli studenti 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 affermi 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 esattamente otto cifre?
Un byte sono otto bit. Gruppi di altra lunghezza sarebbero ambigui senza regole di riempimento, quindi gruppi incompleti o troppo lunghi restituiscono invalid_input all'inverso.