Vous êtes ici :
Accueil Cours Programmations La base du langage PHP Les types de données

La base du langage PHP : Les types de données

Introduction

 

PHP supporte 8 types basiques.

4 types scalaires :

  • boolean
  • integer
  • float (nombre à virgule flottante, i.e. double)
  • string

2 types composés :

  • array
  • object

Et finalement, 2 types spéciaux :

  • resource
  • NULL

Cette partie introduit également quelques pseudo-types pour des raisons de lisibilité :

  • mixed
  • number
  • callback (appelé aussi callable)
  • array|object
  • void

Et la pseudo-variable $....

Ce cours peut toutefois contenir des références au type "double". Considérez ce type comme étant un type "float". Les deux noms n'existent que pour des raisons historiques.

Le type d'une variable n'est pas toujours défini par le programmeur ; il peut être défini par PHP au moment de l'exécution, suivant le contexte dans lequel la variable est utilisée.

Note: Pour vérifier le type et la valeur d'une expression, utilisez la fonction var_dump().

Pour afficher une représentation humainement lisible d'un type aux fins de déboguage, utilisez la fonction gettype(). Pour vérifier un certain type, n'utilisez pas la fonction gettype(), mais plutôt les fonctions is_type. Voici quelques exemples :

<?php
$a_bool = TRUE;   // un booléen
$a_str  = "foo";  // une chaîne de caractères
$a_str2 = 'foo';  // une chaîne de caractères
$an_int = 12;     // un entier

echo gettype($a_bool); // affiche :  boolean
echo gettype($a_str);  // affiche :  string

// Si c\'est un entier, incrément de 4
if (is_int($an_int)) {
    $an_int += 4;
}

// Si $a_bool est une chaîne de caractères, on l'affiche
if (is_string($a_bool)) {
    echo "String: $a_bool";
}
?> 

Pour forcer la conversion d'une variable en un certain type, vous pouvez transtyper (cast) la variable ou utiliser la fonction settype().

Notez qu'une variable peut être évaluée avec différentes valeurs dans certaines situations, suivant son type à un moment donné. Pour plus d'informations, lisez la section sur le transtypage. La table de comparaison des types peut également être très utile, montrant différents exemples.

Les booléen

 

C'est le type le plus simple. Un booléen représente une valeur de vérité. Il peut valoir TRUE ou FALSE.

Syntaxe

Pour spécifier un booléen littéral, utilisez la constante TRUE ou FALSE. Les deux sont insensibles à la casse.

<?php
$foo = True; // assigne la valeur TRUE à $foo
?> 

 

Typiquement, le résultat d'un opérateur qui retourne un booléen, passé ensuite à une structure de contrôle.

<?php
// == est un opérateur qui teste
// l'égalité et retourne un booléen
if ($action == "show_version") {
    echo "La version est 1.23";
}

// ceci n'est pas nécessaire...
if ($show_separators == TRUE) {
    echo "<hr>\n";
}

// ...à la place, vous pouvez utiliser, avec la même signification :
if ($show_separators) {
    echo "<hr>\n";
}
?> 

 

Conversion en booléen

Pour convertir explicitement une valeur en booléen, utilisez (bool) ou (boolean). Cependant, dans la plupart des cas, le transtypage n'est pas nécessaire, sachant qu'une valeur sera automatiquement convertie si un opérateur, une fonction ou une structure de contrôle demandent un argument de type booléen.

Voir aussi le transtypage.

Lors d'une conversion en booléen, les valeurs suivantes sont considérées comme FALSE :

  • le booléen FALSE, lui-même
  • l'entier 0 (zéro)
  • le nombre à virgule flottante 0.0 (zéro)
  • la chaîne vide, et la chaîne "0"
  • un tableau avec aucun élément
  • un objet avec aucun membre, ni variable (uniquement en PHP 4)
  • le type spécial NULL (incluant les variables non définies)
  • les objets SimpleXML créés depuis des balises vides

Toutes les autres valeurs sont considérées comme TRUE (y compris toutes les ressources).

Avertissement

