Encodeur Git Base85
« hello » devient la ligne Git Base85 EXk~0{ZvX%Q, dont le E initial indique que la ligne contient cinq octets : le dialecte des correctifs binaires Git, distinct de l'Ascii85 d'Adobe. Encodez du texte ou des octets et décodez des lignes. 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
- Résultat
- EXk~0{ZvX%Q
- Mode de calcul
- Encode
- Format de sortie
- Text
- Variante
- git_base85
Git enregistre les changements de fichiers binaires dans des diffs unifiés avec un dialecte Base85 qui lui est propre, ni Adobe Ascii85 ni Base64 simple. Chaque ligne de données commence par une lettre de préfixe de longueur—de A à Z pour un à vingt-six octets décodés, de a à z pour vingt-sept à cinquante-deux—suivie de cinq caractères de l’alphabet pour chaque quatre octets utiles. Les développeurs qui inspectent des sections GIT binary patch, déboguent des échecs d’apply ou créent des outils compatibles ont besoin d’un convertisseur qui parle exactement cet alphabet et cette forme de ligne.
Encoder du texte ou de l’hex en lignes Git Base85
Pour chaque bloc il écrit un préfixe de longueur (A signifie un octet, B deux, jusqu’à Z pour vingt-six, puis a pour vingt-sept jusqu’à z pour cinquante-deux) et développe chaque groupe de quatre octets en cinq caractères de l’alphabet de quatre-vingt-cinq symboles de Git : chiffres, lettres majuscules et minuscules, et l’ensemble de ponctuation qui omet guillemets, virgules, points, barres et barres inverses afin que les correctifs restent adaptés au courrier et au shell.
Un groupe final court est complété de zéros pour l’arithmétique puis tronqué au nombre correct de blocs de cinq caractères, de sorte que le décodeur retrouve le nombre exact d’octets à partir du seul préfixe. Fixez format à hex lorsque la charge est binaire brute : text doit être une chaîne hexadécimale de longueur paire (espaces et tirets bas autorisés), et ces octets sont encodés sans couche UTF-8. Une entrée vide est valide et produit un résultat vide avec zéro octet et zéro ligne.
Le chemin est de l’arithmétique pure—pas de réseau, pas de sel aléatoire, pas d’horloge—ainsi des entrées identiques produisent toujours des corps Base85 identiques pour les goldens d’intégration continue.
Décoder les lignes à préfixe de longueur et rejeter l’entrée invalide
Fixez mode à decode et placez une ou plusieurs lignes Git Base85 dans text. Les lignes vides sont ignorées pour que vous puissiez coller un fragment copié d’un correctif plus large. Après le préfixe, le reste doit faire exactement cinq fois le nombre de groupes de quatre octets requis pour le décompte déclaré—trop peu ou trop de symboles est une erreur, pas une troncature silencieuse.
Chaque caractère encodé doit appartenir à l’alphabet de Git ; un symbole emprunté à Adobe Ascii85 (par exemple un inférieur à isolé ou un z de plage de zéros que Git n’utilise pas) échoue aussitôt pour que vous n’appliquiez jamais par erreur un dialecte étranger comme corps de correctif binaire. Un décodage réussi concatène toutes les lignes dans l’ordre en un seul tampon d’octets.
Avec format hex le résultat est une chaîne hex en minuscules des octets récupérés, le choix pratique lorsque la charge est un littéral compressé zlib d’un vrai GIT binary patch plutôt que du texte lisible.
Ce qui distingue Git Base85 d'Ascii85
On cherche souvent un encodeur Base85 après avoir vu des données binaires dans un git diff, puis on atterrit sur des outils Adobe Ascii85 avec un autre alphabet, des enveloppes optionnelles less-than-tilde et un raccourci z pour les zéros. Le dialecte de Git est volontairement distinct : quatre-vingt-cinq symboles fixes commençant au chiffre zéro, préfixes de longueur par ligne obligatoires, pas de délimiteurs Adobe et pas de jeton z de compression.
Cette page vise l’intention de recherche spécifique à Git—encodeur git base85, correctif binaire base85, décoder git base85—et ne concurrence pas une page Ascii85 générale. Un autre flux colle seulement les lignes de données d’un GIT binary patch (en sautant l’en-tête literal N si vous connaissez déjà la taille) et récupère les octets pour inspection. Gardez des charges modestes—c’est un élément parse de niveau A, pas un serveur de packfiles—et épinglez les chaînes result dans les goldens car l’algorithme est entièrement déterministe entre isolats et langages qui implémentent la même table.
Cas d’usage
Inspecter des corps de GIT binary patch
Décodez des lignes Base85 à préfixe de longueur copiées d’un git diff --binary pour voler en hex la charge littérale compressée sans appliquer tout le correctif.
Questions fréquentes
Comment encoder du texte en Git Base85 ?
Le champ result contient les lignes jointes par sauts de ligne, chacune avec une lettre de longueur A–z, et bytes est la longueur UTF-8.
Comment décoder des lignes Base85 d’un correctif binaire Git ?
Fixez mode à decode et placez les lignes à préfixe de longueur dans text. Utilisez format hex lorsque la charge est binaire ; format text (par défaut) renvoie de l’UTF-8 si les octets sont de l’Unicode valide.
Qu’est-ce qui distingue Git Base85 d’Adobe Ascii85 ?
Git utilise un alphabet de 85 caractères différent, exige un préfixe de longueur par ligne (A–Z, a–z), n’utilise pas les délimiteurs <~ ~> et n’implémente pas le raccourci z de zéros d’Adobe.
Que se passe-t-il avec une entrée Base85 invalide ?
Les échecs de validation ne sont pas facturés.
Que signifie la première lettre de chaque ligne Git Base85 ?
C'est la longueur de la ligne en octets : A vaut un, B deux, jusqu'à Z pour 26, puis a pour 27 jusqu'à z pour 52. Une ligne ne dépasse jamais 52 octets, et le décodeur s'appuie sur cette lettre pour retrouver le nombre exact.
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/base85-git \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"hello"}'const res = await fetch("https://api.kit.forhosting.com/enc/base85-git", {
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/base85-git",
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/base85-git", 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/base85-git", 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.base85_git",
"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
Cette capacité encode du texte UTF-8 ou des octets hexadécimaux en lignes Git Base85, et les décode en retour tout en rejetant symboles illégaux, préfixes de longueur erronés et tailles de groupe incohérentes avec invalid_input. Les appels API réussis coûtent $0.002 par élément ; les échecs de validation ne sont pas facturés.
Encoder du texte ou de l’hex en lignes Git Base85
Envoyez un corps JSON avec le champ chaîne obligatoire text et laissez mode à encode, ou définissez mode à encode explicitement. Par défaut format vaut text : le moteur encode votre chaîne en UTF-8 puis parcourt les octets par blocs d’au plus cinquante-deux octets—le même maximum que Git utilise sur chaque ligne de correctif binaire. La réponse inclut result (lignes jointes par sauts de ligne), mode encode, format, variant git_base85, bytes (longueur de la charge avant encodage) et lines (lignes de sortie non vides).
Décoder les lignes à préfixe de longueur et rejeter l’entrée invalide
Chaque ligne non vide doit commencer par une lettre de longueur valide ; tout autre premier caractère échoue avec invalid_input en citant la règle du préfixe de longueur. Avec format text (par défaut) ces octets sont interprétés en UTF-8 avec un décodeur fatal : les séquences invalides lèvent invalid_input au lieu de caractères de remplacement qui corrompraient les diffs en aval. La réponse renvoie mode decode, format, variant git_base85, bytes comme longueur décodée et lines comme le nombre de lignes d’entrée non vides. Les échecs de validation ne sont pas facturés sur l’API prépayée, sonder un collage suspect est donc sûr pour les opérateurs et peu coûteux pour les scripts qui conditionnent les fusions au succès de l’analyse.
Différences avec Ascii85 et usage de l’API
Utilisez l’API prépayée KIT à $0.002 par élément réussi lorsqu’un backend, un bot ou un job d’intégration continue doit émettre ou vérifier des corps Git Base85 sous solde ; une validation échouée ne consomme jamais ce solde.
Cas d'intégration
Rédiger des fixtures de test compatibles
Encodez des séquences d’octets connues en lignes Git Base85 pour des tests unitaires d’outils apply, de bots de fusion et de documentation qui doit coller à l’alphabet et aux préfixes de Git.
Détecter les mélanges de dialecte en CI
Rejetez Adobe Ascii85 ou un collage corrompu avec invalid_input avant qu’un pipeline traite un Base85 étranger comme corps valide de correctif binaire.
Questions techniques
L’encodeur Git Base85 est-il gratuit ?
L’outil navigateur s’exécute gratuitement sur votre appareil. Les appels API utilisent le solde prépayé KIT à $0.002 par élément réussi ; les réponses invalid_input ne consomment pas de solde.