2- Les variables

Pour manipuler des informations comme des nombres, du texte ou des tableaux, il est fastidieux de les répéter à chaque fois pour les utiliser, surtout si leur valeur peut changer au cours d’un calcul. Pour nous simplifier la vie, nous stockons ces valeurs en mémoire dans de petits espaces, et nous leur donnons un nom (comme une étiquette) pour pouvoir les réutiliser ensuite. Une variable est donc un espace mémoire dans lequel on stock de l’information et auquel on accède par son nom.

Pour aller un peu plus loin, il faut savoir que les différents types de variables ne prennent pas le même espace en mémoire, et que c’est pour cela que dans certains langages il faut déclarer le type de la variable qu’on va affecter pour réserver son espace mémoire (c’est la déclaration) avant d’affecter la valeur dans la variable (l’affectation). En PHP, qui est un langage dynamique, nous n’avons pas besoin de déclarer puis d’affecter une valeur à une variable : nous faisons les deux en même temps, c’est l’initialisation.

Pour comprendre ce fonctionnement, il suffit de voir la mémoire comme des boîtes. Quand nous voulons stocker quelque chose dans une de nos boîtes, nous lui mettons une petite étiquette pour nous souvenir de ce que nous avons mis dedans. Comme notre ordinateur met des étiquettes incompréhensibles pour nous, nous leur donnons un nom qui a un sens : c’est le nom de la variable, qui est associé à l’adresse mémoire que lui a donné l’ordinateur. Et comme ce que nous voulons mettre dans chaque boîte n’a pas la même taille, nous devons prendre une boîte plus petite ou plus grande : aucun intérêt de réserver une grande boîte pour stocker une toute petite chose.

Dans des langages comme le C++, où l’on a un grand contrôle de la mémoire, l’espace mémoire dans lequel est stocké la variable a une adresse et il est accessible directement via un pointeur (qui stock cette adresse). Pour modifier directement la valeur de la variable en mémoire, on utilise la référence, qui est un alias de la variable qui permet de modifier directement la valeur de la variable dans sa case mémoire, sans la copier.

PHP étant un langage dynamique, la mémoire est gérée et allouée par le langage : nous ne nous en soucions pas. De la même manière, nous ne pouvons pas connaître la valeur d’un pointeur, soit l’adresse mémoire où est stockée une variable. De plus, comme en Python, plusieurs variables qui stockent la même valeur pointent vers la même adresse (cela économise la place). En PHP, il existe donc une table des symboles qui stock le nom des variables, leur valeur, le nombre de nom de variables (aussi appelés symboles) qui pointent vers cette valeur, et si oui ou non cette variable est une référence. Nous y accédons avec les méthodes debug_zval_dump($variable) et xdebug_debug_zval($variable). Nous verrons comment utiliser les références en PHP dans la partie dédiée.

Pour aller encore plus loin :

  • http://www-inf.telecom-sudparis.eu/COURS/CSC4103/Public/EnLigne/Cours/C4/2.html
  • https://fr.wikipedia.org/wiki/Adressage_m%C3%A9moire
  • https://fr.wikibooks.org/wiki/Programmation_C%2B%2B/Les_pointeurs
  • http://php.net/manual/en/features.gc.refcounting-basics.php
  • http://www.normalesup.org/~charpiat/cours/node15.html

Les variables en PHP

Les variables en PHP commencent par un $.

Elles peuvent être de type bool (true ou false), string (chaîne de caractère), int (entier), float (nombre à virgule flottante), object (une classe dont la variable sera une instance, c’est à dire un objet), NULL (elle n’a pas encore reçue de valeur ou a été déclarée à NULL) iterable (que l’on peut itérer comme un tableau) ou array (un tableau). Il existe également des types de ressources pour les ressources externes (pdf, images etc…) mais cela ne nous concerne pas encore.

En PHP, on ne déclare pas les types des variables directement lors de l’initialisation de la variable, mais le type a tout de même une importance : additionner deux chaînes de caractère ne revient pas à additionner 2 entiers. Il n’est pas non plus nécessaire de déclarer une variable avant son affectation puisque le typage est dynamique (nous n’avons pas besoin de réserver l’espace mémoire avant d’y stocker l’information).

