Les nombres en PHP : un guide complet

Les nombres sont au cœur de presque tous les programmes PHP — compter des éléments, calculer des prix, mesurer des tailles. Ce chapitre couvre les deux types numériques que PHP propose, comment écrire des nombres dans différentes notations, les opérations arithmétiques et les fonctions mathématiques les plus utilisées, le piège de la précision des flottants qui surprend chaque développeur au moins une fois, et comment formater et valider les nombres de manière sûre.

Comprendre les types de données numériques en PHP

PHP dispose de deux types de données numériques :

• int (entier) — un nombre entier sans partie fractionnaire, tel que 42 ou -7.
• float (virgule flottante, aussi appelé double) — un nombre avec une partie fractionnaire, tel que 3.14 ou -0.5.

PHP est faiblement typé, donc vous ne déclarez jamais le type. PHP choisit automatiquement int ou float en fonction du littéral que vous écrivez et des opérations que vous effectuez. Vous pouvez vérifier le type à l'exécution avec gettype() ou var_dump().

La taille d'un entier dépend de la plateforme. Sur un système 64 bits (le cas courant aujourd'hui), un entier va de -9 223 372 036 854 775 808 à 9 223 372 036 854 775 807 ; sur un système 32 bits, la plage est de -2 147 483 648 à 2 147 483 647. La limite exacte est disponible en tant que constante PHP_INT_MAX. Lorsqu'un calcul la dépasse, PHP convertit silencieusement le résultat en float plutôt que de générer un débordement — les très grands entiers peuvent donc perdre en précision.

Écrire des littéraux numériques

Vous n'êtes pas limité à la notation décimale classique. PHP comprend plusieurs bases, ainsi que les underscores pour la lisibilité :

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

Les underscores sont purement cosmétiques — PHP les ignore — mais ils rendent des nombres longs comme 1_000_000 beaucoup plus faciles à lire. Consultez le chapitre Types de données PHP pour voir comment ceux-ci s'intègrent aux chaînes, aux booléens et aux tableaux.

Les opérations arithmétiques en PHP

PHP prend en charge les opérateurs arithmétiques standard : addition (+), soustraction (-), multiplication (*), division (/), modulo (%) et exponentiation (**). L'ensemble complet est couvert dans Les opérateurs PHP. Voici chacune des opérations de base en action :

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

Division, division entière et modulo

La division en PHP a une subtilité qui mérite d'être connue. L'opérateur / retourne un float lorsque le résultat n'est pas un nombre entier, et un int lorsque les opérandes se divisent exactement. Pour un résultat qui est toujours un entier, utilisez intdiv(). Pour le reste, % fonctionne sur les entiers et fmod() fonctionne sur les flottants :

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

Diviser par zéro lève une DivisionByZeroError en PHP 8 et versions ultérieures, donc protégez le diviseur avant de diviser s'il pourrait être 0.

La précision des nombres flottants

Les flottants ne peuvent pas représenter exactement toutes les valeurs décimales, car ils sont stockés en binaire. Cela conduit à une surprise classique :

<?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 vaut en réalité 0.30000000000000004, donc la comparaison stricte === échoue même si echo l'arrondit à 0.3 pour l'affichage. La règle d'or : ne comparez jamais des flottants avec == ou === — vérifiez si leur différence est inférieure à une petite tolérance (un epsilon). Pour les montants monétaires et autres travaux nécessitant une précision décimale exacte, stockez les valeurs en centimes entiers ou utilisez les extensions BCMath / GMP.

Les fonctions mathématiques avancées en PHP

Au-delà des opérateurs, PHP fournit un riche ensemble de fonctions mathématiques intégrées. Les plus courantes sont :

• abs() — la valeur absolue (non négative) d'un nombre
• ceil() — arrondit vers le haut à l'entier le plus proche
• floor() — arrondit vers le bas à l'entier le plus proche
• round() — arrondit à l'entier le plus proche, ou à un nombre donné de décimales
• sqrt() — la racine carrée d'un nombre
• pow() — élève un nombre à une puissance (identique à l'opérateur **)
• max() / min() — la valeur la plus grande / la plus petite parmi les valeurs fournies
• rand() / random_int() — un nombre aléatoire (random_int() est cryptographiquement sécurisé)

La liste complète se trouve dans la référence mathématique PHP. Voici une sélection en action :

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

Formater les nombres pour l'affichage

Les nombres bruts donnent rarement un bon rendu sur une page. number_format() ajoute des séparateurs de milliers et fixe le nombre de décimales, et round() contrôle la précision dans les calculs :

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

Le deuxième argument et les suivants de number_format() permettent de définir le nombre de décimales et de choisir les séparateurs décimal et de milliers — pratique pour un affichage spécifique à une locale.

Vérifier et convertir des valeurs numériques

Lorsque les données proviennent de formulaires, d'URL ou de fichiers, elles sont du texte. Validez-les avant d'effectuer des calculs. is_int() et is_float() vérifient le type réel, tandis que is_numeric() vérifie si une chaîne ressemble à un nombre. Pour convertir, utilisez le cast (int) / (float) ou 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
?>

Les gardes de type associées ont leurs propres chapitres : is_int() et is_float().

Conclusion

En conclusion, les nombres jouent un rôle crucial dans la programmation PHP et il est important d'avoir une bonne compréhension de la façon de les manipuler. Que vous effectuiez des opérations arithmétiques de base ou des fonctions mathématiques avancées, PHP fournit une variété d'outils pour vous aider à accomplir le travail. Grâce aux connaissances acquises dans cet article, vous êtes désormais prêt à relever n'importe quelle tâche liée aux nombres dans vos projets PHP.

Pratique