Números en PHP: Una Guía Completa

Los números son el núcleo de casi cualquier programa PHP — contar elementos, calcular precios, medir tamaños. Este capítulo cubre los dos tipos numéricos que ofrece PHP, cómo escribir números en distintas notaciones, los operadores aritméticos y funciones matemáticas más utilizados, la trampa de precisión de los flotantes que le ocurre a todo desarrollador al menos una vez, y cómo formatear y validar números de forma segura.

Comprensión de los Tipos de Datos Numéricos en PHP

PHP tiene dos tipos de datos numéricos:

• int (entero) — un número entero sin parte fraccionaria, como 42 o -7.
• float (punto flotante, también llamado double) — un número con parte fraccionaria, como 3.14 o -0.5.

PHP es de tipado débil, por lo que nunca se declara el tipo. PHP elige int o float automáticamente según el literal que escribas y las operaciones que realices. Puedes comprobar el tipo en tiempo de ejecución con gettype() o var_dump().

El tamaño de un entero depende de la plataforma. En un sistema de 64 bits (lo habitual hoy en día), un entero va de -9.223.372.036.854.775.808 a 9.223.372.036.854.775.807; en un sistema de 32 bits el rango es de -2.147.483.648 a 2.147.483.647. El límite exacto está disponible como la constante PHP_INT_MAX. Cuando un cálculo lo supera, PHP convierte silenciosamente el resultado a float en lugar de desbordarse — por lo que los enteros muy grandes pueden perder precisión.

Escritura de Literales Numéricos

No estás limitado a la notación decimal simple. PHP entiende varias bases, además de guiones bajos para mejorar la legibilidad:

<?php
$dec = 42;        // decimal integer
$float = 3.14;    // floating-point
$hex = 0x1A;      // hexadecimal, equals 26
$oct = 0o17;      // octal (PHP 8.1+ "0o" prefix), equals 15
$bin = 0b101;     // binary, equals 5
$big = 1_000_000; // underscores are ignored (PHP 7.4+), equals 1000000

echo $hex, "\n";  // 26
echo $oct, "\n";  // 15
echo $bin, "\n";  // 5
echo $big, "\n";  // 1000000

var_dump($dec);   // int(42)
var_dump($float); // float(3.14)
?>

Los guiones bajos son puramente decorativos — PHP los ignora — pero hacen que los números largos como 1_000_000 sean mucho más fáciles de leer. Consulta el capítulo Tipos de Datos en PHP para ver cómo encajan junto a cadenas, booleanos y arrays.

Operaciones Aritméticas en PHP

PHP admite los operadores aritméticos estándar: suma (+), resta (-), multiplicación (*), división (/), módulo (%) y exponenciación (**). El conjunto completo se trata en Operadores PHP. Aquí se muestra cada una de las operaciones principales en acción:

<?php
$num1 = 10;
$num2 = 5;

// Addition
$result = $num1 + $num2;
echo "\$num1 + \$num2 = ";
echo $result; // 15

// Subtraction
$result = $num1 - $num2;
echo "\n\$num1 - \$num2 = ";
echo $result; // 5

// Multiplication
$result = $num1 * $num2;
echo "\n\$num1 * \$num2 = ";
echo $result; // 50

// Division
$result = $num1 / $num2;
echo "\n\$num1 / \$num2 = ";
echo $result; // 2

// Modulus
$result = $num1 % $num2;
echo "\n\$num1 % \$num2 = ";
echo $result; // 0
?>

División, División Entera y Módulo

La división en PHP tiene una sutileza que vale la pena conocer. El operador / devuelve un float cuando el resultado no es un número entero, y un int cuando los operandos son divisibles exactamente. Para obtener siempre un resultado entero, usa intdiv(). Para el resto, % funciona con enteros y fmod() funciona con flotantes:

<?php
var_dump(10 / 4);        // float(2.5)  — not evenly divisible
var_dump(10 / 5);        // int(2)      — evenly divisible
var_dump(intdiv(10, 4)); // int(2)      — integer division, remainder dropped
var_dump(10 % 4);        // int(2)      — modulus (remainder)
var_dump(fmod(10.5, 3)); // float(1.5)  — floating-point remainder
?>

Dividir entre cero lanza un DivisionByZeroError en PHP 8 y versiones posteriores, así que comprueba el divisor antes de dividir si puede ser 0.

