Convertisseur texte vers binaire
« Hi » devient 01001000 01101001 : chaque octet de votre texte s'écrit avec huit zéros et uns, un groupe par octet, tandis que les accents et les emojis occupent de deux à quatre groupes en UTF-8. Collez des groupes binaires pour retrouver le texte. 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
Un convertisseur texte vers binaire transforme des caractères ordinaires en motifs de huit bits que les ordinateurs stockent, et le chemin binaire vers texte inverse ce mappage pour retrouver la chaîne d’origine. Saisissez du texte UTF-8 brut et choisissez encode pour recevoir des groupes de huit zéros et uns séparés par des espaces—un groupe par octet—ou collez des groupes binaires et choisissez decode pour reconstruire le texte.
Comment le texte devient du binaire 8-bit et pourquoi la longueur des groupes compte
Les ordinateurs ne stockent pas les lettres comme des formes ; ils stockent des suites d’octets, et chaque octet fait huit bits. Pour les lettres anglaises de la plage latine de base, un caractère mappe 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 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 en huit chiffres avec le bit de poids fort en premier, en joignant les groupes par un seul espace pour que l’on puisse 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 en UTF-8.
Si un groupe a sept bits, neuf bits ou un caractère non binaire, le convertisseur doit échouer. Un rembourrage silencieux par des zéros ou une troncature modifierait la charge utile et masquerait les erreurs de feuille. 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 outils associés
Préférez decode lorsque vous détenez déjà des chaînes de bits d’un manuel ou d’un dump de paquets et voulez récupérer les caractères. Les contrôles aller-retour 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 retrouvez 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 des caractères de texte face à des groupes binaires de huit bits ; utilisez un formateur hex-vers-binaire lorsque l’entrée est déjà en chiffres hexadécimaux, et un visualiseur de bits flottants lorsque vous avez besoin des champs signe, exposant et mantisse. En enseignement, 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 unique code mystérieux.
Cas d’usage
Vérifications de devoirs sur les motifs de bits ASCII et UTF-8
Les élèves encodent de courtes phrases, comparent des groupes de huit bits manuscrits au résultat déterministe et décodent le binaire fourni par l’enseignant sans tableur.
Démos 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 produit le convertisseur texte vers binaire ?
En mode encode il renvoie des groupes de huit bits séparés par des espaces (un par octet UTF-8), plus des tableaux de groups et de valeurs d’octet entières. En mode decode il renvoie le texte UTF-8 récupéré.
Prend-il 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 un 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.
Le convertisseur texte vers binaire est-il gratuit ?
L’outil navigateur est gratuit et s’exécute en local.
Pourquoi mon binaire ne se décode-t-il pas ?
Chaque groupe doit compter exactement huit chiffres, tous 0 ou 1. Un groupe de sept ou neuf bits, ou tout autre caractère, s'arrête avec un message clair au lieu d'être complété ou tronqué, et le binaire sans espaces ne marche que si sa longueur est un multiple de huit.
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/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)Exemple de requête
{
"text": "Hi"
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.binary_text",
"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_chars | 100000 |
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 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 les 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 du binaire 8-bit et pourquoi la longueur des groupes compte
Cette page vise les personnes qui cherchent un convertisseur texte vers binaire, un outil binaire vers texte ou un encodeur ASCII et UTF-8 huit bits en ligne ; ce n’est pas un visualiseur de bits virgule flottante IEEE ni un mappeur de chiffres hexadécimaux vers le binaire.
Comment appeler l’API et ce que contient la réponse
Le mode par défaut est encode : les octets UTF-8 de text 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 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 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, les comptages et un message correspondant. Envoyez un corps JSON avec un champ chaîne obligatoire text (alias input, value et data) et un mode optionnel valant encode ou decode. La longueur d’entrée est plafonnée à cent mille caractères pour qu’une seule requête ne sature pas la mémoire du Worker avec d’énormes chaînes. En cas de succès 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 les 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 longue, mode inconnu, groupe de bits qui n’a pas huit chiffres, caractères non binaires dans un groupe, ou octets décodés qui ne sont pas un 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 unité item et prix unitaire marginal nul.
Conseils pratiques, limites et outils associés
Soumettez délibérément 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 d’erreur indiquant que chaque groupe doit compter 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 virgule flottante IEEE-754. Les tâches en échec qui renvoient invalid_input ne consomment pas le solde prépayé, ce qui maintient les scripts exploratoires peu coûteux 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 de 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 compter 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.