Guia de Binário e Conversão de Bases: Compreensão Visual de Operações de Bits à Codificação de Dados

Ferramentas de desenvolvimento

Fundamentos de Sistemas Numéricos

Quatro Bases Comuns

Base Radix Dígitos Prefixo Exemplo
Binário 2 0,1 0b 0b1010 = 10
Octal 8 0-7 0o 0o12 = 10
Decimal 10 0-9 Nenhum 10
Hexadecimal 16 0-9,A-F 0x 0xA = 10

Métodos de Conversão

Qualquer Base → Decimal

Binário 1010 → 1×2³ + 0×2² + 1×2¹ + 0×2⁰ = 8 + 0 + 2 + 0 = 10
Hexadecimal FF → 15×16¹ + 15×16⁰ = 240 + 15 = 255

Decimal → Qualquer Base

10 → Binário:
10 ÷ 2 = 5 resto 0
5 ÷ 2 = 2 resto 1
2 ÷ 2 = 1 resto 0
1 ÷ 2 = 0 resto 1
Ler de baixo para cima: 1010

255 → Hexadecimal:
255 ÷ 16 = 15 resto 15
15 ÷ 16 = 0 resto 15
Ler de baixo para cima: FF

Conversão de Bases em JavaScript

// parseInt para decimal
parseInt('1010', 2)    // 10
parseInt('FF', 16)     // 255
parseInt('12', 8)      // 10

// toString para base destino
(10).toString(2)       // "1010"
(255).toString(16)     // "ff"
(255).toString(8)      // "377"

// Literais
0b1010   // 10
0o12     // 10
0xFF     // 255

Operações de Bits na Prática

Seis Operações de Bits

