Les variables

Déclaration des variables

Rappelons que les variables sont des zones mémoires où l'on stocke des valeurs temporaires.

En PHP, il n'est pas nécessaire de déclarer au préalable les variables qui seront utilisées, ni de préciser leur type qui est défini par défaut et de façon transparente par PHP en fonction de leur valeur.
Ainsi, PHP est un langage dit de "typage faible et dynamique", dynamique car le type de la variable évolue en fonction de la valeur que vous lui assignez.

En PHP, tous les noms de variable commencent obligatoirement par le signe $.
L'affectation d'une valeur à une variable s'effectue par le signe = (attention la comparaison s'effectue avec ==).

Exemples d'affectations de valeurs à différents types de variables :

<?php
$titre_article = "Global Land Cover une image exceptionnelle de la végétation mondiale";
$nb_lectures = 139;
$date_ecriture = "03/12/2003";
$date_actuelle = date("d/m/y");
$auteur = "Christophe";
$source = "Commission européenne";
$lien = "<a href=\"http://www.notre-planete.info/actualites/actu_272.php\" target=\"_blank\">";
$note = $nb_lectures / 10;
$commentaire = $_POST['comment'];
?>

La portée des variables

Toute variable qui n'est pas déclarée au sein d'une fonction a une portée par défaut qui s'étend au script, c'est à dire qu'elle conserve sa valeur tout au long de la page uniquement.

Remarques sur les noms de variables

• ils sont obligatoirement des chaînes de caractères non numériques et des variables non réservées
• les caractères de ponctuation (. , ; ...) et le caractère - ne sont pas acceptés
• éviter les caractères accentués
• bannir les espaces
• le premier caractère ne peut être un chiffre
• préférer les noms explicites
• Attention ! PHP est sensible à la casse

Les principaux types de variables

PHP supporte trois grands types primitifs de données :

Type	en français	Plage de valeurs	Exemple
integer	entier	-2 147 483 648 à + 2 147 483 647	$var = 12;
double	réel	1.7E-308 à 1.7E+308	$var = 3.1415957
string	chaîne de caractères	caractère alphanumérique	$var = "bienvenue"

Rappel : PHP ne requiert pas de déclaration préalable des types de variables qui seront utilisées. Le type est défini par PHP en fonction de la valeur de la variable.
Notons que la présence de l'opérateur "+" convertit automatiquement le type en numérique.
Les exemples suivants nous montrent comment les types sont assignés :

<?php
$var = "0"; //$var est une chaîne de caractères (code ASCII 48)
echo var_dump ($var).'<br />';
$var = $var + 1; //$var est un entier et vaut 2
echo var_dump ($var).'<br />';
$var += 1.3; //$var est de type "double" et vaut 3.3
echo var_dump ($var).'<br />';
$var = 2 + "8 arbres"; //$var est de type "integer" et vaut 10
echo var_dump ($var);
?>

Ce qui se vérifie en exécutant le code :

string(1) "0"
int(1)
float(2.3)
int(10)

Vous l'aurez compris, la fonction var_dump() permet, en cas de coute, de connaître le type et la valeur d'une variable : indispensable pour débuguer.

Il est possible de "typer" et de connaître le type d'une variable qui a été défini grâce aux fonctions gettype() et settype().

le type booléen

Il n'existe pas en PHP de type booléen pour créer une variable qui n'aurait que pour valeur "vrai" ou "faux". Cependant, les valeurs TRUE et FALSE (ou respectivement tout nombre différent de 1 et 0) peuvent être utilisées dans le cadre d'une variable numérique.

A noter

• -1 est considéré comme TRUE, comme tous les nombres différents de zéro (négatifs ou positifs) !
• Certaines fonctions retournent false ou true si elles se sont correctement exécutées et on peut donc les tester...

gettype() et settype()

<?php
if (gettype($age) != "integer") {
    settype ($age,"integer"); // ou encore $age = (int) $age;
}
echo "Vous avez $age ans !";
?>

Les valeurs renvoyées par gettype() sont :
"integer", "double", "string", "array" (pour les tableaux), "object" (pour les objets), "class" (pour les classes) et "unknown type" pour un type inconnu...

Tester le type de la variable

Des fonctions permettent également de tester le type de la variable. Elles renvoient VRAI (ou 1) si le type est celui attendu.

