Codificador Git Base85
«hello» se convierte en la línea Git Base85 EXk~0{ZvX%Q, cuya E inicial indica que la línea guarda cinco bytes: el dialecto que Git usa en los parches binarios, distinto del Ascii85 de Adobe. Codifica texto o bytes y decodifica líneas. Gratis en su navegador.
- Gratis
- Funciona en su navegador
- Sin registro
- Sus datos no salen de su equipo
Ejecutar — gratis
Ejemplo resuelto
- Texto
- hello
- Resultado
- EXk~0{ZvX%Q
- Modo de cálculo
- Encode
- Formato de salida
- Text
- Variante
- git_base85
Git guarda los cambios de archivos binarios dentro de diffs unificados con un dialecto Base85 propio, no Adobe Ascii85 ni Base64 simple. Cada línea de datos empieza con una letra de prefijo de longitud—de A a Z para uno a veintiséis bytes decodificados, de a a z para veintisiete a cincuenta y dos—seguida de cinco caracteres del alfabeto por cada cuatro bytes de carga. Quienes inspeccionan secciones GIT binary patch, depuran fallos de apply o construyen herramientas compatibles necesitan un conversor que use exactamente ese alfabeto y esa forma de línea.
Codificar texto o hex en líneas Git Base85
En cada bloque escribe un prefijo de longitud (A significa un byte, B dos, hasta Z para veintiséis, luego a para veintisiete hasta z para cincuenta y dos) y expande cada grupo de cuatro bytes en cinco caracteres del alfabeto de ochenta y cinco símbolos de Git: dígitos, letras mayúsculas y minúsculas, y el conjunto de puntuación que omite comillas, comas, puntos, barras y contrabarras para que los parches sigan siendo amigables para correo y shell.
Un grupo final corto se rellena con ceros para la aritmética y luego se trunca al número correcto de bloques de cinco caracteres, de modo que el decodificador recupera el conteo exacto de bytes solo con el prefijo. Fije format en hex cuando la carga sea binaria en bruto: text debe ser una cadena hexadecimal de longitud par (se permiten espacios y guiones bajos), y esos bytes se codifican sin capa UTF-8. La entrada vacía es válida y produce un resultado vacío con cero bytes y cero líneas.
El camino es aritmética pura—sin red, sin sal aleatoria, sin reloj—así que entradas idénticas siempre producen cuerpos Base85 idénticos para goldens de integración continua.
Decodificar líneas con prefijo de longitud y rechazar entrada inválida
Fije mode en decode y coloque una o más líneas Git Base85 en text. Las líneas en blanco se ignoran para que pueda pegar un fragmento copiado de un parche mayor. Tras el prefijo, el resto debe ser exactamente cinco veces el número de grupos de cuatro bytes necesarios para el conteo declarado—demasiados o demasiados pocos símbolos es un error, no un truncado silencioso.
Cada carácter codificado debe pertenecer al alfabeto de Git; un símbolo tomado de Adobe Ascii85 (por ejemplo un menor-que suelto o un z de corrida de ceros que Git no usa) falla de inmediato para que nunca aplique por error un dialecto ajeno como cuerpo de parche binario. Una decodificación correcta concatena todas las líneas en orden en un único búfer de bytes.
Con format hex el resultado es una cadena hex en minúsculas de los bytes recuperados, la opción práctica cuando la carga es un literal comprimido con zlib de un GIT binary patch real y no texto legible.
En qué se diferencia Git Base85 de Ascii85
A menudo se busca un codificador Base85 tras ver datos binarios en un git diff y se acaba en herramientas Adobe Ascii85 con otro alfabeto, envolturas opcionales less-than-tilde y un atajo z para ceros. El dialecto de Git es deliberadamente distinto: ochenta y cinco símbolos fijos que empiezan en el dígito cero, prefijos de longitud por línea obligatorios, sin delimitadores Adobe y sin token z de compresión.
Esta página atiende esa intención de búsqueda específica de Git—codificador git base85, parche binario base85, decodificar git base85—y no compite con una página Ascii85 general. Otro flujo pega solo las líneas de datos de un GIT binary patch (omitendo la cabecera literal N si ya conoce el tamaño) y recupera bytes para inspección. Mantenga cargas modestas—es un ítem parse de nivel A, no un servidor de packfiles—y fije las cadenas result en goldens porque el algoritmo es totalmente determinista entre aislados e idiomas que implementan la misma tabla.
Qué puede hacer con ella
Inspeccionar cuerpos de GIT binary patch
Decodifique líneas Base85 con prefijo de longitud copiadas de un git diff --binary para volcar en hex la carga literal comprimida sin aplicar todo el parche.
Preguntas frecuentes
¿Cómo codifico texto a Git Base85?
El campo result contiene las líneas unidas por saltos de línea, cada una con letra de longitud A–z, y bytes es la longitud UTF-8.
¿Cómo decodifico líneas Base85 de un parche binario de Git?
Fije mode en decode y ponga las líneas con prefijo de longitud en text. Use format hex cuando la carga sea binaria; format text (predeterminado) devuelve UTF-8 si los bytes son Unicode válido.
¿Qué diferencia Git Base85 de Adobe Ascii85?
Git usa un alfabeto de 85 caracteres distinto, exige prefijo de longitud por línea (A–Z, a–z), no usa delimitadores <~ ~> y no implementa el atajo z de ceros de Adobe.
¿Es gratis el codificador Git Base85?
La herramienta del navegador se ejecuta gratis en su dispositivo.
¿Qué significa la primera letra de cada línea Git Base85?
Es la longitud de esa línea en bytes: A significa uno, B dos, hasta Z para 26, y después a para 27 hasta z para 52. Una línea nunca guarda más de 52 bytes, y el decodificador usa esa letra para recuperar la cantidad exacta.
Herramientas relacionadas
Para desarrolladores — acceso por API
Todo lo de esta página está disponible por programación. Esta sección es para equipos que quieren integrarlo en sus sistemas; el resto puede usar la herramienta de arriba sin más.
Endpoint de API
¿Prefiere automatizarlo? Un POST autenticado crea la tarea; el resultado llega por webhook o enlace firmado. La misma capacidad también se ejecuta aquí en la web, por email y desde Telegram — y pronto también desde nuestra app.
Llámela desde su 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)Ejemplo de solicitud
{
"text": "hello"
}Ejemplo de respuesta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.base85_git",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}La API es asíncrona: la llamada devuelve un task_id al instante y el resultado llega por webhook. El polling está limitado a 1 req/s por tarea.
Precio
Precio publicado — sin tokens ni créditos inventados. Una tarea fallida no se cobra.
Errores
| HTTP | Código | Significado |
|---|---|---|
401 | unauthorized | API key ausente o inválida. |
402 | insufficient_balance | El saldo no cubre el precio de la tarea. |
404 | unknown_type | El tipo de tarea no existe. |
429 | rate_limited | Demasiadas peticiones. Use el webhook en vez de sondear. |
Notas técnicas
Esta capacidad codifica texto UTF-8 o bytes hexadecimales en líneas Git Base85 y las decodifica de vuelta, rechazando símbolos ilegales, prefijos de longitud erróneos y tamaños de grupo incoherentes con invalid_input. Las llamadas API correctas cuestan $0.002 por ítem; los fallos de validación no se cobran.
Codificar texto o hex en líneas Git Base85
Envíe un cuerpo JSON con el campo de cadena obligatorio text y deje mode en encode, o fije mode en encode de forma explícita. Por defecto format es text: el motor codifica su cadena en UTF-8 y recorre los bytes en bloques de como máximo cincuenta y dos octetos—el mismo máximo que Git usa en cada línea de parche binario. La respuesta incluye result (líneas unidas por saltos de línea), mode encode, format, variant git_base85, bytes (longitud de la carga antes de codificar) y lines (líneas de salida no vacías).
Decodificar líneas con prefijo de longitud y rechazar entrada inválida
Cada línea no vacía debe empezar con una letra de longitud válida; cualquier otro primer carácter falla con invalid_input citando la regla del prefijo de longitud. Con format text (predeterminado) esos bytes se interpretan como UTF-8 con decodificador fatal: las secuencias inválidas lanzan invalid_input en lugar de caracteres de reemplazo que corromperían diffs posteriores. La respuesta repite mode decode, format, variant git_base85, bytes como longitud decodificada y lines como el conteo de líneas de entrada no vacías. Los fallos de validación no se facturan en la API prepago, así que sondear un pegado sospechoso es seguro para operadores y barato para scripts que condicionan fusiones al éxito del parseo.
En qué se diferencia de Ascii85 y cómo usar la API
Use la API prepago de KIT a $0.002 por ítem correcto cuando un backend, bot o trabajo de integración continua deba emitir o verificar cuerpos Git Base85 con saldo; la validación fallida nunca consume ese saldo.
Casos de integración
Crear fixtures de prueba compatibles
Codifique secuencias de bytes conocidas en líneas Git Base85 para pruebas unitarias de herramientas apply, bots de fusión y documentación que deba coincidir con el alfabeto y los prefijos de Git.
Detectar mezclas de dialecto en CI
Rechace Adobe Ascii85 o pegados corruptos con invalid_input antes de que un pipeline trate un Base85 ajeno como cuerpo válido de parche binario.
Preguntas técnicas
¿Qué ocurre con una entrada Base85 inválida?
La decodificación falla con invalid_input por prefijos de longitud erróneos, caracteres fuera del alfabeto de Git, tamaños de grupo incorrectos o UTF-8 inválido cuando format es text. Los fallos de validación no se cobran.