Convertidor IPv6 ↔ BigInt

El Conversor de IPv6 a BigInt transforma direcciones IPv6 entre la notación hexadecimal con dos puntos y su representación subyacente como entero de 128 bits usando BigInt para precisión completa. Ingresa una dirección como 2001:db8::1 para obtener 42540766411282592856903984951653826561, o pega un número decimal grande para obtener la dirección IPv6 correspondiente tanto en forma comprimida como expandida.

Entendiendo BigInt para direcciones IPv6

Las direcciones IPv4 son números de 32 bits que caben cómodamente en un tipo de entero estándar -- el valor más grande es aproximadamente 4.3 mil millones, bien dentro del rango del tipo numérico de cualquier lenguaje de programación moderno. IPv6 es una historia completamente diferente. Con 128 bits, el espacio de direcciones abarca desde 0 hasta 340,282,366,920,938,463,463,374,607,431,768,211,455 -- un número tan grande que tiene 39 dígitos. Ningún entero estándar de 64 bits puede contenerlo, y el tipo Number de JavaScript pierde precisión para enteros mayores a aproximadamente 9 cuatrillones (2^53).

Por eso existe BigInt. BigInt es un tipo de entero de precisión arbitraria disponible en JavaScript, Python, Java y la mayoría de los lenguajes modernos. Puede representar números de cualquier tamaño sin redondeo ni pérdida de precisión, lo que lo convierte en la herramienta adecuada para la aritmética de direcciones IPv6. Cuando conviertes una dirección IPv6 a su forma numérica, necesitas BigInt para obtener un resultado exacto. Usar un entero regular de 64 bits o un número de punto flotante redondearía silenciosamente el valor, produciendo una dirección que es cercana pero no igual a la original -- un bug sutil que puede ser muy difícil de rastrear.

Las aplicaciones prácticas de la conversión BigInt de IPv6 son similares a las de la conversión de IPv4 a entero, pero la escala es diferente. El almacenamiento en bases de datos, los cálculos de rangos, la enumeración secuencial y el cómputo de límites de subredes funcionan de la misma manera conceptualmente, pero requieren aritmética BigInt en lugar de matemática de enteros estándar. Si estás construyendo una aplicación compatible con IPv6, entender esta conversión es fundamental -- es cómo pasas del formato legible con dos puntos hexadecimales a algo con lo que una base de datos o algoritmo puede trabajar eficientemente.

Cómo convertir IPv6 a BigInt (y viceversa)

1. Ingresa una dirección IPv6 en cualquier notación válida (comprimida, expandida o mixta) o un entero decimal de 0 a 2^128 - 1
2. Haz clic en Convert para ver la representación equivalente en el otro formato
3. Visualiza el valor BigInt completo, la aproximación en notación científica y ambas formas IPv6 comprimida y expandida

Ejemplos de conversión de IPv6 a BigInt

Conversión paso a paso: 2001:db8::1

Expandida:  2001:0db8:0000:0000:0000:0000:0000:0001

Dígitos hex: 20010db8000000000000000000000001

BigInt:    0x20010db8000000000000000000000001
         = 42540766411282592856903984951653826561

Conversión inversa: BigInt 1 a ::1

BigInt:     1
Hex:        0x00000000000000000000000000000001
Agrupado:   0000:0000:0000:0000:0000:0000:0000:0001
Comprimido: ::1

Cuándo usar el conversor de IPv6 a BigInt