is_int(), is_integer(), is_long() renverront VRAI si le type est entier
is_double(), is_float(), is_real() renverront VRAI si le type est double (réel)
is_string(), is_array(), is_object() renverront respectivement VRAI si le type est string, array ou object

Les constantes

Une constance est une référence à une valeur qui ne change pas et qui ne peut être par la suite modifiée.
Les sciences "dures" ont ainsi défini un certain nombre de constantes comme pi (environ 3,14), le zéro absolu (-273,15°C) ou la vitesse de la lumière (300 000 km/s environ). Les sciences sociales également d'ailleurs : taux de chômage en France (8%), personnes n'ayant pas accès à l'eau potable (1,5 milliard)... Voir pour exemple d'autres constantes sur la Terre
Il peut-être utile, dans un site, de définir une constante pour une valeur qui se trouve répétée un certain nombre de fois. Comme par exemple la dénomination de la société éditrice du site, du titre du site ou de son auteur si ces informations sont récurrentes.
Sur le portail notre-planete.info, le titre "notre-planete.info" est répété sur un grand nombre de pages. C'est pourquoi une constante a été définie comme suit :

<?php
define ("SITE", "<strong><font color=\"#00216a\">notre-planete.info</font></strong>"); // titre du site
define ("NA", 21500); // nombre d'abonnés à la newsletter
?>

On remarquera la présence du caractère "\" pour despécialiser les guillemets afin qu'ils ne soient pas interprétés par PHP tout en étant présents pour un code HTML propre. Toutes les constantes sont en majuscule pour s'y retrouver.
Les constantes sont ensuite appelées de cette façon :

<?php
echo SITE;
echo "<br />mon site s'appelle ".SITE." et ".NA." personnes en suivent
l'actualité via la lettre d'information, et vous ?";
?>

Nous noterons dans son appel qu'il faut respecter sa casse, ne pas indiquer le $ propre aux variables et que la commande echo se passe de guillemets si la constante est appelée sans autre chaîne de caractères.
Ce qui donnera donc :

notre-planete.info
mon site s'appelle notre-planete.info et 21000 personnes en suivent l'actualité via la lettre d'information, et vous ?

On peut enfin vérifier la présence d'une constante avec la fonction defined() qui renvoie 1 si cette première a été déclarée et 0 dans le cas contraire :

<?php
if (defined("SITE")) {
    echo SITE;
}
?>

Les constantes internes

Par défaut, PHP comprend un certain nombre de constantes utiles au développeur comme :

<?php
echo PHP_OS; // affichera le système d'exploitation du serveur web
echo '<br />';
echo PHP_VERSION; // affichera le n° de version de PHP
?>

Par exemple sur notre serveur nous avons :

Linux
5.3.8-pl0-gentoo

Une liste des constantes relatives à l'environnement dans lequel s'exécute PHP sont disponibles grâce à la fonction phpinfo().
Cette fonction est particulièrement utile pour connaître l'environnement de travail mais les informations qu'elle fournit permet également à des personnes malintentionnées d'en savoir trop...

Les chaînes de caractères

L'interprétation des variables

Nous avons déjà utilisé la commande echo pour retourner la valeur d'une variable en affichant son contenu. En effet, la commande echo permet d'interpréter une variable pour en afficher la valeur comme en témoignent les exemples suivants :

<?php
$annee_actu = "2003";
echo "Année : $annee_actu<br />";
echo 'Année : $annee_actu<br />';
echo 'Année : '.$annee_actu.'<br />';
echo 'Année n + 2 = '.($annee_actu + 2).'<br />';
echo "La variable \$annee_actu vaut $annee_actu";
// l'emploi du \ est indispensable pour despécialiser
?>

Résultat :

Année : 2003
Année : $annee_actu
Année : 2003
Année n + 2 = 2005
La variable $annee_actu vaut 2003

Nous remarquerons que :

1. la variable peut s'insérer dans du texte délimité par des guillemets, elle est alors interprétée
2. l'utilisation de l'apostrophe à la place des guillemets ne permet pas l'interprétation
3. il est possible d'afficher tout caractère normalement interprété en le déspécialisant via un antislash "\"
4. la commande echo peut afficher des résultats d'opérations, mais dans ce cas, celles-ci doivent impérativement être entre parenthèses.

