Como funciona a codificação Base64

Base64 é elegante porque reutiliza ideias que você já conhece: bits, potências de dois e uma tabela de lookup (o alfabeto). Não há dicionário em prosa nem compressão — só reagrupamento determinístico de bits mais substituição de caracteres.

De bytes para fluxo de bits

Um byte tem oito bits. Três bytes dão 24 bits:

Byte1: ########
Byte2: ########
Byte3: ########   → concatene em 24 bits em ordem

Base64 reagrupa esses 24 bits em quatro sextetos (seis bits cada):

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

Cada valor de seis bits vai de 0–63 e indexa um dos 64 símbolos. Daí o nome “base 64”: você escreve números em base 64 com caracteres ASCII imprimíveis em vez de dígitos 0–63.

Alfabeto padrão (estilo RFC)

Base64 tradicional atribui:

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

Decodificar é o mapa inverso: símbolo → seis bits → reconstruir grupos de oito bits.

Mini exemplo manual (dois bytes → quatro chars com intuição de padding)

Raramente você faz isso na mão, mas fixa a intuição. ASCII "Hi":

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

Concatene 16 bits: 0100100001101001.

Preencha à direita com zeros até o comprimento ser múltiplo de seis (a lição de padding aprofunda):

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

O quarto sexteto fica incompleto até chegar mais entrada; serializadores emitem = (próxima lição). Bibliotecas fazem isso mecanicamente — ver os cortes explica por que o tamanho cresce e por que corrupção altera bits downstream.

Por que a saída cresce ~33%

Cada trio de bytes (24 bits) vira quatro caracteres codificados com a mesma entropia espalhada em texto imprimível. Média simplificada: para n bytes de entrada, espere cerca de ceil(4n/3) caracteres antes do padding.

Mais símbolos = quando n mod 3 != 0. Esse overhead é esperado; Base64 trocou tamanho por compatibilidade.

Simetria na decodificação

Para decodificar:

1. Mapeie cada caractere do alfabeto → valor de seis bits (peculiaridades +// só se você escolheu a variante certa depois).
2. Concatene bits.
3. Reagruppe em bytes (grupos de oito bits).

Se o comprimento da string for malformado ou surgirem símbolos inválidos (espaço, índice de alfabeto errado), o decode falha — ou pior, interoperam de forma inconsistente conforme parsers permissivos.

Resumo

Base64 rechunka bits em grupos de seis e substitui cada chunk por um dos sessenta e quatro caracteres imprimíveis pré-definidos. Visualizando o reagrupamento, padding e substituições URL-safe deixam de ser mistério.