• Almacenamiento de IPv6 en bases de datos -- almacena direcciones IPv6 como enteros de 128 bits en bases de datos que soportan tipos numéricos grandes (PostgreSQL numeric, MySQL DECIMAL(39,0), o dos columnas BIGINT para las mitades alta/baja de 64 bits)
• Aritmética de rangos de direcciones -- calcula el número de direcciones en un prefijo IPv6 computando 2^(128 - prefix_length), operaciones que requieren precisión BigInt
• Cálculo de límites de subredes -- encuentra la dirección de red aplicando una máscara de bits: BigInt_address & BigInt_mask, y el broadcast con: BigInt_address | ~BigInt_mask
• Enumeración secuencial de direcciones -- genera direcciones IPv6 consecutivas incrementando el valor BigInt, útil para herramientas de escaneo o asignación
• Ordenamiento compatible con IPv6 -- ordena direcciones IPv6 numéricamente comparando sus valores BigInt, evitando la complejidad de comparar cadenas hexadecimales con dos puntos
• Visualización del espacio de direcciones -- convierte límites de prefijos a rangos numéricos para graficar asignaciones IPv6 en líneas numéricas o mapas de calor

Cómo funciona la conversión de IPv6 a BigInt

El espacio de direcciones de 128 bits

Las direcciones IPv6 son valores de 128 bits, produciendo enteros en un rango muy superior al que los tipos numéricos estándar pueden manejar:

Los enteros estándar de 64 bits tienen un máximo de 2^63 - 1 (~9.2 x 10^18), lo cual es aproximadamente 3.7 x 10^19 veces demasiado pequeño para IPv6. El Number.MAX_SAFE_INTEGER de JavaScript es 2^53 - 1 (~9 x 10^15), aún más limitado. BigInt es necesario para la aritmética de direcciones IPv6 sin pérdida.

Algoritmo de conversión

1. Expande la dirección IPv6 a la notación completa de 8 grupos con ceros a la izquierda
2. Concatena todos los dígitos hexadecimales en una sola cadena hex de 32 caracteres
3. Parsea la cadena hexadecimal como un valor BigInt en base 16

// Conversión BigInt en JavaScript
const ipv6 = "2001:0db8:0000:0000:0000:0000:0000:0001";
const hex = ipv6.replace(/:/g, "");           // "20010db8000000000000000000000001"
const bigint = BigInt("0x" + hex);            // 42540766411282592856903984951653826561n

Estrategias de almacenamiento en bases de datos

Dado que la mayoría de las bases de datos carecen de un tipo de entero nativo de 128 bits, los enfoques comunes incluyen:

-- PostgreSQL: Usa NUMERIC para almacenamiento exacto de 128 bits
CREATE TABLE ipv6_addresses (
    id SERIAL PRIMARY KEY,
    address NUMERIC(39, 0) NOT NULL
);

-- MySQL: Usa BINARY(16) para almacenamiento compacto
CREATE TABLE ipv6_addresses (
    id INT AUTO_INCREMENT PRIMARY KEY,
    address BINARY(16) NOT NULL
);

-- Alternativa: Dividir en dos mitades de 64 bits
CREATE TABLE ipv6_addresses (
    id INT AUTO_INCREMENT PRIMARY KEY,
    address_high BIGINT UNSIGNED NOT NULL,
    address_low  BIGINT UNSIGNED NOT NULL
);

Consejos prácticos para operaciones BigInt con IPv6

El error más común al trabajar con valores BigInt de IPv6 es mezclar tipos BigInt y Number regulares. En JavaScript, BigInt y Number son incompatibles -- no puedes sumar 1n a 1 sin una conversión explícita. Esto significa que toda tu cadena de aritmética de direcciones necesita usar BigInt de manera consistente. Si una función devuelve un Number donde se esperaba un BigInt, el resultado lanzará un TypeError o perderá precisión silenciosamente, dependiendo del lenguaje y el contexto.

Al almacenar direcciones IPv6 en una base de datos, considera tus patrones de consulta antes de elegir una estrategia de almacenamiento. El NUMERIC(39,0) de PostgreSQL almacena el BigInt completo y soporta consultas de rango, pero es más lento que el almacenamiento binario para búsquedas de coincidencia exacta. El BINARY(16) de MySQL es compacto (exactamente 16 bytes) y rápido para coincidencias exactas, pero las consultas de rango requieren conversión a valores numéricos. El enfoque de dos columnas BIGINT divide la dirección en mitades superior e inferior de 64 bits, lo que funciona bien para consultas de rango si la mayoría de tu filtrado es sobre la porción de red (64 bits superiores). Elige la estrategia que coincida con cómo realmente consultas los datos, no la que se vea más limpia en el esquema.

