Encodeur Base32768
Compactez du texte en Base32768, où chaque caractère Unicode porte quinze bits pour les canaux UTF-16 : Hello tient en trois caractères, 䩲腻㐿. Le décodage vérifie chaque symbole et le remplissage, si bien qu'une copie abîmée échoue. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Exemple résolu
- Texte
- Hello
- Mode de calcul
- Encode
- Résultat
- 䩲腻㐿
- Longueur
- 3
- Octets d'entrée
- 5
- Bits par caractère
- 15
Au lieu d'empiler cinq ou six bits dans un symbole ASCII comme Base32 et Base64, Base32768 choisit chaque caractère dans un répertoire de 32768 points de code sûrs du plan multilingue de base et transporte quinze bits de charge par caractère. Cela donne environ 93.75 pour cent d'efficacité lorsque le résultat est stocké ou transmis en UTF-16, bien plus dense que Base64 sur le même fil. Cette capacité implémente de bout en bout le profil qntm Base32768 : le mode encode lit votre chaîne en clair comme octets UTF-8 et émet un résultat Base32768 ; le mode decode valide chaque symbole face à l'alphabet primaire de quinze bits et à l'alphabet secondaire de remplissage de sept bits, puis retrouve le texte UTF-8 d'origine.
Comment Base32768 regroupe quinze bits en caractères BMP sûrs
Base32768 traite l'entrée comme un flux continu de bits d'octets bruts. Pour le texte, cette capacité convertit d'abord votre chaîne en UTF-8 afin que les caractères multi-octets restent portables entre langues et plateformes. Les bits sont pris du plus significatif au moins.
Tous les quinze bits accumulés sélectionnent un index dans un répertoire primaire de 32768 entrées bâti sur des plages fermées de points de code Unicode assignés, non de contrôle et sans blanc, dans le plan multilingue de base. Lorsque le reste final n'est pas un bloc complet de quinze bits, l'encodeur remplit avec des uns et termine par un symbole primaire ou par un symbole secondaire de remplissage de sept bits tiré d'un alphabet séparé de 128 entrées.
Le décodage inverse la carte : chaque caractère apporte quinze ou sept bits, des octets complets sont émis dès que huit bits s'accumulent, et les bits de remplissage résiduels doivent encore être tous des uns. Un caractère secondaire de remplissage avant la position finale est aussi rejeté, car ce motif n'apparaît jamais dans un encodage légal.
Face à Base64, vous échangez un alphabet purement ASCII contre une bien meilleure densité sous UTF-16 ; face à Base65536, vous restez dans le BMP et chaque caractère est une seule unité de code UTF-16.
Ce que vous envoyez et ce que vous recevez
Envoyez un champ chaîne obligatoire nommé text et un champ optionnel mode égal à encode ou decode. Lorsque mode est omis, encode est la valeur par défaut et une seule charge utile reste utile. Le mode encode traite text comme contenu UTF-8 en clair et renvoie une chaîne result dans les alphabets Base32768.
Le mode decode traite text comme Base32768, valide chaque symbole et renvoie la chaîne UTF-8 récupérée dans result. Les échecs de validation ne consomment pas le solde prépayé. Les contrôles classiques incluent l'encodage de Hello en un court bloc Base32768 de trois caractères, l'encodage de la phrase hello world vers la chaîne de référence connue du format, et le décodage de cette chaîne vers la charge utile d'origine de onze octets.
Où Base32768 apparaît dans le travail réel
Les systèmes qui stockent des blobs binaires dans des colonnes texte UTF-16 ont souvent besoin d'un empaquetage plus dense que ce que Base64 offre sans quitter le BMP. Les équipes déjà standardisées sur la suite qntm d'encodages denses utilisent Base32768 lorsque le canal est natif UTF-16 et Base2048 ou Base65536 lorsque d'autres contraintes s'appliquent. Les bureaux d'assistance collent des chaînes opaques depuis des tickets et exigent une validation stricte de l'alphabet sans accepter des symboles pourris qui produiraient une charge erronée.
Les auteurs de cours qui enseignent la densité d'encodage sous différentes formes Unicode veulent une page dédiée à Base32768 plutôt que de l'enterrer sous une landing générique Base64, car l'intention de recherche, les règles d'alphabet et les chiffres d'efficacité diffèrent. Si vous avez besoin de Base32 RFC 4648 pour des secrets TOTP, de Base64 sûr pour URL ou de densité basE91 sous UTF-8, traitez-les comme des intentions de recherche et des landings distinctes plutôt que de surcharger cette page d'encodeur Base32768.
Cas d’usage
Jetons opaques denses en UTF-16
Encodez de courtes charges sûres en binaire en Base32768 pour le stockage en colonnes NVARCHAR, chaînes JavaScript ou presse-papiers lorsque la densité UTF-16 prime sur la sûreté ASCII.
Questions fréquentes
Quel profil Base32768 cette capacité utilise-t-elle ?
Le profil qntm Base32768 : 32768 points de code BMP primaires portant quinze bits chacun, plus un alphabet secondaire de 128 entrées pour le symbole final de remplissage de sept bits si besoin.
Puis-je encoder et décoder ?
Oui. Réglez mode sur encode (par défaut) pour convertir du texte UTF-8 en clair en Base32768, ou mode sur decode pour retrouver le texte depuis une chaîne Base32768.
Que se passe-t-il si la chaîne Base32768 a un caractère invalide ?
Rien n'est facturé pour les échecs de validation.
Pourquoi Base32768 est-il plus dense que Base64 sous UTF-16 ?
Chaque caractère Base32768 est une seule unité de code BMP (16 bits d'UTF-16) portant quinze bits de charge, environ 93.75 pour cent d'efficacité. Base64 a besoin de deux unités UTF-16 pour douze bits de charge ASCII, donc la densité sur des fils UTF-16 est bien plus faible.
Combien cela coûte-t-il ?
L'outil navigateur est gratuit et s'exécute en local.
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/base32768 \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"Hello"}'const res = await fetch("https://api.kit.forhosting.com/enc/base32768", {
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/base32768",
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/base32768", 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/base32768", 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": "Hello"
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.base32768",
"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.
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
Base32768 est un encodage binaire vers texte conçu pour les canaux qui parlent déjà UTF-16 : chaînes JavaScript, String Java, API larges Windows et nombreuses bases en NVARCHAR. Symboles illégaux, caractères de remplissage mal placés et désaccords de bits de remplissage échouent aussitôt avec invalid_input afin qu'un collage corrompu ne paraisse jamais réussi.
Comment Base32768 regroupe quinze bits en caractères BMP sûrs
Ces plages évitent délibérément les caractères qui cassent la normalisation Unicode, troublent la direction du texte ou ressemblent à du formatage, de sorte que la chaîne encodée est sûre à coller dans la plupart des API propres Unicode. Tout caractère hors des deux répertoires lève invalid_input. Tout le chemin est un travail d'entiers déterministe sans réseau, sans graines aléatoires et sans horloge murale, donc des entrées identiques produisent toujours le même JSON.
Ce que vous envoyez et ce que vous recevez
Les deux sens renvoient mode, le text d'origine, result, un champ length de la chaîne de sortie principale, bits_per_char à quinze, des libellés alphabet et plane, et une courte référence au standard pour que les clients affirment le profil. Encode signale aussi input_bytes ; decode signale output_bytes. Text manquant, objets non chaîne, valeurs de mode non prises en charge, chaînes plus longues que le maximum documenté, caractères Base32768 non reconnus, caractère secondaire de remplissage avant la fin, désaccords de bits de remplissage ou octets décodés non UTF-8 valide échouent avec invalid_input et un message clair en anglais. Le tarif des appels API réussis est la base publiée de $0.002 par élément.
Où Base32768 apparaît dans le travail réel
Blobs de sauvegarde de jeu intégrés au JSON, empreintes compactes de configuration passées par des API presse-papiers, et jetons hors ligne courts qui doivent survivre aux allers-retours de chaînes JavaScript profitent tous de quinze bits par caractère. Comme cette capacité est un moteur parse pur, le tarif API est la base publiée de $0.002 par élément réussi et l'échec de validation ne consomme pas le solde.
Cas d'intégration
Fixtures golden multi-runtime
Générez des vecteurs encode et decode alignés sur la référence qntm Base32768 pour qu'une CI multi-langages partage une seule vérité sur l'empaquetage à quinze bits.
Validation stricte au collage
Décodez des chaînes Base32768 collées par l'utilisateur avec des erreurs invalid_input claires lorsqu'un symbole sort de l'alphabet primaire ou secondaire.