Herramienta de Conversión de Base

La conversión de base es aritmética de notación posicional. Un dígito d en la posición p en base b contribuye d × bᵖ al valor total, y el valor de un número de N dígitos es Σᵢ₌₀..N₋₁ dᵢ × b^(N-1-i). El sistema decimal es base 10, binario es base 2, octal es base 8, hexadecimal es base 16. Dos algoritmos hacen todo el trabajo: para convertir de base b₁ a base 10, se evalúa el polinomio (el método de Horner es la forma estándar in situ: `value = value * b₁ + digit`); para convertir de base 10 a base b₂, se divide repetidamente por b₂ y se recogen los residuos, luego se invierten. Ambos algoritmos son O(N) por dígito y O(1) en espacio extra, y funcionan para cualquier base del 2 al 36 (dígitos '0'-'9' + 'A'-'Z' como 10-35). La mayoría del trabajo práctico de conversión de base omite el paso decimal intermedio y va directamente entre bases que son potencias de dos. Binario ↔ octal agrupa 3 dígitos binarios por dígito octal (porque 2³ = 8), y binario ↔ hex agrupa 4 dígitos binarios por dígito hexadecimal (2⁴ = 16). Por eso 0xFF = 11111111₂, 0755 (octal, el modo de archivo Unix) = 111101101₂ = 493 decimal. La página también maneja base 32 (RFC 4648 §6, usado en algunos tokens de autenticación) y base 36 (el alfabeto tradicional compacto para acortadores de URL '0'-'9' + 'A'-'Z'), donde la conversión a binario es la única forma sensata ya que 36 no es potencia de 2. Esta página usa las funciones integradas de JavaScript parseInt(value, base) para el análisis y (123).toString(base) para la salida. Ambas están limitadas a la precisión de Number: un IEEE 754 binary64 tiene una mantisa de 53 bits, por lo que valores enteros mayores que 2⁵³ - 1 = 9.007.199.254.740.991 pierden precisión. Por ejemplo, Number.MAX_SAFE_INTEGER + 1 es igual a Number.MAX_SAFE_INTEGER + 2 — los dos grandes valores no son representables. Para conversión de base de enteros de precisión arbitraria, BigInt es el camino moderno: la lógica tipo parseInt en BigInt es directa, y BigInt.prototype.toString(base) maneja cualquier base del 2 al 36. Las bibliotecas criptográficas, generadores de UUID y cálculos con números grandes (wallets HD BIP-32, claves RSA) usan BigInt por esta razón. El mismo algoritmo también maneja números con signo y de punto flotante, con matices. En complemento a dos (la representación con signo dominante para enteros de ancho fijo, desde el diseño del IBM System/360 de 1965 hasta cada CPU moderna), -1 es todo unos (0xFFFFFFFF para 32 bits, 0xFFFFFFFFFFFFFFFF para 64), y el bit más alto es el bit de signo. Para convertir un entero negativo en complemento a dos a decimal, se resta 2ⁿ (donde n es el ancho en bits). Para números de punto flotante, IEEE 754 binary64 almacena signo (1 bit), exponente (11 bits, con sesgo de 1023) y mantisa (52 bits, con un 1 implícito inicial). La conversión decimal de un binary64 arbitrario no es exacta — 0,1 en IEEE 754 es 0,1000000000000000055511151231257827021181583404541015625, razón por la cual el código financiero usa centavos enteros o bibliotecas decimales en lugar de float.

• Notación posicional: un dígito d en la posición p en base b contribuye d × bᵖ. El valor completo de un número de N dígitos es Σᵢ dᵢ × b^(N-1-i). El método de Horner evalúa esto en tiempo O(N) y espacio O(1): `value = value * b + digit`.
• Para convertir de decimal a base b, se divide repetidamente por b y se recogen los residuos; leyéndolos en orden inverso se obtiene la representación destino. El algoritmo es O(N) para una salida de N dígitos.
• Conversión directa binario ↔ hexadecimal: cada dígito hexadecimal son exactamente 4 dígitos binarios, así que 0xFF = 11111111₂. Binario ↔ octal: cada dígito octal son 3 dígitos binarios, así que 0755 = 111101101₂.
• Complemento a dos (usado por toda CPU moderna para enteros con signo): el bit alto es el signo, y los números negativos se codifican como 2ⁿ - |x|. -1 en complemento a dos de 32 bits es 0xFFFFFFFF.
• IEEE 754 binary64 (Number de JavaScript): 1 bit de signo + exponente con sesgo de 11 bits (sesgo 1023) + mantisa de 52 bits con 1 implícito inicial. El entero seguro máximo es 2⁵³ - 1 = 9.007.199.254.740.991; los valores por encima pierden precisión.
• parseInt(value, base) y Number.prototype.toString(base) funcionan para bases 2-36 y usan la mantisa de 53 bits de Number. Para precisión arbitraria, usa BigInt('value', base) y BigInt.prototype.toString(base).
• Base 32 (RFC 4648 §6) y Base 36 ('0'-'9' + 'A'-'Z') necesitan binario como paso intermedio porque 32 y 36 no son potencias de 2 — un dígito no corresponde a un número fijo de bits.
• Caso límite: la división entera con residuo para bases negativas o números negativos en complemento a dos necesita manejo de signo; la página trata la entrada como un valor absoluto sin signo y re-aplica el signo al resultado final.