Convertidor de Bases Numéricas

Conversión bidireccional entre binario (base 2), octal (base 8), decimal (base 10), hexadecimal (base 16) y bases personalizadas (2–36) con soporte para complemento a dos y registros de hardware.

Modo y Ancho de bits
Valores predefinidos:
Decimal (Base 10)Estándar
Dígitos válidos: 0–93 caracteres
Hexadecimal (Base 16)0x
Símbolos: 0–9, A–F1 bytes
Binario (Base 2)0b
Símbolos: 0, 18 bits
Octal (Base 8)0o
Dígitos válidos: 0–73 dígitos
Base personalizada
Base (Radix):
Alfabeto: 0–9, a–z (rango 2–36)2 símbolos

Guía de Configuración del Convertidor

Selección de RadixEntrada directa en binario, octal, decimal, hexadecimal o configuración de cualquier base personalizada entre 2 y 36.
Registro de PalabraRestrinja el cálculo al tamaño físico de la arquitectura (8 bits Byte, 16 bits Word, 32 bits Int, 64 bits Long) o use BigInt arbitrario.
Complemento a Dos con SignoActive el modo con signo para representar valores negativos mediante inversión aritmética estándar y desbordamiento modular.
Formato de SintaxisMuestre prefijos sintácticos (0b, 0o, 0x), espacios de agrupación o caracteres hex en mayúsculas.

Tabla de Referencia Rápida y Segmentación Mental de Bits

En el desarrollo de software, la conversión entre binario, octal, decimal y hexadecimal rara vez exige divisiones sucesivas complejas. Debido a que 8 (2³) y 16 (2⁴) son potencias exactas de 2, los bits individuales se asignan de forma directa a dígitos únicos:

DecimalBinario de 4 Bits (Nibble)HexadecimalBinario de 3 BitsOctal
0000000000
1000110011
2001020102
3001130113
4010041004
5010151015
6011061106
7011171117
810008——
910019——
101010A——
111011B——
121100C——
131101D——
141110E——
151111F——
Segmentación de 4 Bits: Binario ↔ Hexadecimal

Agrupe los bits en bloques de 4 elementos (nibbles) de derecha a izquierda. Cada bloque de 4 bits se traduce directamente en un carácter hexadecimal:

Binario:  1101 0110
Nibbles: 1101 (D)  0110 (6)
Hex:     0xD6 (= 214 sin signo o -42 con signo)
Puente Directo Hexadecimal ↔ Octal

Convierta sin necesidad de pasar por base decimal expandiendo el valor hex a binario y reagrupando en fragmentos de 3 bits:

Hex:     0x5B
Expandir:  0101 1011 (8 bits)
Reagrupar: 001 011 011
Octal:   0o133 (1×64 + 3×8 + 3 = 91)

Depuración de Complemento a Dos: La Regla del Nibble Superior

Las unidades centrales de procesamiento (CPU) no reservan un carácter de signo menos (-). Los enteros negativos se codifican mediante Complemento a Dos, donde el bit más significativo (MSB) aporta un peso negativo. Esto permite que los circuitos sumadores gestionen restas de forma nativa: A - B = A + (~B + 1).

La Regla del Nibble Superior (Inspección Inmediata)

En cualquier volcado hexadecimal de longitud fija, examine el primer dígito a la izquierda:

  • 8, 9, A, B, C, D, E, F: Bit superior en 1 → Negativo en modo con signo.
  • 0, 1, 2, 3, 4, 5, 6, 7: Bit superior en 0 → Positivo o Cero.
0xFF = -1 (8 bits)  |  0x7F = +127 (8 bits)
Extensión de Signo en Conversiones de Tipo

Al promocionar un entero con signo a un registro mayor (ej. int8_t → int32_t), la CPU replica el MSB en todas las posiciones superiores agregadas para preservar el valor matemático:

8 bits:   0xD6 (-42)
16 bits: 0xFFD6 (-42, byte superior extendido con signo)
32 bits: 0xFFFF FFD6 (-42, 3 bytes superiores extendidos con signo)
Valor DecimalBinario 8 BitsHex 8 BitsHex 16 BitsHex 32 BitsInterpretación de Hardware
+127 (Máx Int8)0111 11110x7F0x007F0x0000 007FMayor valor positivo con signo en 8 bits
+10000 00010x010x00010x0000 0001Incremento unitario
00000 00000x000x00000x0000 0000Cero unívoco (sin ambigüedad +0/-0)
-11111 11110xFF0xFFFF0xFFFF FFFFTodos los bits activos (todos unos)
-421101 01100xD60xFFD60xFFFF FFD6Inversión bit a bit + 1 (~42 + 1)
-128 (Mín Int8)1000 00000x800xFF800xFFFF FF80Límite negativo inferior de 8 bits