Il faut donc déclarer le type de variable le plus tôt possible (par exemple $nomDeMaVariable = 0;) pour un int même si cela est parfois inutile. On peut spécifier le type des paramètres des fonctions et méthodes depuis PHP 7.0.

Pour affecter une variable, on utilise l’opérateur “=”. Pour stocker l’entier 5 dans la variable de nom “toto”, on écrira donc $toto = 5;. Cela revient à stocker l’entier 5 dans la mémoire de l’ordinateur et de lui mettre une étiquette $toto pour pouvoir l’utiliser plus tard.

Une variable peut également être affectée par le retour d’une fonction. Si une fonction “tata” retourne 3, écrire $nb = 3; ou $nb = tata(); sera exactement similaire. On peut afficher le type et le contenu d’une variable en écrivant var_dump($maVariable); et cela est très pratique pour débugguer notre code.

Notez que pour affecter une chaîne de caractère à une variable, il faut écrire notre chaine de caractère entre ‘’ ou entre “”.

Exemple de typage des variables :

$toto = 12;
var_dump($toto);// int(12)
$toto = '12';
var_dump($toto);// string(2) "12"

Il existe également des constantes, des constantes magiques en php qui sont des variables prédéfinies (pour savoir par exemple le dossier en cours), des variables d’environnement stockées dans la variable $_SERVER[‘nomDeLaVariable’] et les tableaux $_POST et $_GET qui sont réservés pour les variables transmises par le protocole http.

En PHP, le nom d’une variable doit être explicite pour la compréhension du code : inutile d’appeler un entier $nombre1, il vaut mieux dire ce que ce nombre décrit, par exemple $vitesseDuVehicule. On peut écrire en camelCase, StudlyCaps ou snake_case le nom des variables, le tout étant de se tenir à ce que l’on a choisi.

Exemple :

$monNombre = 0;
$res = maFonction($nombre1, $nombre2);
$res = function(int $nombre1, int $nombre2) : int
{
   return $nombre1 + $nombre2;
};

Note :

Il est également possible de créer des noms de variables variables avec le double $$. Ces noms de variables variables servent dans des situations où nous ne pouvons pas connaître à l’avance le nom des variables mais où nous devons les utiliser. Par exemple, j’ai un formulaire et un script PHP qui va traiter les données de ce formulaire mais sans connaître à l’avance les variables utilisées. Je peux stocker dans un tableau (array) les noms des variables et créer des variables à noms variables pour les utiliser plus tard. Néanmoins, cela sert à une utilisation plus avancée du langage et on peut souvent s’en sortir autrement, par exemple en stockant les données dans une structure comme un tableau de données.

Exemple :

$foo = "ab";
$bar = 5;

$$foo = $bar;

var_dump($ab); // int(5)

Dans cet exemple, la variable $$foo appelle en fait une variable du nom de $ab (elle stock la chaîne “ab” pour l’utiliser ensuite comme nom de variable). $ab vaut donc 5.

Les constantes

Les constantes sont des variables qui ne peuvent pas être modifiées (sauf dans le cas des constantes magiques). Elles sont déclarées avec le mot-clé define("NOM_DE_CONSTANTE", valeur). Par convention, le nom des constantes est écrit en majuscules. La valeur peut-être de tout type natif, même un tableau (depuis php7), mais il est très fortement déconseillé de déclarer une ressource constante.

Contrairement aux variables classiques, les noms des constantes ne sont pas précédés de "$". De plus, la portée des constantes est globales : elles peuvent donc être déclarées dans le corps d'une fonction et utilisées en dehors.

Déclarer et utiliser une constante :

define("PI", 3.14);
echo PI; // 3.14

Fonctions utiles des constantes :

  • defined("NOM_DE_CONSTANTE") : Vérifie l'existence d'une constante
  • constant("NOM_DE_CONSTANTE") : Retourne la valeur d'une constante

Le cast

Il est possible de changer le type d’une variable en utilisant un cast, c’est à dire un transtypage. Nous avons vu précédemment que 1 est un int et qu’habituellement “toto” est une chaîne de caractères. Mais parfois, nous voulons que PHP interprète comme chaîne de caractères un nombre, ou comme nombre une chaîne de caractères (ou un autre type, peu importe). Dans le cas où nous voulons le faire, nous pouvons utiliser les fonctions ou opérateurs de cast pour préciser à PHP que nous changeons le type de la variable.