Precisión de Punto Flotante

Los flotantes no pueden representar todos los valores decimales exactamente, porque se almacenan en binario. Esto lleva a una sorpresa clásica:

<?php
var_dump(0.1 + 0.2 === 0.3); // bool(false) — not exactly equal!

// Compare floats with a small tolerance instead:
$epsilon = 1e-9;
var_dump(abs((0.1 + 0.2) - 0.3) < $epsilon); // bool(true)
?>

0.1 + 0.2 es en realidad 0.30000000000000004, por lo que la comparación estricta === falla aunque echo lo redondee a 0.3 para mostrarlo. La regla general: nunca compares flotantes con == o === — comprueba si su diferencia está dentro de una pequeña tolerancia (un épsilon). Para dinero y otros trabajos con decimales exactos, almacena los valores como centavos enteros o usa las extensiones BCMath / GMP.

Funciones Matemáticas Avanzadas en PHP

Más allá de los operadores, PHP incluye un rico conjunto de funciones matemáticas integradas. Las más comunes son:

• abs() — el valor absoluto (no negativo) de un número
• ceil() — redondea hacia arriba al entero más cercano
• floor() — redondea hacia abajo al entero más cercano
• round() — redondea al entero más cercano, o a un número determinado de decimales
• sqrt() — la raíz cuadrada de un número
• pow() — eleva un número a una potencia (igual que el operador **)
• max() / min() — el mayor / menor de los valores proporcionados
• rand() / random_int() — un número aleatorio (random_int() es criptográficamente seguro)

La lista completa se encuentra en la referencia de Matemáticas PHP. Aquí hay una selección en uso:

<?php
$num1 = -10;
$num2 = 2.7;

// Absolute value
$result = abs($num1);
echo "abs(\$num1) = ";
echo $result  . "\n"; // 10

// Round up
$result = ceil($num2);
echo "ceil(\$num2) = ";
echo $result . "\n"; // 3

// Round down
$result = floor($num2);
echo "floor(\$num2) = ";
echo $result . "\n"; // 2

// Square root
$result = sqrt(9);
echo "sqrt(9) = ";
echo $result . "\n";  // 3

// Raise to power
$result = pow(2, 3);
echo "pow(2, 3) = ";
echo $result; // 8
?>

Formateo de Números para Mostrar

Los números brutos rara vez se ven bien en una página. number_format() añade separadores de miles y fija el número de decimales, y round() controla la precisión en los cálculos:

<?php
echo number_format(1234567.891, 2), "\n";          // 1,234,567.89
echo number_format(1234567.891, 2, '.', ' '), "\n"; // 1 234 567.89 (custom separators)
echo round(3.14159, 2), "\n";                       // 3.14
?>

El segundo argumento y los siguientes de number_format() permiten establecer la cantidad de decimales y elegir los separadores decimal y de miles — útil para salida específica de cada región.

Comprobación y Conversión de Valores Numéricos

Cuando los datos llegan de formularios, URLs o archivos, son texto. Valídalos antes de hacer operaciones aritméticas. is_int() e is_float() comprueban el tipo real, mientras que is_numeric() comprueba si una cadena parece un número. Para convertir, usa el casting con (int) / (float) o usa floatval():

<?php
var_dump(is_int(42));          // bool(true)
var_dump(is_float(3.14));      // bool(true)
var_dump(is_numeric("123"));   // bool(true)  — numeric string
var_dump(is_numeric("12abc")); // bool(false) — not numeric

echo (int) "42px", "\n";       // 42  — leading digits are kept, the rest dropped
echo PHP_INT_MAX, "\n";        // 9223372036854775807 on a 64-bit system
?>

Las comprobaciones de tipo relacionadas tienen sus propios capítulos: is_int() e is_float().

Conclusión

En conclusión, los números desempeñan un papel fundamental en la programación PHP y es importante tener una comprensión sólida de cómo trabajar con ellos. Ya sea que realices operaciones aritméticas básicas o funciones matemáticas avanzadas, PHP proporciona una variedad de herramientas para ayudarte a realizar el trabajo. Con los conocimientos adquiridos en este artículo, ahora estás preparado para afrontar cualquier tarea relacionada con números en tus proyectos PHP.

Práctica