Convertir texte en binaire
« Hi » devient 01001000 01101001 : un groupe de huit zéros et uns par octet, le motif que l'ordinateur stocke réellement. Recollez les groupes et le texte d'origine revient, accents et emoji compris. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Exemple résolu
- Texte
- Hi
- Mode de calcul
- Encode
- Résultat
- 01001000 01101001
- Entrée
- Hi
- Binaire
- 01001000 01101001
- Groupes
- 01001000, 01101001
Convertir du texte en représentation binaire associe chaque caractère aux motifs de huit bits que les ordinateurs stockent réellement, et convertir le binaire en texte inverse ce mappage pour retrouver la chaîne d'origine. Saisissez du texte UTF-8 brut et choisissez encode pour recevoir des groupes séparés par des espaces de huit zéros et uns—un groupe par octet—ou collez des groupes binaires et choisissez decode pour reconstruire les caractères.
Comment le texte devient une représentation binaire 8 bits et pourquoi la longueur du groupe compte
Les ordinateurs ne stockent pas les lettres comme des dessins ; ils stockent des séquences d'octets, et chaque octet fait huit bits. Pour les lettres anglaises de la plage latine de base, un caractère correspond souvent à un octet dont la valeur décimale est le code ASCII classique—par exemple le H majuscule vaut soixante-douze, soit zéro-un-zéro-zéro-un-zéro-zéro-zéro en binaire.
Le texte moderne est en UTF-8, donc les lettres accentuées, les emoji et les écritures non latines peuvent nécessiter deux, trois ou quatre octets et donc deux, trois ou quatre groupes de huit bits. L'encodage parcourt la séquence d'octets UTF-8 de gauche à droite et écrit chaque octet comme huit chiffres avec le bit de poids fort en premier, en joignant les groupes par un seul espace pour compter les octets d'un coup d'œil.
Le décodage fait l'inverse : il découpe l'entrée en groupes candidats, exige que chaque groupe corresponde exactement à huit caractères zéro ou un, convertit chaque groupe en une valeur d'octet entre zéro et deux cent cinquante-cinq, puis interprète le tableau d'octets comme UTF-8. Si un groupe a sept bits, neuf bits ou un caractère non binaire, le convertisseur doit échouer. Un rembourrage silencieux de zéros ou une troncature changerait la charge utile et masquerait les erreurs de feuille de travail.
Le binaire continu sans espaces n'est autorisé que lorsque la longueur totale est un multiple de huit, car chaque tranche de huit chiffres consécutifs reste un octet.
Conseils pratiques, limites et quand utiliser des outils voisins
Préférez decode lorsque vous avez déjà des chaînes de bits d'un manuel ou d'un dump de paquets et voulez retrouver les caractères. Les allers-retours sont le test de fumée le plus rapide : encodez un court mot comme Hi, confirmez que les deux groupes correspondent aux octets ASCII connus de H et i, puis décodez ces groupes et confirmez que vous récupérez la chaîne d'origine. Gardez les charges sous la limite de caractères publiée ; les dumps multi-mégaoctets restent hors ligne.
Préférez cette capacité lorsque l'intention de recherche est de convertir des caractères de texte en représentation binaire sur huit bits ou de récupérer du texte à partir de ces groupes ; utilisez un formateur hex-vers-binaire lorsque l'entrée est déjà en chiffres hexadécimaux, et un visualiseur de bits de flottant lorsque vous avez besoin des champs signe, exposant et mantisse.
En cours, montrez le même emoji ou la même lettre accentuée à côté d'une lettre ASCII simple pour que les élèves voient les octets UTF-8 multi-octets apparaître comme des groupes de huit bits supplémentaires plutôt qu'un seul point de code mystérieux sur la page.
Cas d’usage
Vérification des devoirs sur les motifs de bits ASCII et UTF-8
Les élèves encodent de courtes phrases, comparent des groupes de huit bits écrits à la main au résultat déterministe, et décodent le binaire fourni par l'enseignant sans tableur.
Démonstrations pédagogiques de protocoles et réseaux
Les ateliers montrent comment des libellés imprimables deviennent des octets sur le fil, puis forcent des groupes de bits incomplets pour illustrer des règles de cadrage strictes.
Questions fréquentes
Que renvoie la conversion de texte en représentation binaire ?
En mode encode, elle renvoie des groupes de huit bits séparés par des espaces (un par octet UTF-8), plus des tableaux groups et des valeurs entières d'octet. En mode decode, elle renvoie le texte UTF-8 récupéré.
Prend-elle en charge UTF-8 et les emoji ?
Oui. L'encodage utilise UTF-8, donc les caractères multi-octets deviennent plusieurs groupes de huit bits. Le décodage rejette les séquences d'octets qui ne sont pas de l'UTF-8 valide.
Puis-je coller du binaire sans espaces ?
Oui, si la chaîne continue ne contient que 0 et 1 et que sa longueur est un multiple de huit.
La conversion de texte en binaire est-elle gratuite ?
L'outil navigateur est gratuit et s'exécute en local.
Que se passe-t-il si un groupe compte sept ou neuf chiffres ?
La conversion s'arrête avec un message clair au lieu de deviner. Chaque groupe doit contenir exactement huit zéros et uns, car compléter ou couper en silence changerait le texte et masquerait une erreur dans un exercice.
Outils associés
Pour les développeurs — accès API
Tout sur cette page est disponible par programmation. Cette section s'adresse aux équipes qui veulent l'intégrer à leurs systèmes ; les autres peuvent simplement utiliser l'outil ci-dessus.
Endpoint
Authentification par jeton Bearer : un seul POST met la tâche en file d’attente, et le résultat vous parvient par webhook ou lien signé.
Appeler depuis votre 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)Exemple de requête
{
"text": "Hi"
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "text.text_to_binary",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L’API est asynchrone : chaque appel renvoie un task_id immédiatement, puis vous interrogez l’état à raison d’une requête par seconde.
Tarifs
Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.
Limites
max_tokens | 20000 |
Erreurs
| HTTP | Code | Signification |
|---|---|---|
401 | unauthorized | Clé API absente ou invalide : vérifiez l’en-tête Authorization. |
402 | insufficient_balance | Solde insuffisant : rechargez votre compte pour lancer cette tâche. |
404 | unknown_type | Type de tâche inconnu : vérifiez le champ type de votre requête. |
429 | rate_limited | Trop de requêtes : ralentissez la cadence, puis réessayez. |
Notes techniques
Chaque groupe de bits à l'inverse doit compter exactement huit chiffres ; un groupe trop court ou trop long, ou une chaîne continue dont la longueur n'est pas un multiple de huit, renvoie une erreur invalid_input claire au lieu d'inventer un rembourrage. Le chemin est une arithmétique purement déterministe sur des octets UTF-8—sans réseau, sans graines aléatoires, sans horloge—ainsi l'exécuteur gratuit du navigateur et l'API prépayée renvoient le même JSON à chaque appel.
Comment le texte devient une représentation binaire 8 bits et pourquoi la longueur du groupe compte
Cette page s'adresse à qui cherche à convertir du texte en représentation binaire, à retransformer des groupes binaires en texte lisible, ou à vérifier un encodage de caractères sur huit bits en ligne ; ce n'est pas un visualiseur de bits IEEE en virgule flottante ni un mappeur hex-vers-binaire pour des chiffres déjà en base seize.
Comment appeler l'API et ce que contient la réponse
Le mode par défaut est encode : les octets UTF-8 du texte deviennent des groupes binaires de huit bits séparés par des espaces. Le mode decode traite text comme des groupes binaires—octets séparés par des espaces blancs ou une chaîne continue de zéros et uns dont la longueur est un multiple de huit—et renvoie la chaîne UTF-8 récupérée. En cas de succès pour decode, la réponse inclut mode, input, result et text avec la chaîne UTF-8 décodée, binary normalisé en groupes séparés par des espaces, les mêmes tableaux groups et bytes, des compteurs et un message équivalent. Envoyez un corps JSON avec un champ chaîne obligatoire text (alias input, value et data) et un mode optionnel encode ou decode. La longueur d'entrée est plafonnée à cent mille caractères pour qu'une seule requête n'épuise pas la mémoire du Worker sur d'énormes chaînes. En cas de succès pour encode, la réponse inclut mode, input, result et binary avec la même chaîne de bits séparée par des espaces, groups comme tableau de chaînes de huit caractères, bytes comme valeurs entières d'octet, byte_count et bit_count, et un court message. Une validation échouée—text manquant, text non chaîne, entrée trop grande, mode inconnu, un groupe de bits qui n'a pas huit chiffres, des caractères non binaires dans un groupe, ou des octets décodés qui ne sont pas de l'UTF-8 valide—renvoie invalid_input et n'est jamais facturée. Le tarif est un forfait $0.002 par requête réussie avec l'unité item et un prix unitaire marginal nul.
Conseils pratiques, limites et quand utiliser des outils voisins
Soumettez volontairement un fragment de sept bits ou une chaîne binaire continue dont la longueur n'est pas un multiple de huit pour vérifier que votre client gère invalid_input et le message indiquant que chaque groupe doit avoir huit chiffres. Cet outil n'est pas un convertisseur hexadécimal—les chiffres hex sont en base seize, pas en base deux—et ce n'est pas un inspecteur de bits de flottant IEEE-754. Les tâches en échec qui renvoient invalid_input ne consomment pas le solde prépayé, ce qui maintient les scripts d'exploration bon marché lorsque les apprenants collent des groupes de bits incomplets.
Cas d'intégration
Fixtures de tests unitaires pour codecs et analyseurs
Générez des chaînes binaires connues à partir d'un texte de fixture et affirmez que decode récupère les mêmes octets UTF-8 en CI sans aides ad hoc d'empaquetage de bits.
Questions techniques
Pourquoi chaque groupe de bits doit-il avoir exactement huit chiffres ?
Un octet fait huit bits. Des groupes d'une autre longueur seraient ambigus sans règles de rembourrage, donc les groupes incomplets ou trop longs renvoient invalid_input à l'inverse.