Exemple :

Je demande l’âge de trois personnes par email et je stock leur réponse en chaînes de caractères. Les réponses sont les suivantes :

$joe = 'J\'ai 26 ans';
$avrell = 'J\'ai 32 ans';
$jack = 'J\'ai 14 ans';

J’ai donc trois chaînes de caractères mais on me demande de faire la moyenne des âges des individus. Pour l’instant, je pourrais faire cela facilement, mais plus tard, nous voudrons demander à des centaines de personnes et il faut automatiser le processus. Heureusement, je sais récupérer automatiquement des nombres dans une chaîne de caractères en PHP (il existe beaucoup de manières de le faire, en voici une).

$ageJoe = filter_var($joe, FILTER_SANITIZE_NUMBER_INT);
$ageAvrell = filter_var($avrell, FILTER_SANITIZE_NUMBER_INT);
$ageJack = filter_var($jack, FILTER_SANITIZE_NUMBER_INT);

var_dump($ageJoe, $ageAvrell, $ageJack); // affiche : string(2) "26" string(2) "32" string(2) "14"

Néanmoins, comme je peux le voir, les âges sont récupérés en chaînes de caractères et pour faire mes moyennes il me faut des nombres car il est impossible d’effectuer des calculs sur des chaînes !

Il me suffit alors d’utiliser l’opérateur de cast (int) avant d’utiliser mes variables ou de transtyper avec la méthode intval() (si on avait voulu transtyper en string on aurait utilisé (string) et strval(), en float (float) et floatval() etc…).

$moyenne = ((int)$ageJoe + intval($ageAvrell) + (int)$ageJack)/3;
var_dump($moyenne); // affiche int(24)

Mes variables sont au moment où je les utilise, interprétées comme des entiers par PHP qui peut alors effectuer des calculs arithmétiques dessus. Notez que nous utilisons ici deux opérateurs arithmétiques : l’addition et la division. Ces opérateurs sont primordiaux pour faire des calculs.

Les opérateurs arithmétiques (servent à faire interagir des variables entre elles)

Les variables sont donc des données que nous stockons avec une étiquette pour pouvoir ensuite les utiliser. Une des utilisations possibles des variables est de stocker des nombres pour faire des calculs.

  • Identité : +$a (conversion de $a vers int ou float)
  • Négation : -$a (opposé de $a)
  • Addition : $a + $b (somme de $a et $b)
  • Soustraction : $a - $b (différence de $a et $b)
  • Multiplication : $a * $b (produit de $a et $b)
  • Division : $a / $b (quotient de $a et $b)
  • Modulo : $a % $b (reste de la division euclidienne de $a par $b)
  • Exponentielle : $a ** $b (élévation de $a à la puissance $b)

Opérateur de concaténation

La concaténation signifie l’ajout d’une variable après une autre, par exemple si j’ai une variable qui vaut 12 et que je veux m’en servir dans une phrase pour dire que j’ai 12 ans, il faudra que je concatène “j’ai “ puis 12 puis “ans”. Même si PHP accepte la concaténation d’une chaîne de caractères et d’un entier par exemple, il est tout de même conseillé de transformer l’entier en chaîne (avec le cast, comme vu précédemment) pour le concaténer.

  • Concaténation: $var1 . $var2

Exemple :

echo 'J\'ai ' . strval(12) . 'ans.';

Notez que dans cet exemple on utilise echo pour afficher à l’écran, et qu’on utilise l’antislash (), qui est un caractère d’échappement pour signifier au PHP que l’apostrophe dans ce cas fait partie de la chaîne de caractère.

Les opérateurs d’affectations

  • $a = valeur (a=valeur)
  • $a += valeur (a = a +valeur)
  • $a .= “chaîne” (a = a . “chaîne”)
  • $a -= valeur (a = a - valeur)
  • $a *= valeur (a = a * valeur)
  • $a /= valeur (a = a / valeur)
  • $a++ (a = a + 1)
  • $a-- (a = a - 1)