Función PHP inet_pton(): Todo lo que Necesitas Saber

La función PHP inet_pton() convierte una dirección IP legible por humanos — como 127.0.0.1 o 2001:db8::1 — en su representación binaria compacta. El nombre significa "presentación a red": toma la forma de presentación (el texto con puntos y dos puntos que escribes) y devuelve la forma de red (los bytes sin procesar que realmente viajan por el cable).

Esta página cubre la sintaxis, tanto IPv4 como IPv6, cómo leer el resultado de forma segura, cómo invertirlo y las razones prácticas por las que almacenarías IPs en binario.

¿Qué es la función inet_pton()?

inet_pton() analiza una cadena IPv4 o IPv6 válida y devuelve una cadena binaria empaquetada in-addr — 4 bytes para IPv4, 16 bytes para IPv6. Si la entrada no es una dirección IP válida, devuelve false en lugar de lanzar una excepción.

La "cadena binaria" que devuelve no es legible por humanos: son los bytes sin procesar, por lo que imprimirla directamente en una terminal o navegador muestra caracteres incomprensibles. Para inspeccionarla, conviértela con bin2hex(). Para convertirla de nuevo en una cadena IP normal, usa su función espejo, inet_ntop().

Sintaxis

inet_pton(string $ip): string|false

La función acepta un parámetro:

• $ip — la dirección IP a convertir, como cadena (IPv4 o IPv6).

Valor de retorno: la cadena binaria empaquetada en caso de éxito, o false si $ip no es una dirección IP válida.

Ejemplo básico: IPv4

Los 4 bytes sin procesar de 127.0.0.1 son 7f 00 00 01 — exactamente los octetos decimales de 127.0.0.1 escritos en hexadecimal. Como la cadena binaria en sí no es imprimible, la pasamos por bin2hex() para que los bytes se muestren como hexadecimal legible.

IPv4 e IPv6

A diferencia de la función más antigua ip2long(), que solo maneja IPv4, inet_pton() funciona para ambas familias de direcciones. IPv4 produce 4 bytes; IPv6 produce 16:

<?php

echo bin2hex(inet_pton("192.168.1.1")), "\n";   // c0a80101  (4 bytes)
echo bin2hex(inet_pton("2001:db8::1")), "\n";    // 20010db8000000000000000000000001 (16 bytes)

echo strlen(inet_pton("192.168.1.1")), "\n";     // 4
echo strlen(inet_pton("2001:db8::1")), "\n";     // 16

Comprobar strlen() en el resultado es la forma más sencilla de saber a qué familia pertenece una dirección: una longitud de 4 significa IPv4, 16 significa IPv6.

Manejo de entrada inválida

Cuando la cadena no es una IP válida, inet_pton() devuelve false. Comprueba siempre el resultado antes de usarlo — de lo contrario podrías terminar almacenando o comparando false (una cadena vacía) por accidente:

<?php

$input = "not-an-ip";
$packed = inet_pton($input);

if ($packed === false) {
    echo "Invalid IP address";
} else {
    echo bin2hex($packed);
}
// Outputs: Invalid IP address

Usa comparación estricta (===) aquí. Una 0.0.0.0 válida se empaqueta en el byte 00000000, cuyo primer byte es un byte nulo; una comprobación laxa == false podría fallar en casos extremos, por lo que === false es la prueba segura.

Invertir la conversión

inet_pton() e inet_ntop() forman un par complementario: una empaqueta, la otra desempaqueta. Hacer un ciclo completo devuelve la dirección original:

<?php

$packed = inet_pton("2001:db8::1");
echo inet_ntop($packed); // Outputs 2001:db8::1

¿Cuándo usaría esto?

Almacenar IPs como binario compacto es principalmente para lograr un almacenamiento compacto, ordenable e independiente de la familia:

• Almacenamiento en base de datos. Una columna binaria (VARBINARY(16)) almacena cualquier dirección IPv4 o IPv6 en una forma fija y compacta que ordena correctamente. Usa inet_pton() antes de INSERT e inet_ntop() después de SELECT.
• Comparaciones de rango. Como los bytes preservan el orden numérico, puedes comparar cadenas empaquetadas para comprobar si una dirección cae dentro de una subred.
• Búsquedas de coincidencia exacta. Comparar claves binarias de longitud fija es más rápido y evita la ambigüedad de las formas de texto (p. ej., 2001:db8::1 frente a 2001:0db8:0000:...:0001 son la misma dirección pero cadenas distintas — el empaquetado las normaliza).

Para matemáticas numéricas exclusivas de IPv4, ip2long() y long2ip() son una alternativa, pero no pueden representar IPv6.

Conclusión

inet_pton() convierte una dirección IPv4 o IPv6 de su forma de texto legible por humanos a una cadena binaria compacta — 4 bytes para IPv4, 16 para IPv6 — y devuelve false en caso de entrada inválida. Combínala con inet_ntop() para invertir la conversión, y usa bin2hex() cuando necesites inspeccionar los bytes sin procesar. Es la forma estándar de almacenar y comparar direcciones IP de forma compacta en una base de datos mientras se admiten ambas familias de direcciones.

Práctica