-1 est considéré comme TRUE, comme tous les nombres différents de zéro (négatifs ou positifs) !

<?php
var_dump((bool) "");        // bool(false)
var_dump((bool) 1);         // bool(true)
var_dump((bool) -2);        // bool(true)
var_dump((bool) "foo");     // bool(true)
var_dump((bool) 2.3e5);     // bool(true)
var_dump((bool) array(12)); // bool(true)
var_dump((bool) array());   // bool(false)
var_dump((bool) "false");   // bool(true)
?> 

Les entiers

 

Un entier est un nombre appartenant à la classe Z = {..., -2, -1, 0, 1, 2, ...}.

Voir aussi :

  • Les entiers de longueur arbitraire / GMP
  • Les nombres à virgule flottante
  • Les précisions arbitraires / BCMath

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) optionnellement précédée d'un signe (- ou +).

Les entiers littéraux binaires sont disponibles depuis PHP 5.4.0.

Pour utiliser la notation octale, précédez le nombre d'un 0 (zéro). Pour utiliser la notation hexadécimale, précédez le nombre d'un 0x. Pour utiliser la notation binaire, précédez le nombre d'un 0b.

Exemple #1 Les entiers littéraux

<?php
$a = 1234; // un nombre décimal
$a = -123; // un nombre négatif
$a = 0123; // un nombre octal (équivalent à 83 en décimal)
$a = 0x1A; // un nombre héxadecimal (équivalent à 26 en décimal)
$a = 0b11111111; // un nombre binaire (équivalent à 255 en decimal)
?> 

Formellement, la structure d'un entier littéral est :

decimal     : [1-9][0-9]*
            | 0

hexadecimal : 0[xX][0-9a-fA-F]+

octal       : 0[0-7]+

integer     : [+-]?decimal
            | [+-]?hexadecimal
            | [+-]?octal
            | [+-]?binary

La taille d'un entier est dépendant 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, sauf pour Windows, qui est toujours en 32 bit. 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, et la valeur maximale, en utilisant la constante PHP_INT_MAX depuis PHP 4.4.0 et PHP 5.0.5.

Avertissement

Avant PHP 7, si un nombre invalide était fourni dans un entier octal (i.e. 8 ou 9), le reste du nombre était ignoré. Depuis PHP 7, une erreur d'analyse est émise.

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 supérieur au nombre maximal d'un entier, retournera un nombre décimal.

Exemple #2 Dépassement d'entier sur un système 32-bit

<?php
$large_number = 2147483647;
var_dump($large_number);                     // int(2147483647)

$large_number = 2147483648;
var_dump($large_number);                     // float(2147483648)

$million = 1000000;
$large_number =  50000 * $million;
var_dump($large_number);                     // float(50000000000)
?> 

Exemple #3 Dépassement d'entier sur un système 64-bit

<?php
$large_number = 9223372036854775807;
var_dump($large_number);                     // int(9223372036854775807)

$large_number = 9223372036854775808;
var_dump($large_number);                     // float(9.2233720368548E+18)

$million = 1000000;
$large_number =  50000000000000 * $million;
var_dump($large_number);                     // float(5.0E+19)
?>

Il n'y a pas d'opérateur de division entière en PHP. 1/2 contient en fait, float(0.5). La valeur peut être convertie en un entier en l'arrondissant, en utilisant la fonction round().

<?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, utilisez soit le mot-clé (int), soit (integer). 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 integer, 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

Lorsque l'on convertit un nombre décimal en un entier, le nombre sera arrondi vers zéro.

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 autre que Windows), le résultat sera indéfini, sachant que le nombre à virgule flottante n'a pas une précision suffisante pour donner un résultat entier exact. Aucune alerte n'est émise lorsque ce comportement survient !

Avertissement

Ne convertissez jamais une fraction inconnue en un entier, ceci peut engendrer un résultat inattendu.

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

Depuis des chaînes de caractères

Voir la section sur la conversion des chaînes en nombres

Depuis d'autres types

Attention