Para cálculos de tamaño de prefijo, recuerda que los números IPv6 crecen muy rápido. Un prefijo /64 contiene 2^64 direcciones -- aproximadamente 18.4 quintillones. Un /48 contiene 2^80 direcciones. Estos números son útiles para entender la escala de IPv6, pero rara vez son significativos para la planificación práctica de capacidad. Nadie va a quedarse sin direcciones en un /64, así que la pregunta generalmente es cuántas subredes /64 necesitas, no cuántas direcciones hay en cada una. Usa aritmética BigInt para cálculos de límites, pero piensa en términos de conteo de prefijos para la planificación.

Preguntas frecuentes

¿Por qué no puedo usar un número regular de JavaScript para direcciones IPv6?

Los números de JavaScript son valores de punto flotante IEEE 754 de 64 bits que pierden precisión para enteros mayores a 2^53 (9,007,199,254,740,992). Las direcciones IPv6 pueden alcanzar 2^128, que es aproximadamente 10^38 -- muy por encima del rango seguro de enteros. Usar Number redondearía silenciosamente el valor, produciendo conversiones de direcciones incorrectas. BigInt proporciona enteros de precisión arbitraria sin redondeo.

¿Cómo calculo el número de direcciones en un prefijo IPv6?

Usa exponenciación BigInt: 2n ** BigInt(128 - prefix_length). Por ejemplo, un prefijo /64 contiene 2n ** 64n = 18,446,744,073,709,551,616 direcciones. Un /48 contiene 2n ** 80n = 1,208,925,819,614,629,174,706,176 direcciones. Estos números son demasiado grandes para tipos de enteros estándar pero son directos con BigInt.

¿Hay un costo de rendimiento al usar BigInt en lugar de Number?

Sí. Las operaciones BigInt son más lentas que las operaciones nativas de Number porque requieren aritmética de precisión arbitraria. Para la mayoría de los casos de uso en redes -- convertir direcciones, calcular rangos, comparar valores -- la diferencia de rendimiento es insignificante. La aritmética BigInt se vuelve notablemente más lenta solo cuando se realizan millones de operaciones en bucles ajustados, lo cual es poco común en tareas de gestión de direcciones.

¿Qué tipo de base de datos debo usar para direcciones IPv6?

Depende de tu caso de uso. Los tipos nativos inet o cidr de PostgreSQL son la mejor opción si usas PostgreSQL, ya que manejan IPv6 de forma nativa con operadores integrados. Para MySQL, BINARY(16) es compacto y eficiente. Para portabilidad entre bases de datos, DECIMAL(39,0) o NUMERIC(39,0) funcionan en todas partes y soportan consultas de rango, aunque usan más almacenamiento que las alternativas binarias.

¿Puedo convertir direcciones IPv6 mapeadas a IPv4 como ::ffff:192.168.1.1?

Sí. La herramienta primero expande la notación mixta a la forma hexadecimal completa (0000:0000:0000:0000:0000:ffff:c0a8:0101), luego convierte a BigInt normalmente. El valor resultante es 281473913978881, que cae en el rango mapeado a IPv4 (::ffff:0:0/96).

Herramientas relacionadas

• Conversor IPv4 ↔ Entero - Convierte direcciones IPv4 a/desde enteros de 32 bits
• Expandir ↔ Comprimir IPv6 - Convierte entre notación IPv6 expandida y comprimida
• Conversor IPv6 ↔ Binario - Convierte direcciones IPv6 a/desde notación binaria
• Validador de IPv6 - Valida direcciones IPv6 (formatos completo y comprimido)
• Conversor IPv4-Mapped IPv6 - Convierte entre IPv4 e IPv4-mapped IPv6 (::ffff:)