Operação Símbolo Exemplo Resultado
AND & 0b1100 & 0b1010 0b1000 (8)
OR ` ` `0b1100
XOR ^ 0b1100 ^ 0b1010 0b0110 (6)
NOT ~ ~0b1100 -0b1101 (-13)
Deslocamento esquerda << 0b0011 << 2 0b1100 (12)
Deslocamento direita >> 0b1100 >> 2 0b0011 (3)

Aplicação 1: Sistema de Permissões

const PERMISSIONS = {
  READ:    1 << 0,  // 0b0001 = 1
  WRITE:   1 << 1,  // 0b0010 = 2
  DELETE:  1 << 2,  // 0b0100 = 4
  ADMIN:   1 << 3,  // 0b1000 = 8
};

// Combinar permissões
const editor = PERMISSIONS.READ | PERMISSIONS.WRITE;  // 0b0011 = 3
const admin = PERMISSIONS.READ | PERMISSIONS.WRITE | PERMISSIONS.DELETE | PERMISSIONS.ADMIN;  // 0b1111 = 15

// Verificar permissões
function hasPermission(userPermissions: number, permission: number): boolean {
  return (userPermissions & permission) === permission;
}

hasPermission(editor, PERMISSIONS.READ);    // true
hasPermission(editor, PERMISSIONS.DELETE);  // false
hasPermission(admin, PERMISSIONS.ADMIN);    // true

// Adicionar permissão
function addPermission(userPermissions: number, permission: number): number {
  return userPermissions | permission;
}

// Remover permissão
function removePermission(userPermissions: number, permission: number): number {
  return userPermissions & ~permission;
}

Aplicação 2: Flags

const FLAGS = {
  BOLD:      1 << 0,  // 1
  ITALIC:    1 << 1,  // 2
  UNDERLINE: 1 << 2,  // 4
  STRIKETHROUGH: 1 << 3, // 8
};

// Definir: negrito + itálico
let style = FLAGS.BOLD | FLAGS.ITALIC;  // 3

// Alternar sublinhado
style ^= FLAGS.UNDERLINE;  // 7 (adicionar sublinhado)
style ^= FLAGS.UNDERLINE;  // 3 (remover sublinhado)

Aplicação 3: Cor RGB

// RGB → número
function rgbToNumber(r: number, g: number, b: number): number {
  return (r << 16) | (g << 8) | b;
}

// Número → RGB
function numberToRgb(n: number): { r: number; g: number; b: number } {
  return {
    r: (n >> 16) & 0xFF,
    g: (n >> 8) & 0xFF,
    b: n & 0xFF,
  };
}

rgbToNumber(255, 128, 0);     // 0xFF8000 = 16744448
numberToRgb(0xFF8000);        // { r: 255, g: 128, b: 0 }

Aplicação 4: Cálculo Rápido

// Multiplicar por potências de 2
n * 2     === n << 1
n * 4     === n << 2
n * 8     === n << 3

// Dividir por potências de 2 (truncar)
n / 2     === n >> 1  // números positivos
Math.floor(n / 2) === n >> 1

// Verificar par/ímpar
n & 1     // 0 = par, 1 = ímpar

// Módulo de potências de 2
n % 4     === n & 3
n % 8     === n & 7
n % 16    === n & 15

// Trocar dois valores (sem variável temporária)
a ^= b; b ^= a; a ^= b;

Números de Ponto Flutuante IEEE 754

Estrutura de Dupla Precisão (64 bits)

Bit de sinal(1)  Bits de expoente(11)    Bits de mantissa(52)
S                EEEEEEEEEEE             MMMMMMMMMMMM...MMMM

Exemplo: -12.375
Sinal: 1 (negativo)
Expoente: 10000000010 (1026, com offset 3)
Mantissa: 1001001100000000...0

Problemas de Precisão

// Problema clássico
0.1 + 0.2 === 0.3   // falso!
0.1 + 0.2            // 0.30000000000000004

// Razão: 0.1 e 0.2 em binário são decimais periódicos infinitos
// 0.1 = 0.0001100110011... (periódico)
// 0.2 = 0.0011001100110... (periódico)

// Soluções
// 1. Usar aritmética de inteiros
(0.1 * 10 + 0.2 * 10) / 10  // 0.3

// 2. Usar toFixed
(0.1 + 0.2).toFixed(1)       // "0.3"

// 3. Usar comparação com EPSILON
Math.abs(0.1 + 0.2 - 0.3) < Number.EPSILON  // true

Valores Especiais

Number.MAX_SAFE_INTEGER    // 9007199254740991 (2^53 - 1)
Number.MIN_SAFE_INTEGER    // -9007199254740991
Number.MAX_VALUE           // 1.7976931348623157e+308
Number.EPSILON             // 2.220446049250313e-16
Infinity                   // Infinito positivo
-Infinity                  // Infinito negativo
NaN                        // Não é um número

Codificação Base64 e Binário

Princípio de Codificação

3 bytes (24 bits) → 4 caracteres Base64 (6 bits cada)

Exemplo: "Man"
M = 77  = 01001101
a = 97  = 01100001
n = 110 = 01101110

Combinado: 010011010110000101101110
Agrupado: 010011 010110 000101 101110
Índices:   19      22      5      46
Caracteres: T       W       F       u

Resultado: "TWFu"

Usando a Ferramenta para Codificar/Decodificar

  1. Abra a ferramenta de codificação/decodificação Base64
  2. Insira texto ou uma string Base64
  3. Clique em "Codificar" ou "Decodificar"
  4. Suporta conversão Base64 de arquivos e imagens

Codificação Hex

Tabela de Correspondência Binário → Hex

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

Usos Comuns

Uso Exemplo
Valores de cor #FF8000
Endereço MAC 00:1A:2B:3C:4D:5E
Valores hash a1b2c3d4e5f6...
Endereços de memória 0x7fff5fbff8c0
Visualização binária xxd file.bin

Usando o ToolsKu para Conversão de Bases

  1. Abra a ferramenta de conversão de bases
  2. Insira um valor
  3. Selecione a base de entrada
  4. Consulte os resultados de conversão em todas as bases

Perguntas Frequentes

Por que as operações de bits em JavaScript só suportam 32 bits?

As operações de bits em JavaScript convertem os números em inteiros com sinal de 32 bits, os bits que excedem 32 bits são truncados:

0xFFFFFFFF          // 4294967295 (número normal)
0xFFFFFFFF | 0      // -1 (estouro ao converter para int32)

// Operações de bits com números grandes requerem BigInt
(0xFFFFFFFFFn & 0xFFn).toString(16)  // "ff"

Como ver o conteúdo binário de um arquivo?

# hex dump
xxd file.bin

# Ou use o visualizador Hex do ToolsKu
# Faça upload de um arquivo → veja o conteúdo hexadecimal/binário

Resumo

O binário é a base da computação — sistemas de permissões, codificação de cores, precisão de ponto flutuante e codificação Base64 dependem dele. Dominar a conversão de bases e operações de bits permite escrever código mais eficiente e de baixo nível. O ToolsKu oferece ferramentas como Conversão de Bases, Codificação/Decodificação Base64 e mais, para ajudá-lo a lidar rapidamente com problemas de bases e codificação.

#二进制#进制转换#位运算#数据可视化#教程