Le comportement de la conversion en un entier est indéfini depuis les autres types. Ne rapporter aucun comportement observé, sachant qu'ils peuvent changer sans avertissement.

 

Nombres décimaux

Les nombres décimaux, (aussi connus comme nombres à virgule flottante, "floats", "doubles", ou "real numbers") peuvent être spécifiés en utilisant les syntaxes suivantes :

<?php
$a = 1.234;
$b = 1.2e3;
$c = 7E-10;
?> 

 

Formellement :

LNUM          [0-9]+
DNUM          ([0-9]*[\\.]) | ([\\.][0-9]*)
EXPONENT_DNUM [+-]?(( | ) [eE][+-]? )

La taille d'un nombre décimal est dépendant de la plate-forme, cependant, un nombre maximal de ~1.8e308 avec une précision sur 14 chiffres est une valeur commune (format 64 bits IEEE).

Avertissement

Précision des nombres décimaux

Les nombres décimaux ont une précision limitée. Même s'ils dépendent du système, PHP utilise le format de précision des décimaux IEEE 754, qui donnera une erreur maximale relative de l'ordre de 1.11e-16 (dûe aux arrondis). Les opérations arithmétiques non-élémentaires peuvent donner des erreurs plus importantes et bien sûr les erreurs doivent être prises en compte lorsque plusieurs opérations sont liées.

Aussi, les nombres rationnels exactement représentables sous forme de nombre à virgule flottante en base 10, comme 0.1 ou 0.7, n'ont pas de représentation exacte comme nombres à virgule flottante en base 2, utilisée en interne, et ce quelle que soit la taille de la mantisse. De ce fait, ils ne peuvent être convertis sans une petite perte de précision. Ceci peut mener à des résultats confus: par exemple, floor((0.1+0.7)*10) retournera normalement 7 au lieu de 8 attendu, car la représentation interne sera quelque chose comme 7.9999999999999991118....

Ainsi, ne faites jamais confiance aux derniers chiffres d'un nombre décimal, mais aussi, ne comparez pas l'égalité de 2 nombres décimaux directement. Si vous avez besoin d'une haute précision, les fonctions mathématiques de précision et les fonctions gmp sont disponibles.

Pour une explication "simple", reportez-vous au » guide relatif aux nombres à virgule flottante.

Conversion en un nombre décimal

Pour plus d'informations sur la conversion de chaînes en nombres décimaux, voir la section sur la conversion de chaînes en nombres décimaux. Pour les valeurs d'autres types, la conversion est effectuée en convertissant tout d'abord la valeur en un entier, puis, en nombre décimal. Voir la section sur la conversion en entier pour plus d'informations. Une notice est émise si un objet est converti en nombre décimal.

Comparaison de nombre décimaux

Comme dit dans la note ci-dessus, le test d'égalité des valeurs de nombres décimaux est problématique, en raison de la façon dont ils sont représentés en interne. Cependant, il existe des façons de réaliser cette comparaison.

Pour tester l'égalité de valeurs de nombres décimaux, une borne supérieure de l'erreur relative à l'arrondi est utilisée. Cette valeur est connue comme étant l'epsilon de la machine, ou le unit roundoff, et est la différence la plus petite acceptable dans les calculs.

$a et $b sont égaux sur 5 nombres après la virgule.

<?php
$a = 1.23456789;
$b = 1.23456780;
$epsilon = 0.00001;

if(abs($a-$b) < $epsilon) {
    echo "true";
}
?> 

 

NaN :

Quelques opérations numériques peuvent donner comme résultat une valeur représentée par la constante NAN. Ce résultat représente une valeur indéfinie ou non représentable lors de calculs avec des nombres à virgule flottante. Toute comparaison, même stricte de cette valeur avec une autre valeur, y compris cette constante elle-même, donnera une valeur de FALSE.

En raison du fait que NAN représente tout nombre de valeur différente, NAN ne doit pas être comparé à d'autres valeurs, y compris cette constante elle-même, et à la place, elle doit être vérifiée en utilisant la fonction is_nan().




Vous êtes ici :
Accueil Cours Programmations La base du langage PHP Les types de données