Límites de Registro de Hardware y Desbordamiento Modular

En la arquitectura física, los registros operan con anchos de bits fijos. Cuando una operación aritmética excede la capacidad del registro, los bits superiores se truncan de forma modular (módulo 2ᵟ), produciendo el efecto de vuelta cíclica (wrap-around). Consulte la tabla siguiente para verificar los límites de cada tipo de datos:

Ancho de RegistroRango Sin Signo [0, 2ᴺ - 1]Rango Con Signo [-2ᴺ⁻¹, 2ᴺ⁻¹ - 1]Valor Hex MáximoTipos en Lenguajes (Rust / C / Go)
8 bits (Byte)0 a 255-128 a +1270xFFu8 / i8, uint8_t / int8_t, byte
16 bits (Word)0 a 65.535-32.768 a +32.7670xFFFFu16 / i16, uint16_t / int16_t
32 bits (DWord)0 a 4.294.967.295-2.147.483.648 a +2.147.483.6470xFFFF FFFFu32 / i32, uint32_t / int32_t
64 bits (QWord)0 a 18.446.744.073.709.551.615-9.223.372.036.854.775.808 a +9.223.372.036.854.775.8070xFFFF FFFF FFFF FFFFu64 / i64, uint64_t / int64_t
Auto (BigInt)0 a ∞ (limitado por RAM)-∞ a +∞ (limitado por RAM)DinámicoBigInt (JS), int (Python 3), big.Int (Go)
Desbordamiento Aritmético en la Práctica

Al sumar 1 al valor máximo positivo de un entero con signo de 32 bits (0x7FFF FFFF / +2.147.483.647), la secuencia binaria avanza a 0x8000 0000. Al activarse el bit más significativo (MSB) en 1, el valor se evalúa de inmediato como el límite negativo inferior: -2.147.483.648. La selección de anchos fijos en nuestra herramienta modela con precisión este comportamiento del hardware.

Base 36 en Sistemas de Producción: Slugs de URL y Compresión de Claves

Mientras que el binario y el hexadecimal predominan en la depuración de memoria de bajo nivel, las bases con mayor cardinalidad resuelven desafíos de almacenamiento compacto y transmisión de identificadores:

Base 36 (Alfanumérico 0–9, A–Z)

Representación insensible a mayúsculas que aprovecha los 10 dígitos y las 26 letras del alfabeto latino. Al no generar secuencias reservadas en URLs (%2B, %2F), es el estándar idóneo para acortar identificadores autonuméricos de bases de datos en slugs públicos (por ejemplo, identificadores de comentarios en foros y tokens de enlaces reducidos).

342.551.797 → 5NY2NP (6 caracteres)
Base 32 (RFC 4648)

Emplea 32 caracteres seguros (A–Z, 2–7), omitiendo glifos propensos a confusión óptica manual (0/O, 1/I/L, 8/B). Diseñado específicamente para transcripción humana, como claves secretas TOTP en Google Authenticator y direcciones .onion en la red Tor.

JBSWY3DPEHPK3PXP (Semilla TOTP)
Base 64 (Serialización de Bytes)

A diferencia de Base 36, que codifica una única magnitud entera escalar, Base 64 es un esquema de transporte de flujos de bytes. Empaqueta 6 bits por carácter para transmitir activos binarios arbitrarios (imágenes, tokens, firmas criptográficas) a través de protocolos basados en texto ASCII de 7 bits (cabeceras HTTP, cargas útiles JSON, correo MIME).

data:image/png;base64,iVBORw...

Literales Numéricos y Sintaxis de Enmascaramiento en Lenguajes de Programación

Los compiladores e intérpretes interpretan números sin prefijo en base decimal por defecto. Utilice prefijos estandarizados para declarar literales constantes en otras bases numéricas:

LenguajePrefijo BinarioPrefijo OctalPrefijo HexadecimalSeparador de Dígitos
JavaScript / TypeScript0b / 0B0o / 0O0x / 0XGuion bajo: 0xFF_FF
Python 30b / 0B0o / 0O0x / 0XGuion bajo: 0b1111_0000
Rust0b0o0xGuion bajo: 0xDEAD_BEEF
Go (Golang)0b / 0B0o / 0O0x / 0XGuion bajo: 0_644
C / C++0b / 0B (C++14 / C23)0 (heredado) / 0o (C23)0x / 0XComilla simple (C++): 0xFF'FF
Operaciones Habituales con Máscaras de Bits
Activar Bit n (Set)flags |= (1 << n)
Desactivar Bit n (Clear)flags &= ~(1 << n)
Invertir Bit n (Toggle)flags ^= (1 << n)
Comprobar Bit n (Test)(flags & (1 << n)) != 0

Fragmentos de Código para Entornos de Producción

Patrones recomendados para analizar y formatear enteros entre diversas bases (2 a 36) en backends de producción:

TypeScript & JavaScript (BigInt y Radix 2–36)
// BigInt convierte sin pérdida a cualquier base entre 2 y 36
const val = 3735928559n;
const hex = val.toString(16); // "deadbeef"
const b36 = val.toString(36); // "1ps9wxb"

// Analizar cadenas de vuelta a entero
const parsedHex = BigInt('0x' + hex); // 3735928559n

// Simular desbordamiento con signo en complemento a dos de 8 bits
const signed8 = BigInt.asIntN(8, -42n);   // -42n
const unsigned8 = BigInt.asUintN(8, -42n); // 214n (0xD6)
Python 3 (Funciones Nativas de Base)
# Formatear entero a binario, octal y hexadecimal
num = 3735928559
bin_str = bin(num)  # '0b11011110101011011011111011101111'
hex_str = hex(num)  # '0xdeadbeef'

# Analizar cadenas en cualquier base entre 2 y 36
val_from_hex = int("DEADBEEF", 16)  # 3735928559
val_from_b36 = int("1ps9wxb", 36)   # 3735928559
Go (Paquete strconv)
package main

import (
    "fmt"
    "strconv"
)

func main() {
    val := int64(3735928559)

    // FormatInt admite cualquier base entre 2 y 36
    hexStr := strconv.FormatInt(val, 16) // "deadbeef"
    b36Str := strconv.FormatInt(val, 36) // "1ps9wxb"

    // Analizar con base explícita
    parsed, _ := strconv.ParseInt(hexStr, 16, 64)
    fmt.Println(parsed) // 3735928559
}
Rust (Módulos std::fmt y from_str_radix)
fn main() {
    let val: u32 = 0xDEAD_BEEF;

    // Formatear cadenas
    let bin_str = format!("{:b}", val);
    let hex_str = format!("{:X}", val); // "DEADBEEF"

    // Analizar desde cualquier base (2 a 36)
    let parsed = u32::from_str_radix("DEADBEEF", 16).expect("hex válido");
    assert_eq!(val, parsed);
}

Frequently Asked Questions

¿Por qué la salida hexadecimal muestra 0xFF o 0xFFFFFFFF en lugar de un signo negativo para -1?

