Conversão de bases numéricas: binário, hexadecimal, octal e decimal para desenvolvedores

Numa tarde qualquer, você está olhando 0x7FFF5FBFF8C0 no depurador, depois ajusta #FF5733 num arquivo CSS e executa chmod 755 no terminal. Três representações diferentes, a mesma aritmética por trás. Se você precisa parar para converter entre hexadecimal e binário, ou se pergunta por que o Unix usa octal para permissões, este artigo vai conectar esses pontos.

Vamos percorrer os quatro sistemas numéricos do dia a dia da programação, três métodos de conversão que vale a pena memorizar e código funcional em JavaScript, Python, Go e C. Se quiser pular a teoria e converter um número direto, abra nosso conversor de base numérica — suporta qualquer base de 2 a 36 com precisão arbitrária.

Os quatro sistemas numéricos que todo desenvolvedor usa

Cada base existe na programação por uma razão prática.

Binário (base 2) — A linguagem da máquina

Dois dígitos: 0 e 1. Um transistor conduz ou bloqueia — essa restrição física origina o binário. Você o encontra ao trabalhar com máscaras de bits, flags, operações bit a bit e cálculos de sub-rede IP.

O binário fica extenso rápido. O número 255 em decimal é 11111111 em binário — oito dígitos para um valor de três dígitos. Por isso programadores raramente escrevem binário bruto, exceto quando a posição de cada bit importa.

Octal (base 8) — A abreviação do Unix

Oito dígitos: 0 a 7. Cada dígito octal mapeia exatamente para três bits binários, por isso o Unix usa octal para permissões de arquivo — chmod 755 comprime três grupos de três bits em três dígitos legíveis.

O octal tinha um papel mais amplo na era do PDP-11, quando palavras de máquina se dividiam em grupos de 3 bits. Hoje é quase exclusivo das permissões Unix, além de ocasionais literais C prefixados com 0 (fonte de bugs quando alguém escreve 0177 achando que é decimal 177).

Decimal (base 10) — O padrão humano

Dez dígitos: 0 a 9. É o sistema que seu cérebro usa por padrão — números de porta, índices de arrays, códigos HTTP, dimensões em pixels. O computador não opera em decimal, mas humanos operam, então todo número voltado ao usuário sai em base 10.

Hexadecimal (base 16) — O canivete suíço do desenvolvedor

Dezesseis símbolos: 0-9 e A-F. Cada dígito hex representa exatamente quatro bits (um nibble). Dois dígitos hex = um byte. Sempre.

