Codificatore Git Base85
«hello» diventa la riga Git Base85 EXk~0{ZvX%Q, la cui E iniziale indica che la riga contiene cinque byte: il dialetto che Git usa per le patch binarie, diverso dall'Ascii85 di Adobe. Codifica testo o byte e decodifica righe. Gratis nel suo browser.
- Gratis
- Funziona nel suo browser
- Senza registrazione
- I suoi dati restano sul dispositivo
Esegui gratis nel browser
Esempio risolto
- Testo
- hello
- Risultato
- EXk~0{ZvX%Q
- Modalità di calcolo
- Encode
- Formato di uscita
- Text
- Variante
- git_base85
Git memorizza le modifiche ai file binari nei diff unificati con un dialetto Base85 proprio, non Adobe Ascii85 né Base64 semplice. Ogni riga di dati inizia con una lettera di prefisso di lunghezza—da A a Z per uno a ventisei byte decodificati, da a a z per ventisette a cinquantadue—seguita da cinque caratteri dell’alfabeto ogni quattro byte di carico. Chi ispeziona sezioni GIT binary patch, diagnostica errori di apply o costruisce strumenti compatibili ha bisogno di un convertitore che parli esattamente quell’alfabeto e quella forma di riga.
Codificare testo o hex in righe Git Base85
Per ogni blocco scrive un prefisso di lunghezza (A significa un byte, B due, fino a Z per ventisei, poi a per ventisette fino a z per cinquantadue) e espande ogni gruppo di quattro byte in cinque caratteri dell’alfabeto a ottantacinque simboli di Git: cifre, lettere maiuscole e minuscole, e l’insieme di punteggiatura che omette virgolette, virgole, punti, barre e backslash così le patch restano adatte a posta e shell.
Un gruppo finale corto viene riempito di zeri per l’aritmetica e poi troncato al numero corretto di blocchi da cinque caratteri, così il decodificatore recupera il conteggio esatto dei byte dal solo prefisso. Imposti format su hex quando il carico è binario grezzo: text deve essere una stringa esadecimale di lunghezza pari (spazi e underscore ammessi), e quei byte vengono codificati senza strato UTF-8. L’ingresso vuoto è valido e produce un risultato vuoto con zero byte e zero righe.
Decodificare righe con prefisso di lunghezza e rifiutare l’ingresso non valido
Imposti mode su decode e inserisca una o più righe Git Base85 in text. Le righe vuote vengono ignorate così può incollare un frammento copiato da una patch più ampia. Dopo il prefisso, il resto deve essere esattamente cinque volte il numero di gruppi da quattro byte necessari per il conteggio dichiarato—troppi o troppo pochi simboli sono un errore, non un troncamento silenzioso.
Ogni carattere codificato deve appartenere all’alfabeto di Git; un simbolo preso da Adobe Ascii85 (ad esempio un minore isolato o una z di corsa di zeri che Git non usa) fallisce subito così non applica mai per errore un dialetto estraneo come corpo di patch binario. Una decodifica riuscita concatena tutte le righe in ordine in un unico buffer di byte.
Con format hex il risultato è una stringa hex minuscola dei byte recuperati, la scelta pratica quando il carico è un letterale compresso zlib di un vero GIT binary patch e non testo leggibile.
Cosa distingue Git Base85 da Ascii85
Spesso si cerca un codificatore Base85 dopo aver visto dati binari in un git diff e si finisce su strumenti Adobe Ascii85 con un altro alfabeto, involucri opzionali less-than-tilde e una scorciatoia z per gli zeri. Il dialetto di Git è volutamente distinto: ottantacinque simboli fissi che iniziano dalla cifra zero, prefissi di lunghezza per riga obbligatori, nessun delimitatore Adobe e nessun token z di compressione. Questa pagina risponde all’intento di ricerca specifico di Git—codificatore git base85, patch binario base85, decodificare git base85—e non compete con una pagina Ascii85 generica.
Un altro flusso incolla solo le righe dati di un GIT binary patch (saltando l’intestazione literal N se conosce già la dimensione) e recupera i byte per l’ispezione.
Casi d'uso
Ispezionare corpi di GIT binary patch
Decodifichi righe Base85 con prefisso di lunghezza copiate da un git diff --binary per fare hex-dump del carico letterale compresso senza applicare l’intera patch.
Domande frequenti
Come codifico testo in Git Base85?
Il campo result contiene le righe unite da a capo, ciascuna con lettera di lunghezza A–z, e bytes è la lunghezza UTF-8.
Come decodifico righe Base85 di una patch binaria Git?
Imposti mode su decode e metta le righe con prefisso di lunghezza in text. Usi format hex quando il carico è binario; format text (predefinito) restituisce UTF-8 se i byte sono Unicode valido.
Cosa distingue Git Base85 da Adobe Ascii85?
Git usa un alfabeto di 85 caratteri diverso, richiede un prefisso di lunghezza per riga (A–Z, a–z), non usa i delimitatori <~ ~> e non implementa la scorciatoia z degli zeri di Adobe.
Il codificatore Git Base85 è gratuito?
Lo strumento del browser viene eseguito gratis sul suo dispositivo.
Che cosa significa la prima lettera di ogni riga Git Base85?
È la lunghezza di quella riga in byte: A vale uno, B due, fino a Z per 26, poi a per 27 fino a z per 52. Una riga non contiene mai più di 52 byte, e il decodificatore usa quella lettera per ricavare il numero esatto.
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/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)Esempio di richiesta
{
"text": "hello"
}Esempio di risposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.base85_git",
"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.
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
Questa capacità codifica testo UTF-8 o byte esadecimali in righe Git Base85 e le decodifica di nuovo, rifiutando simboli illegali, prefissi di lunghezza errati e dimensioni di gruppo incoerenti con invalid_input. Le chiamate API riuscite costano $0.002 per elemento; i fallimenti di validazione non vengono addebitati.
Codificare testo o hex in righe Git Base85
Invii un corpo JSON con il campo stringa obbligatorio text e lasci mode su encode, oppure imposti mode su encode in modo esplicito. Per impostazione predefinita format è text: il motore codifica la sua stringa in UTF-8 e scorre i byte a blocchi di al massimo cinquantadue ottetti—lo stesso massimo che Git usa su ogni riga di patch binario. La risposta include result (righe unite da a capo), mode encode, format, variant git_base85, bytes (lunghezza del carico prima della codifica) e lines (righe di uscita non vuote).
Decodificare righe con prefisso di lunghezza e rifiutare l’ingresso non valido
Ogni riga non vuota deve iniziare con una lettera di lunghezza valida; qualsiasi altro primo carattere fallisce con invalid_input citando la regola del prefisso di lunghezza. Con format text (predefinito) quei byte sono interpretati come UTF-8 con decodificatore fatale: sequenze non valide sollevano invalid_input invece di caratteri di sostituzione che corromperebbero i diff a valle. La risposta ripete mode decode, format, variant git_base85, bytes come lunghezza decodificata e lines come conteggio delle righe di ingresso non vuote. I fallimenti di validazione non vengono fatturati sull’API prepagata, quindi sondare un incolla sospetto è sicuro per gli operatori e conveniente per gli script che condizionano le fusioni al successo del parsing.
Differenze rispetto ad Ascii85 e uso dell’API
Usi l’API prepagata KIT a $0.002 per elemento riuscito quando un backend, un bot o un job di integrazione continua deve emettere o verificare corpi Git Base85 con saldo; la validazione fallita non consuma mai quel saldo.
Casi di integrazione
Scrivere fixture di test compatibili
Codifichi sequenze di byte note in righe Git Base85 per test unitari di strumenti apply, bot di merge e documentazione che deve combaciare con alfabeto e prefissi di Git.
Intercettare misture di dialetto in CI
Rifiuti Adobe Ascii85 o incolla corrotti con invalid_input prima che una pipeline tratti un Base85 estraneo come corpo valido di patch binario.
Domande tecniche
Cosa succede con un ingresso Base85 non valido?
La decodifica fallisce con invalid_input per prefissi di lunghezza errati, caratteri fuori dall’alfabeto Git, dimensioni di gruppo scorrette o UTF-8 non valido quando format è text. I fallimenti di validazione non vengono addebitati.