La memoria del ordenador y los registros del procesador no almacenan caracteres "-" independientes. Los números negativos se representan mediante la notación de complemento a dos (Two's Complement). En complemento a dos, el valor -1 se codifica asignando un 1 a cada uno de los bits de la palabra de hardware (todos los bits activos). En un registro de 8 bits, ocho unos consecutivos equivalen al binario 1111 1111, que se representa en hexadecimal como 0xFF. En un registro de 32 bits, 32 unos consecutivos forman 0xFFFF FFFF. Al activar la opción "Con signo" en este convertidor, el bit más significativo (MSB) se interpreta con peso negativo, resolviendo correctamente 0xFF como -1 en el modo de 8 bits.

¿Cómo pueden los desarrolladores determinar al instante si un valor hexadecimal representa un número negativo?

Inspeccionando el primer dígito hexadecimal (el más significativo). Como cada carácter hexadecimal representa exactamente 4 bits binarios (8, 4, 2, 1), cualquier dígito entre 8 y F tiene su bit superior activado en 1 (8 = 1000₂, 9 = 1001₂, A = 1010₂, ..., F = 1111₂). En registros con signo en complemento a dos, un bit más significativo (MSB) en 1 denota un valor negativo. Si el dígito inicial se encuentra entre 0 y 7 (donde el MSB es 0), el número es positivo o cero.

¿Cuál es la diferencia práctica entre el desplazamiento aritmético (>>) y el desplazamiento lógico (>>>)?

En la manipulación binaria a nivel de bits, el desplazamiento a la derecha aritmético (>>) conserva el bit de signo: si el número es negativo (el MSB es 1), propaga unos por la izquierda en las posiciones recién desalojadas (extensión de signo). El desplazamiento a la derecha lógico (>>>) ignora el signo e introduce incondicionalmente ceros por la izquierda, convirtiendo valores negativos en grandes enteros positivos sin signo. Por ejemplo, en 32 bits: (-42 >> 1) se mantiene en -21, mientras que (-42 >>> 1) produce 2.147.483.627.

¿Por qué JavaScript nativo pierde precisión con enteros superiores a 53 bits sin BigInt?

Los valores numéricos estándar de tipo Number en JavaScript se rigen por el estándar IEEE-754 de punto flotante de doble precisión, que reserva 53 bits para la mantisa o significando, 11 bits para el exponente y 1 bit para el signo. Los enteros mayores que Number.MAX_SAFE_INTEGER (9.007.199.254.740.991, o 2⁵³ - 1) no pueden representarse de forma unívoca y sufren colapso por redondeo. El tipo primitivo BigInt evita la unidad de coma flotante almacenando enteros de precisión arbitraria mediante matrices dinámicas de bloques de 64 bits en memoria, garantizando conversiones sin pérdida en claves y registros de 64, 128 y 256 bits.

¿Por qué los permisos de archivos en UNIX (chmod 755) se asignan directamente al sistema octal?

El modelo de seguridad de archivos en UNIX descompone los permisos en tres indicadores de bit discretos: Lectura (4, 2²), Escritura (2, 2¹) y Ejecución (1, 2⁰), distribuidos en tres entidades independientes: Usuario propietario, Grupo y Otros. Dado que 2³ = 8, cada grupo de 3 bits encaja con exactitud en un único dígito octal de 0 (---) a 7 (rwx). Una cadena de permisos como rwxr-xr-x se desglosa en [111] (7), [101] (5) y [101] (5), eliminando la necesidad de realizar cálculos de desplazamiento de bits.

¿Cómo opera la extensión de signo al convertir un entero de 8 bits en un registro de 32 bits?

Al promocionar o ensanchar un entero con signo de 8 bits a un registro de 32 bits, el hardware debe conservar su valor matemático negativo original. Si el valor de 8 bits es -42 (binario 1101 0110, hexadecimal 0xD6), rellenarlo simplemente con ceros generaría 0x0000 00D6 (+214). La extensión de signo replica el octavo bit (1) en los 24 bits superiores adicionales, produciendo 0xFFFF FFD6 (binario 1111...1101 0110), que se evalúa correctamente como -42 en la aritmética de complemento a dos de 32 bits.

¿Por qué se prefiere Base 36 frente a Base 64 para identificadores secuenciales de bases de datos y slugs en URLs?

Base 36 emplea dígitos del 0 al 9 y letras del alfabeto latino de la A a la Z (36 caracteres en total) y es completamente insensible a mayúsculas y minúsculas (case-insensitive). Esto previene errores de transcripción humana y garantiza que las URLs se mantengan limpias y legibles sin requerir codificación porcentual (%2B, %2F). Aunque Base 64 es ligeramente más compacta, su sensibilidad a mayúsculas y la inclusión de símbolos (+, /, =) pueden causar colisiones en sistemas de archivos o requerir variantes adaptadas para URLs (RFC 4648 Base64URL).

¿Cómo se emplean constantes hexadecimales como 0x0F y 0xFF en las operaciones de enmascaramiento de bits (bitmasking)?

Debido a que un dígito hexadecimal representa exactamente 4 bits binarios (un nibble) y dos dígitos representan un byte de 8 bits, la notación hexadecimal actúa como plantilla visual para las máscaras de bits. La constante 0x0F (binario 0000 1111) aísla los 4 bits inferiores descartando los superiores. La constante 0xFF (binario 1111 1111) permite extraer bytes individuales de registros de 32 bits, como al descomponer componentes cromáticos RGB: la expresión (color >> 16) & 0xFF extrae el byte correspondiente al canal Rojo.