Você encontra hexadecimal em endereços de memória (0x7FFF5FBFF8C0), cores CSS (#FF5733), endereços MAC (00:1A:2B:3C:4D:5E), formato UUID e digests de hash. É a língua franca da programação em nível de byte.

Teste a conversão entre os quatro sistemas no nosso conversor de base numérica — insira um valor em qualquer base e veja os outros atualizarem instantaneamente.

Como funciona a conversão de bases: três métodos fundamentais

Não precisa de ferramenta para converter entre bases, embora acelere o processo. Três métodos cobrem todos os casos.

Método 1 — Expansão posicional (qualquer base → decimal)

Todo sistema posicional funciona igual: cada dígito é multiplicado pela base elevada à potência da sua posição, contando da direita para a esquerda a partir de zero.

Binário 1011:

1×2³ + 0×2² + 1×2¹ + 1×2⁰
= 8   + 0    + 2    + 1
= 11

Hex FF:

15×16¹ + 15×16⁰
= 240   + 15
= 255

No código, a maioria das linguagens tem uma função de parsing:

parseInt('1011', 2)   // 11
parseInt('FF', 16)    // 255
parseInt('755', 8)    // 493

Método 2 — Divisão sucessiva (decimal → qualquer base)

Na direção inversa, divida o número decimal pela base alvo repetidamente e colete os restos. Leia-os de baixo para cima.

Decimal 255 → hexadecimal:

255 ÷ 16 = 15  resto 15 (F)
 15 ÷ 16 =  0  resto 15 (F)
→ De baixo para cima: FF

Decimal 42 → binário:

42 ÷ 2 = 21  resto 0
21 ÷ 2 = 10  resto 1
10 ÷ 2 =  5  resto 0
 5 ÷ 2 =  2  resto 1
 2 ÷ 2 =  1  resto 0
 1 ÷ 2 =  0  resto 1
→ De baixo para cima: 101010

bin(42)    # '0b101010'
hex(255)   # '0xff'
oct(493)   # '0o755'

Método 3 — Agrupamento de bits (binário ↔ hex/octal direto)

Este é o método que desenvolvedores experientes mais usam. Como 16 = 2⁴ e 8 = 2³, a conversão entre binário e hex (ou octal) se faz agrupando bits diretamente, sem cálculos.

Binário → Hex: Agrupe em nibbles (4 bits) da direita. Complete o grupo mais à esquerda com zeros se necessário.

Binário:      1010 1111
Hexadecimal:   A    F
→ AF

Binário → Octal: Agrupe em tripletos (3 bits) da direita.

Binário: 111 101 101
Octal:    7   5   5
→ 755

A tabela de correspondência de nibbles merece ser memorizada:

Binário	Hex	Binário	Hex
`0000`	0	`1000`	8
`0001`	1	`1001`	9
`0010`	2	`1010`	A
`0011`	3	`1011`	B
`0100`	4	`1100`	C
`0101`	5	`1101`	D
`0110`	6	`1110`	E
`0111`	7	`1111`	F

Com essa tabela decorada, converter binário para hex vira leitura direta.

Conversão de bases em cada linguagem

Código prático nas quatro linguagens onde essa operação aparece com mais frequência.

JavaScript / TypeScript

// Parsing: string em qualquer base → número
parseInt('FF', 16)          // 255
parseInt('101010', 2)       // 42
parseInt('755', 8)          // 493

// Formatação: número → string em qualquer base
(255).toString(16)          // 'ff'
(42).toString(2)            // '101010'
(493).toString(8)           // '755'

// Literais
const bin = 0b11111111;     // 255
const oct = 0o377;          // 255
const hex = 0xff;           // 255

// BigInt para valores acima de 2⁵³
const big = BigInt('0xFFFFFFFFFFFFFFFF');
big.toString(2)             // 64 uns
big.toString(10)            // '18446744073709551615'

Python

# Decimal → outras bases (strings com prefixo)
bin(255)          # '0b11111111'
oct(493)          # '0o755'
hex(255)          # '0xff'

# Outras bases → decimal
int('11111111', 2)    # 255
int('FF', 16)         # 255
int('755', 8)         # 493

# Saída formatada com preenchimento
f'{255:08b}'      # '11111111'  (binário de 8 dígitos)
f'{255:02x}'      # 'ff'       (hex minúsculo)
f'{255:02X}'      # 'FF'       (hex maiúsculo)

# Precisão arbitrária nativa em Python
big = int('F' * 64, 16)   # número de 256 bits, sem overflow

Go

package main

import (
    "fmt"
    "strconv"
)

func main() {
    // Formatação: int → string em qualquer base
    fmt.Println(strconv.FormatInt(255, 16))  // "ff"
    fmt.Println(strconv.FormatInt(255, 2))   // "11111111"
    fmt.Println(strconv.FormatInt(493, 8))   // "755"

    // Parsing: string em qualquer base → int
    n, _ := strconv.ParseInt("FF", 16, 64)  // 255
    fmt.Println(n)

    // Verbos Printf
    fmt.Printf("%b %o %x %d\n", 255, 255, 255, 255)
    // 11111111 377 ff 255
}

C

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

int main() {
    // Saída em decimal, octal, hexadecimal
    printf("%d %o %x\n", 255, 255, 255);
    // 255 377 ff

    // Parsing de qualquer base
    long val = strtol("FF", NULL, 16);   // 255
    long bin = strtol("101010", NULL, 2); // 42

    // C não tem printf binário nativo — extração bit a bit:
    uint8_t byte = 0xAF;
    for (int i = 7; i >= 0; i--)
        putchar(((byte >> i) & 1) ? '1' : '0');
    // 10101111

    return 0;
}

Cenários reais de conversão de bases

Cinco situações em que a conversão de bases deixa de ser teoria e passa a ser trabalho.

1. Depuração de endereços de memória

O depurador mostra um ponteiro em 0x7FFF5FBFF8C0. Converter os dois últimos bytes para binário — 1000 1100 0000 — revela alinhamento a 64 bytes (seis zeros finais). O alinhamento afeta performance de cache, operações SIMD e I/O mapeado em memória.

Aritmética de ponteiros também fica mais clara em hex. Um deslocamento de 0x100 a partir de um endereço base são exatamente 256 bytes — uma página em muitos sistemas embarcados.

2. Cores CSS hexadecimais ↔ RGB

A cor #FF5733 são três bytes em pares hexadecimais:

Par	Hex	Decimal	Canal
`FF`	FF	255	Vermelho (máx)
`57`	57	87	Verde
`33`	33	51	Azul

A notação abreviada #F00 expande para #FF0000 — vermelho puro. A variante de 8 dígitos #FF573380 adiciona canal alfa, onde 80 (decimal 128) é aproximadamente 50% de opacidade.

3. Permissões de arquivo Unix (octal)

chmod 755 decomposto:

7 → 111 → rwx  (proprietário: leitura + escrita + execução)
5 → 101 → r-x  (grupo: leitura + execução)
5 → 101 → r-x  (outros: leitura + execução)

Cada dígito octal codifica um grupo de permissões porque três bits de permissão (leitura=4, escrita=2, execução=1) mapeiam para um único dígito octal (0-7). Combinações comuns:

Octal	Binário	Permissões	Uso típico
`755`	`111 101 101`	`rwxr-xr-x`	Executáveis, diretórios
`644`	`110 100 100`	`rw-r--r--`	Arquivos regulares
`700`	`111 000 000`	`rwx------`	Scripts privados
`600`	`110 000 000`	`rw-------`	Chaves SSH, segredos

4. Cálculos de sub-rede

Uma máscara /24 significa 24 uns iniciais em binário:

11111111.11111111.11111111.00000000
→ 255.255.255.0

Para encontrar o endereço de rede, aplique AND bit a bit entre o IP e a máscara:

192.168.1.37   → 11000000.10101000.00000001.00100101
255.255.255.0  → 11111111.11111111.11111111.00000000
Resultado AND  → 11000000.10101000.00000001.00000000
               → 192.168.1.0 (endereço de rede)

Engenheiros de rede alternam constantemente entre decimal (notação IP), binário (cálculos de máscara) e hexadecimal (capturas de pacotes). Nosso conversor de base numérica permite verificar cada octeto individualmente.

5. Leitura de digests de hash e UUIDs

Um hash MD5 como d41d8cd98f00b204e9800998ecf8427e contém 32 caracteres hexadecimais, representando 16 bytes (128 bits). Cada par hex é um byte.

Um UUID segue o padrão 8-4-4-4-12 em hexadecimal:

550e8400-e29b-41d4-a716-446655440000

32 dígitos hex separados por hífens — os mesmos 128 bits, formatados diferentemente. O nibble de versão fica na posição 13 (o 4 em 41d4 indica UUID v4).

Gere hashes com nosso gerador de hash MD5 & SHA ou crie UUIDs com nosso gerador de UUID — ambos produzem saída hexadecimal.

Além da base 16: base 36, base 64 e bases personalizadas

As quatro bases padrão cobrem a maior parte do trabalho, mas algumas outras aparecem em contextos especializados.

Base 36 — Codificação alfanumérica compacta

Base 36 usa os 10 dígitos mais as 26 letras (A-Z), oferecendo a representação alfanumérica case-insensitive mais compacta possível. Serviços de encurtamento de URL adoram — IDs de vídeos do YouTube, links curtos e chaves de banco de dados frequentemente usam base 36.

(1000000).toString(36)    // 'lfls'
parseInt('lfls', 36)      // 1000000

Um milhão em quatro caracteres. Para identificadores curtos compatíveis com URL, difícil superar.

Base 64 — Codificação de dados (não um sistema numérico)

Base64 parece outra base, mas serve um propósito diferente. Em vez de representar um valor numérico num sistema posicional, Base64 codifica dados binários arbitrários (imagens, arquivos, tokens JWT) como texto ASCII. Usa A-Z, a-z, 0-9, + e / — 64 símbolos no total.

É um esquema de codificação, não um sistema numérico. Para codificar e decodificar Base64, use nosso codificador-decodificador Base64.

Bases arbitrárias (2-36) e onde aparecem

Algumas outras bases surgem ocasionalmente:

Base 12 (duodecimal): Tempo (12 horas), quantidades (dúzia). Alguns matemáticos argumentam que base 12 seria melhor que base 10 porque 12 tem mais divisores.
Base 60 (sexagesimal): Tempo (60 segundos, 60 minutos) e ângulos (360°). Herdado da matemática babilônica.
Base 32: Codificação Base32 de Crockford para identificadores legíveis (exclui caracteres ambíguos como I, L, O). Também usado em geohashing.

Nosso conversor de base numérica suporta qualquer base inteira de 2 a 36.

Operações bit a bit e conversão de bases

Entender binário vai além de converter números — é a base das operações bit a bit presentes em programação de sistemas, desenvolvimento de jogos e sistemas de permissões.

const READ  = 0b100;  // 4
const WRITE = 0b010;  // 2
const EXEC  = 0b001;  // 1

// Combinar permissões com OR
const perms = READ | WRITE;  // 0b110 = 6

// Verificar permissão com AND
(perms & READ)  !== 0   // true  — tem leitura
(perms & EXEC)  !== 0   // false — sem execução

// Alternar permissão com XOR
perms ^ WRITE   // 0b100 = 4 — escrita removida

// Deslocamentos
1 << 3    // 0b1000 = 8  (1 deslocado 3 para a esquerda)
0xFF >> 4  // 0b00001111 = 15  (deslocamento direito 4 = dividir por 16)

Feature flags, registradores de hardware, protocolos de rede, programação gráfica — todos dependem de operações bit a bit. Quando você lê binário fluentemente, manipulação de bits deixa de parecer mágica.

FAQ

Quais são os quatro principais sistemas numéricos em programação?

Binário (base 2), octal (base 8), decimal (base 10) e hexadecimal (base 16). Binário é a forma física dos dados no hardware. Octal serve para permissões Unix. Decimal é o padrão humano. Hexadecimal comprime binário em formato legível — cada dígito hex equivale a exatamente 4 bits.

Como converto binário para hexadecimal?

Agrupe os bits em conjuntos de 4 da direita, preenchendo o último grupo à esquerda com zeros. Mapeie cada grupo: 0000=0, 0001=1, …, 1010=A, …, 1111=F. Exemplo: binário 10101111 → grupos 1010 1111 → hex AF. Funciona porque 16 = 2⁴.

Como converto hexadecimal para decimal?

Multiplique cada dígito hex por 16 elevado à potência da sua posição (mais à direita = 0), depois some. Lembre: A=10, B=11, C=12, D=13, E=14, F=15. Exemplo: hex FF = 15×16¹ + 15×16⁰ = 240 + 15 = 255. No código: JavaScript parseInt('FF', 16), Python int('FF', 16).

Por que desenvolvedores usam hexadecimal em vez de binário?

Hex é compacto. Cada dígito hex mapeia exatamente 4 bits, então 11111111 00001010 em binário vira FF0A em hex — bem mais curto e fácil de ler. Hex é o padrão para endereços de memória, cores CSS (#FF5733), endereços MAC, saídas de hash e formato UUID.

O que é um nibble e qual a relação com conversão hex?

Um nibble são 4 bits — meio byte. Um nibble mapeia exatamente para um dígito hexadecimal, tornando a conversão binário-hex uma simples consulta nibble por nibble. Um byte = dois nibbles = dois dígitos hex. Essa correspondência limpa de 4 bits é a razão pela qual hex se tornou o padrão para dados em nível de byte.

Por que permissões Unix são escritas em octal?

Cada grupo de permissões tem três bits: leitura (4), escrita (2), execução (1). São três grupos (proprietário, grupo, outros). Como 2³ = 8, três bits de permissão correspondem a um único dígito octal. 755 significa proprietário=7 (rwx), grupo=5 (r-x), outros=5 (r-x). Octal é a base natural para agrupamentos de 3 bits.

Como lidar com números maiores que 2⁵³ em JavaScript?

Use BigInt. Adicione n a um literal ou use o construtor BigInt(): BigInt('0xFFFFFFFFFFFFFFFF').toString(2) produz a string binária completa de 64 bits. O tipo Number padrão perde precisão acima de 9.007.199.254.740.991 (2⁵³ - 1). Nosso conversor de base numérica usa BigInt internamente, processando números de qualquer tamanho sem perda de precisão.

Como converto hexadecimal para binário?

Substitua cada dígito hex pelo equivalente de 4 bits usando a tabela de nibbles ao contrário: 0=0000, 1=0001, …, A=1010, …, F=1111. Exemplo: hex AF → A (1010) + F (1111) → binário 10101111. No código: JavaScript parseInt('AF', 16).toString(2) ou Python bin(int('AF', 16))[2:].

Como ler endereços IPv6 em hexadecimal?

Endereços IPv6 têm 128 bits representados como 8 grupos de 4 dígitos hex separados por dois-pontos, como 2001:0db8:85a3:0000:0000:8a2e:0370:7334. Cada grupo são 16 bits (4 nibbles). Regras de compressão: zeros à esquerda dentro de um grupo podem ser omitidos (0db8 → db8), e uma sequência de grupos zero pode virar :: uma única vez (2001:db8:85a3::8a2e:370:7334). O prefixo /64 típico reserva os primeiros 64 bits para a rede e os outros 64 para o host — dobrando a matemática de sub-rede do IPv4 mas mantendo os mesmos princípios binários.