Les entiers

Un entier est un nombre appartenant à l'ensemble ℤ = {..., -2, -1, 0, 1, 2, ...}.

Voir aussi

Syntaxe

Les entiers peuvent être spécifiés en notation décimale (base 10), hexadécimale (base 16), octale (base 8), ou binaire (base 2). L'opérateur de négation peut être utilisé pour désigner un entier négatif.

Pour utiliser la notation octale, il faut précéder le nombre d'un 0 (zéro). À partir de PHP 8.1.0, la notation octale peut également être précédée de 0o ou 0O. Pour utiliser la notation hexadécimale, il faut précéder le nombre de 0x. Pour utiliser la notation binaire, il faut précéder le nombre de 0b.

À partir de PHP 7.4.0, les entiers littéraux peuvent contenir des underscores (_) entre les chiffres, pour une meilleure lisibilité des littéraux. Ces underscores sont supprimés par le scanner de PHP.

Exemple #1 Les entiers littéraux

<?php
$a = 1234; // un nombre décimal
$a = 0123; // un nombre octal (équivalent à 83 en décimal)
$a = 0o123; // un nombre octal (à partir de PHP 8.1.0)
$a = 0x1A; // un nombre hexadécimal (équivalent à 26 en décimal)
$a = 0b11111111; // un nombre binaire (équivalent à 255 en décimal)
$a = 1_234_567; // un nombre décimal (à partir de PHP 7.4.0)
?>

Formellement, la structure d'un entier littéral est à partir de PHP 8.1.0 (auparavant, les préfixes octaux 0o ou 0O n'étaient pas autorisés, et avant PHP 7.4.0, les underscores n'étaient pas autorisés) :

decimal     : [1-9][0-9]*(_[0-9]+)*
            | 0

hexadecimal : 0[xX][0-9a-fA-F]+(_[0-9a-fA-F]+)*

octal       : 0[oO]?[0-7]+(_[0-7]+)*

binary      : 0[bB][01]+(_[01]+)*

integer     : decimal
            | hexadecimal
            | octal
            | binary

La taille d'un entier est dépendante de la plate-forme, cependant, une valeur maximale d'environ 2 milliards est habituelle (cela correspond à 32 bits signés). Les plateformes 64-bit ont habituellement une valeur maximale d'environ 9E18. PHP ne supporte pas les entiers non-signés. La taille d'un entier peut être déterminée en utilisant la constante PHP_INT_SIZE, la valeur maximale, en utilisant la constante PHP_INT_MAX, et la valeur minimale en utilisant la constante PHP_INT_MIN.

Débordement d'entier

Si PHP rencontre un nombre supérieur au maximal d'un entier, il sera interprété comme un nombre décimal. De la même façon, une opération qui résulte en un nombre en dehors de l'intervalle du type entier retournera un nombre décimal.

Exemple #2 Dépassement d'entier

<?php
$large_number = 50000000000000000000;
var_dump($large_number);         // float(5.0E+19)

var_dump(PHP_INT_MAX + 1);       // 32-bit system: float(2147483648)
                                 // 64-bit system: float(9.2233720368548E+18)
?>

Division d'entier

Il n'y a pas d'opérateur de division d'entier en PHP, pour accomplir ceci, utiliser la fonction intdiv(). 1/2 produit le nombre décimal (0.5). La valeur peut être transtypée en un entier pour l'arrondir vers zéro, ou en utilisant la fonction round() pour avoir un contrôle plus fin sur la façon dont l'arrondi est exécuté.

Exemple #3 Division

<?php
var_dump(25/7);         // float(3.5714285714286)
var_dump((int) (25/7)); // int(3)
var_dump(round(25/7));  // float(4)
?>

Conversion en entier

Pour convertir explicitement une valeur en un entier, utiliser le mot-clé (int). Cependant, dans la plupart des cas, ce mot-clé n'est pas nécessaire vu qu'une valeur sera automatiquement convertie si un opérateur, une fonction ou une structure de contrôle demande un entier en guise d'argument. Une valeur peut également être convertie en un entier en utilisant la fonction intval().

Si une resource est convertie vers un entier, alors le résultat sera l'identifiant unique de la resource assigné par PHP à l'exécution.

Voir aussi le transtypage.

Depuis un booléen

false correspond à 0 (zéro), et true correspond à 1 (un).

Depuis un nombre à virgule flottante

Lors de la conversion d'un nombre décimal en entier, le nombre est arrondi vers zéro. À partir de PHP 8.1.0, une notification de dépréciation est émise lors de la conversion implicite d'un nombre décimal non-intégral en entier perdant en précision.

Exemple #4 Conversion depuis des nombres flottants

<?php

function foo($value): int {
  return $value;
}

var_dump(foo(8.1)); // "Deprecated: Implicit conversion from float 8.1 to int loses precision" à partir de PHP 8.1.0
var_dump(foo(8.1)); // 8 avant PHP 8.1.0
var_dump(foo(8.0)); // 8 dans les deux cas

var_dump((int) 8.1); // 8 dans les deux cas
var_dump(intval(8.1)); // 8 dans les deux cas
?>

Si le nombre à virgule flottante est au-delà des limites des entiers (habituellement, +/- 2.15e+9 = 2^31 sur les plate-formes 32-bit et +/- 9.22e+18 = 2^63 sur les plate-formes 64-bit), le résultat sera indéfini, sachant que le nombre décimal n'a pas une précision suffisante pour donner un résultat entier exact. Aucune alerte n'est émise lorsque ce comportement survient !

Note:
NaN, Inf et -Inf sont toujours égaux à zéro lors d'une conversion en int.

Avertissement

Ne jamais convertir une fraction inconnue en un entier, ceci peut engendrer des résultats inattendus.

<?php
echo (int) ( (0.1+0.7) * 10 ); // Affiche 7 !
?>

Voir aussi la section sur les alertes concernant la précision des nombres à virgule flottante.

Depuis des chaînes de caractères

Si une chaîne est numérique ou numérique de tête alors elle sera transformée en sa valeur entière correspondante, sinon elle sera convertie en zéro (0).

Depuis NULL

null est toujours converti en zéro (0).

Depuis d'autres types

Attention

Le comportement de la conversion en entier est indéfini pour les autres types. Ne pas se fier à un quelconque comportement observé, sachant qu'il peut changer sans avertissement.