Afin de simplifier l'écriture et la compréhension du code, nous conseillons l'usage des guillemets simples avec la commande echo, la despécialisation des guillemets doubles utilisés largement en HTML n'est plus alors nécessaire.

Quelques fonctions usuelles

Il existe de nombreuses fonctions qui permettent d'exploiter les chaînes de caractères, pour les scinder, en extraire des parties, les préparer pour l'intégration dans une base de données.

Voici les principales :

Fonction	Signification	Exemple
strlen()	renvoie le nombre de caractères contenus dans la chaîne	$nbcar = strlen($var);
substr()	extrait un nombre de caractères d'une chaîne à partir d'une position	$extrait = substr($var,$pos,$nb);
trim()	supprime les espaces avant et après la chaîne	$var = trim($var);
addslashes()	despécialise les caractères apostrophe ('), double apostrophe (") et le slashe (\) pour les bases de données.	$varbd = addslashes($var);
explode()	renvoie dans un tableau les valeurs comprises entre un séparateur	$tableau = explode($delimiteur,$var);

On pourra consulter utilement toutes les fonctions documentées sur les chaînes de caractères et pour aller plus loin les expressions régulières.

Les tableaux

PHP gère deux types de tableaux, ceux à indices numériques (indexés), ce qui est classique et ceux dits associatifs.
Notons qu'il n'est pas obligatoire de déclarer la taille d'un tableau en PHP.

Les tableaux à indices numériques

<?php
$mois[1] = "janvier";
$mois[2] = "février";
$mois[3] = "mars";
$mois[] = "avril"; // l'indice 4 a été automatiquement affecté
?>

Rappelons que les tableaux servent à stocker des valeurs multiples dans une même variable.
Pour manipuler ces différentes valeurs, on leur affecte un indice numérique entier noté entre crochets. L'exploitation d'un tableau est rendue possible via les boucles.
Les tableaux sont notamment utilisés dans l'accès aux données d'une table issue d'une base de données.
En cas d'indice alloué automatiquement, il s'agit de l'indice le plus élevé déjà déclaré plus 1.

echo $mois[4];

Résultat :

avril

Les chaînes de caractères sont considérées comme des tableaux, c'est à dire que chaque caractère qui forme la chaîne est un élément du tableau avec un indice qui commence à 0 et s'incrémente de 1 pour chaque caractère à droite du premier. Ce qui est classique et utile.

<?php
$site = "notre-planete.info";
// attention ! l'indice de la première lettre est 0
echo "$site[4]<br />";
echo "$site[0]<br />";
?>

Résultat :

e
n

La fonction array permet aussi de déclarer et remplir un tableau comme suit :

<?php
$mois = array("janvier","février","mars","avril");
echo $mois[1];
?>

Résultat :

février

Nous noterons sur cet exemple, qu'aucun indice n'a été nécessaire, l'indexation est automatique, débute à 0 et s'incrémente de 1 pour chaque nouvelle valeur déclarée.

On peut bien sûr imaginer des tableaux à plusieurs dimensions comme dans un jeu de morpion (un passe temps classique en cours) avec deux indices (donc deux dimensions) pour chaque case correspondant au croisement de la colonne x (1er indice ici) avec la ligne y (2ème indice ici) :

<?php
$case[1][1] = "vide";
$case[1][2] = "rond";
$case[1][3] = "croix";
$case[2][1] = "rond";
$case[2][2] = "croix";
$case[2][3] = "vide";
$case[3][1] = "croix";
$case[3][2] = "rond";
$case[3][3] = "vide";
echo "la case 3,1 contient : ".$case[3][1]."<br />";
echo "la case 3,1 contient : $case[3][1]<br />";
echo "la case 3,1 contient : {$case[3][1]}<br />";
?>

Résultat :

la case 3,1 contient : croix
la case 3,1 contient : Array[1]
la case 3,1 contient : croix

Nous noterons ici que l'interprétation ne fonctionne pas avec deux indices sauf si on place la variable a interpréter entre accolades. On peut, bien sûr, concaténer la valeur de la variable au texte.

Afficher simplement les éléments d'un tableau

La fonction print_r() est utile pour débugger lorsque l'on souhaite vérifier si notre tableau est rempli correctement. Il suffit de l'appeler comme ceci :

<?php
print_r($case);
?>

Ce qui nous afficherait dans le cas de notre précédent tableau :

Array ( [1] => Array ( [1] => vide [2] => rond [3] => croix ) [2] => Array ( [1] => rond [2] => croix [3] => vide ) [3] => Array ( [1] => croix [2] => rond [3] => vide ) )

le nombre d'éléments d'un tableau

La fonction count() retourne le nombre d'éléments contenus dans un tableau. Ce qui peut être utile pour créer une boucle de lecture de ses éléments. En effet, ainsi nous pouvons spécifier combien d'éléments il faut parcourir.

<?php
$mois[0] = "janvier";
$mois[1] = "février";
$mois[2] = "mars";
$mois[3] = "avril";
$nb = count($mois);
echo "$nb mois ont été renseignés";
?>

Résultat :

4 mois ont été renseignés

Les tableaux associatifs

La différence provient de l'indice qui n'est plus un nombre mais une chaîne de caractères, ce qui est particulièrement intéressant pour "s'y retrouver".
Exemple :

<?php
$tableau['pays'] = "Etats-Unis";
$tableau['CO2'] = "20";
$tableau['Kyoto'] = "non";
?>

Nous pouvons ensuite interroger ce tableau de la façon suivante :

<?php
echo 'un habitant du pays '.$tableau['pays'].' (ratification de Kyoto : '.$tableau['kyoto'].')
émet en moyenne '.$tableau['CO2'].' tonnes de Co2 par an';
?>

Ce qui aura pour résultat :

un habitant du pays Etats-Unis (ratification de Kyoto : non) émet en moyenne 20 tonnes de Co2 par an

De plus, indices numériques et associatifs peuvent être utilisés en même temps :

<?php
$tableau[0]['pays'] = "Etats-Unis";
$tableau[0]['CO2'] = 20;
$tableau[0]['Kyoto'] = "non";
$tableau[1]['pays'] = "France";
$tableau[1]['CO2'] = 6;
$tableau[1]['Kyoto'] = "oui";

echo 'un habitant du pays '.$tableau[0]['pays'].' (ratification de Kyoto : '.$tableau[0]['Kyoto'].')
émet en moyenne '.$tableau[0]['CO2'].' tonnes de Co2 par an<br /><br />';

echo 'un habitant du pays '.$tableau[1]['pays'].' (ratification de Kyoto : '.$tableau[1]['Kyoto'].')
émet en moyenne '.$tableau[1]['CO2'].' tonnes de Co2 par an';

// on aurait fait plus simplement, sans mélanger les types d'indice :
unset($tableau); // pour initialiser notre variable tableau déjà remplie

$tableau['France']['CO2'] = 6;
$tableau['France']['Kyoto'] = "oui";

$tableau['Etats-Unis']['CO2'] = 20;
$tableau['Etats-Unis']['Kyoto'] = "non";

echo 'un habitant du pays '.key($tableau).' (ratification de Kyoto : '.$tableau['France']['Kyoto'].')
émet en moyenne '.$tableau['France']['CO2'].' tonnes de Co2 par an<br /><br />';

next($tableau); // on avance le pointeur du tableau vers le pays suivant

echo 'un habitant du pays '.key($tableau).' (ratification de Kyoto : '.$tableau['Etats-Unis']['Kyoto'].')
émet en moyenne '.$tableau['Etats-Unis']['CO2'].' tonnes de Co2 par an';
?>

Résultat :

un habitant du pays Etats-Unis (ratification de Kyoto : non) émet en moyenne 20 tonnes de Co2 par an

un habitant du pays France (ratification de Kyoto : oui) émet en moyenne 6 tonnes de Co2 par an

un habitant du pays France (ratification de Kyoto : oui) émet en moyenne 6 tonnes de Co2 par an

un habitant du pays Etats-Unis (ratification de Kyoto : non) émet en moyenne 20 tonnes de Co2 par an

Tester les variables

Quelques fonctions nous permettent de vérifier qu'une variable possède une valeur ou au contraire, n'en a pas.

Fonction	Signification	Exemple
isset()	détermine si une variable possède une valeur	isset ($var)
unset()	détruit une variable, libérant la mémoire qu'elle occupe	unset ($var)
empty()	vérifie si une variable n'est pas définie, vide ("") ou égale à 0	empty ($var)

Ces fonctions sont notamment utilisées dans l'exploitation des formulaires HTML ou la sécurisation des scripts.