Ferramenta de Conversão de Base

A conversão de base é aritmética de notação posicional. Um dígito d na posição p na base b contribui com d × bᵖ para o valor total, e o valor de um número de N dígitos é Σᵢ₌₀..N₋₁ dᵢ × b^(N-1-i). O sistema decimal é base 10, binário é base 2, octal é base 8, hexadecimal é base 16. Dois algoritmos fazem todo o trabalho: para converter da base b₁ para base 10, avalia-se o polinômio (o método de Horner é a forma padrão in-place: `value = value * b₁ + digit`); para converter da base 10 para base b₂, divide-se repetidamente por b₂ e coletam-se os restos, depois inverte-se a ordem. Ambos os algoritmos são O(N) por dígito e O(1) em espaço extra, e funcionam para qualquer base de 2 a 36 (dígitos '0'-'9' + 'A'-'Z' como 10-35). A maioria dos trabalhos práticos de conversão de base pula a etapa decimal intermediária e vai diretamente entre bases que são potências de dois. Binário ↔ octal agrupa 3 dígitos binários por dígito octal (porque 2³ = 8), e binário ↔ hex agrupa 4 dígitos binários por dígito hexadecimal (2⁴ = 16). É por isso que 0xFF = 11111111₂, 0755 (octal, o modo de arquivo Unix) = 111101101₂ = 493 decimal. A página também lida com base 32 (RFC 4648 §6, usada em alguns tokens de autenticação) e base 36 (o alfabeto tradicional compacto de encurtadores de URL '0'-'9' + 'A'-'Z'), onde a conversão para binário é a única maneira sensata, já que 36 não é uma potência de 2. Esta página usa o parseInt(value, base) nativo do JavaScript para análise e (123).toString(base) para saída. Ambos são limitados à precisão Number: um IEEE 754 binary64 tem uma mantissa de 53 bits, então valores inteiros maiores que 2⁵³ - 1 = 9.007.199.254.740.991 perdem precisão. Por exemplo, Number.MAX_SAFE_INTEGER + 1 é igual a Number.MAX_SAFE_INTEGER + 2 — os dois grandes valores não são representáveis. Para conversão de base de inteiros de precisão arbitrária, BigInt é o caminho moderno: a lógica estilo parseInt em BigInt é direta, e BigInt.prototype.toString(base) lida com qualquer base de 2 a 36. Bibliotecas de criptografia, geradores de UUID e cálculos com números grandes (carteiras HD BIP-32, chaves RSA) usam BigInt por essa razão. O mesmo algoritmo também lida com números com sinal e ponto flutuante, com ressalvas. Em complemento de dois (a representação com sinal dominante para inteiros de largura fixa, desde o design do IBM System/360 de 1965 até todas as CPUs modernas), -1 é tudo uns (0xFFFFFFFF para 32 bits, 0xFFFFFFFFFFFFFFFF para 64), e o bit mais significativo é o bit de sinal. Para converter um inteiro negativo em complemento de dois para decimal, subtrai-se 2ⁿ (onde n é a largura em bits). Para números de ponto flutuante, IEEE 754 binary64 armazena sinal (1 bit), expoente (11 bits, com viés de 1023) e mantissa (52 bits, com um 1 implícito à esquerda). A conversão decimal de um binary64 arbitrário não é portanto exata — 0,1 em IEEE 754 é 0,1000000000000000055511151231257827021181583404541015625, razão pela qual código financeiro usa centavos inteiros ou bibliotecas decimais em vez de float.

• Notação posicional: um dígito d na posição p na base b contribui com d × bᵖ. O valor completo de um número de N dígitos é Σᵢ dᵢ × b^(N-1-i). O método de Horner avalia isso em tempo O(N) e espaço O(1): `value = value * b + digit`.
• Para converter de decimal para base b, divide-se repetidamente por b e coletam-se os restos; lê-los na ordem inversa fornece a representação alvo. O algoritmo é O(N) para uma saída de N dígitos.
• Conversão direta binário ↔ hex: cada dígito hexadecimal são exatamente 4 dígitos binários, então 0xFF = 11111111₂. Binário ↔ octal: cada dígito octal são 3 dígitos binários, então 0755 = 111101101₂.
• Complemento de dois (usado por toda CPU moderna para inteiros com sinal): o bit mais significativo é o sinal, e números negativos são codificados como 2ⁿ - |x|. -1 em complemento de dois de 32 bits é 0xFFFFFFFF.
• IEEE 754 binary64 (Number do JavaScript): 1 bit de sinal + expoente com viés de 11 bits (viés 1023) + mantissa de 52 bits com 1 implícito à esquerda. O inteiro seguro máximo é 2⁵³ - 1 = 9.007.199.254.740.991; valores acima disso perdem precisão.
• parseInt(value, base) e Number.prototype.toString(base) funcionam para bases 2-36 e usam a mantissa Number de 53 bits. Para precisão arbitrária, use BigInt('value', base) e BigInt.prototype.toString(base).
• Base 32 (RFC 4648 §6) e Base 36 ('0'-'9' + 'A'-'Z') precisam de binário como etapa intermediária porque 32 e 36 não são potências de 2 — um dígito não corresponde a um número fixo de bits.
• Caso extremo: divisão inteira com resto para bases negativas ou para números negativos em complemento de dois requer tratamento de sinal; a página trata a entrada como um valor absoluto sem sinal e reaplica o sinal ao resultado final.