Cómo funciona la codificación Base64

Base64 es elegante porque reutiliza ideas que ya conoces: bits, potencias de dos y una tabla de búsqueda (el alfabeto). No hay diccionario en prosa ni paso de compresión — solo reordenamiento determinista de bits más sustitución de caracteres.

De bytes a un flujo de bits

Un byte son ocho bits. Tres bytes dan 24 bits:

Byte1: ########
Byte2: ########
Byte3: ########   → concatenar en 24 bits en orden

Base64 reagrupa esos 24 bits en cuatro sextetos (seis bits cada uno):

[######][######][######][######]
  ^        ^        ^        ^
 idx 0    idx 1    idx 2    idx 3

Cada valor de seis bits va de 0–63, lo que indexa uno de 64 símbolos. Ese conteo de índices es literalmente de donde sale el nombre «base 64»: escribes números en base 64, usando caracteres ASCII imprimibles en lugar de dígitos 0–63.

El alfabeto estándar (estilo RFC)

Base64 tradicional asigna:

0–25 → A–Z
26–51 → a–z
52–61 → 0–9
62 → '+'
63 → '/'

La decodificación recorre el mapa inverso: símbolo → seis bits → reconstruir grupos originales de ocho bits.

Mini ejemplo a mano (dos bytes → cuatro chars con intuición de relleno)

Rara vez necesitas trazar manualmente en el día a día, pero afianza la intuición. Toma ASCII "Hi":

• H = 0x48 (01001000)
• i = 0x69 (01101001)

Concatena 16 bits: 0100100001101001.

Rellena a la derecha con ceros hasta que la longitud sea divisible por seis (la lección sobre relleno profundiza):

010010 | 000110 | 100100 |
  18  |    6   |   36   |

El cuarto sexteto está incompleto hasta que llegue más entrada; los serializadores emiten marcadores de relleno = (detallado en la siguiente lección). Las bibliotecas manejan esto mecánicamente — ver las divisiones explica por qué crecen las longitudes y por qué la corrupción voltea los bits posteriores de forma drástica.

Por qué la salida crece ~33%

Cada trío de bytes (24 bits) se convierte en cuatro caracteres codificados que representan la misma entropía repartida en texto imprimible. Crecimiento promedio simplificado: para n bytes de entrada, espera unos ceil(4n/3) caracteres antes del relleno.

Más símbolos de relleno = cuando n mod 3 != 0. Ese overhead es esperado; Base64 intercambió tamaño por compatibilidad.

Simetría de decodificación

Decodificar:

1. Mapea cada carácter del alfabeto → valor de seis bits (las peculiaridades de +// aparecen solo si elegiste la variante correspondiente más adelante).
2. Concatena bits.
3. Reagrupa en bytes (fragmentos de ocho bits).

Si la longitud de la cadena es malformada o aparecen símbolos falsos (p. ej., espacios en blanco o índice de alfabeto incorrecto), la decodificación falla — o peor, interoperan de forma inconsistente según parsers laxos.

Idea clave

Base64 refragmenta bits en grupos de seis y sustituye cada fragmento por uno de sesenta y cuatro caracteres imprimibles predeterminados. Una vez visualizas el reagrupamiento, el relleno y las sustituciones URL-safe dejan de ser misteriosos. Usa la herramienta Base64 para codificar y decodificar muestras.