Números em PHP: Um Guia Completo

Os números estão no centro de quase todos os programas PHP — contar itens, calcular preços, medir tamanhos. Este capítulo aborda os dois tipos numéricos que o PHP oferece, como escrever números em diferentes notações, as operações aritméticas e funções matemáticas mais usadas, a armadilha de precisão de float que todo desenvolvedor enfrenta ao menos uma vez, e como formatar e validar números com segurança.

Compreendendo os Tipos de Dados Numéricos do PHP

O PHP possui dois tipos de dados numéricos:

• int (inteiro) — um número inteiro sem parte fracionária, como 42 ou -7.
• float (ponto flutuante, também chamado de double) — um número com parte fracionária, como 3.14 ou -0.5.

O PHP é fracamente tipado, portanto você nunca declara o tipo. O PHP escolhe int ou float automaticamente com base no literal que você escreve e nas operações realizadas. Você pode verificar o tipo em tempo de execução com gettype() ou var_dump().

O tamanho de um inteiro depende da plataforma. Em um sistema de 64 bits (o caso comum hoje) um inteiro varia de -9.223.372.036.854.775.808 a 9.223.372.036.854.775.807; em um sistema de 32 bits o intervalo é de -2.147.483.648 a 2.147.483.647. O limite exato está disponível como a constante PHP_INT_MAX. Quando um cálculo ultrapassa esse limite, o PHP converte silenciosamente o resultado para float em vez de causar overflow — portanto, inteiros muito grandes podem perder precisão.

Escrevendo Literais Numéricos

Você não está limitado à notação decimal simples. O PHP entende diversas bases, além de sublinhados para legibilidade:

<?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)
?>

Os sublinhados são puramente cosméticos — o PHP os ignora —, mas tornam números longos como 1_000_000 muito mais fáceis de ler. Veja o capítulo de Tipos de Dados PHP para entender como eles se encaixam junto a strings, booleanos e arrays.

Operações Aritméticas em PHP

O PHP suporta os operadores aritméticos padrão: adição (+), subtração (-), multiplicação (*), divisão (/), módulo (%) e exponenciação (**). O conjunto completo está coberto em Operadores PHP. Veja cada uma das operações principais em ação:

<?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
?>

Divisão, Divisão Inteira e Módulo

A divisão em PHP tem uma sutileza que vale conhecer. O operador / retorna um float quando o resultado não é um número inteiro, e um int quando os operandos são divisíveis exatamente. Para um resultado que seja sempre um inteiro, use intdiv(). Para o resto, % funciona com inteiros e fmod() funciona com floats:

<?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 por zero lança um DivisionByZeroError no PHP 8 e versões posteriores, portanto proteja o divisor antes de dividir caso ele possa ser 0.

Precisão de Ponto Flutuante

Floats não podem representar todos os valores decimais com exatidão, porque são armazenados em binário. Isso leva a uma surpresa clássica:

<?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 na verdade resulta em 0.30000000000000004, portanto a comparação estrita com === falha mesmo que echo arredonde para 0.3 na exibição. A regra geral: nunca compare floats com == ou === — verifique se a diferença entre eles está dentro de uma tolerância mínima (um epsilon). Para operações com dinheiro e outros valores decimais exatos, armazene os valores como centavos inteiros ou use as extensões BCMath / GMP.

Funções Matemáticas Avançadas em PHP

Além dos operadores, o PHP inclui um rico conjunto de funções matemáticas embutidas. As mais comuns são:

• abs() — o valor absoluto (não negativo) de um número
• ceil() — arredonda para cima até o inteiro mais próximo
• floor() — arredonda para baixo até o inteiro mais próximo
• round() — arredonda para o inteiro mais próximo, ou para um determinado número de casas decimais
• sqrt() — a raiz quadrada de um número
• pow() — eleva um número a uma potência (equivalente ao operador **)
• max() / min() — o maior / menor dos valores fornecidos
• rand() / random_int() — um número aleatório (random_int() é criptograficamente seguro)

A lista completa está na referência de Math do PHP. Veja uma seleção em 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
?>

Formatando Números para Exibição

Números brutos raramente ficam bem em uma página. number_format() adiciona separadores de milhares e define o número de casas decimais, e round() controla a precisão nos 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
?>

O segundo argumento e os seguintes de number_format() permitem definir a quantidade de casas decimais e escolher os separadores decimal e de milhar — útil para saída específica por localidade.

Verificando e Convertendo Valores Numéricos

Quando dados chegam de formulários, URLs ou arquivos, eles são texto. Valide-os antes de realizar operações aritméticas. is_int() e is_float() verificam o tipo real, enquanto is_numeric() verifica se uma string parece um número. Para converter, use cast com (int) / (float) ou utilize 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
?>

Verificadores de tipo relacionados têm seus próprios capítulos: is_int() e is_float().

Conclusão

Em conclusão, os números desempenham um papel crucial na programação PHP e é importante ter uma compreensão sólida de como trabalhar com eles. Seja realizando operações aritméticas básicas ou funções matemáticas avançadas, o PHP oferece uma variedade de ferramentas para ajudá-lo a realizar o trabalho. Com o conhecimento adquirido neste artigo, você está agora preparado para lidar com qualquer tarefa relacionada a números em seus projetos PHP.

Prática