Création d'un site web en PHP et MySQL : Travailler avec des variables
Déclarer une variable
Une variable commence par un dollar « $ » suivi d'un nom de variable. Les variables ne sont pas typées au moment de leur création. Attention PHP est sensible à la casse : var et Var ne sont pas les mêmes variables! Voici les règles à respecter :
- Une variable peut commencer par une lettre
- Une variable peut commencer par un souligné(underscore) « _ »
- Une variable ne doit pas commencer par un chiffre.
Exemple de déclaration :
<?php
// Déclaration et règles
$var=1; // $var est à 1
$Var=2; // $Var est à 2
$_toto='Salut'; // Ok
$3petitscochons=5; // Invalide : commence par un chiffre
?>
Leur type dépend de leur valeur et de leur contexte d'utilisation. Mais on peut forcer (cast) ponctuellement une variable à un type de données, ce qui s'appelle le transtypage. De même comme le type de variable peut changer en fonction de son utilisation ou du contexte, PHP effectue
automatiquement un transtypage, ce qui peut parfois fournir des résultats surprenants. On affecte une valeur à une variable avec le signe égal «=» avec ou sans espace avant ou après.
<?php
// Déclaration et transtypage
$var='2'; // Une chaîne 2
$var+=1; // $var est maintenant un entier 3
$var=$var+0.3; // $var est maintenant un réel de type double 3.3
$var=5+ "3 petits cochons"; // $var est un entier qui vaut 8
?>
Par défaut les variables sont assignées par valeur : la valeur assignée à la variable est recopiée dans la variable. PHP peut aussi travailler par référence. Une variable peut donc référencer une autre variable. On dit alors que la variable devient un alias, ou pointe sur une autre variable. On assigne
par référence en utilisant le signe « & » devant la variable assignée
<?php
$var=2;
$ref=&$var; // $ref devient une référence de $var
echo $ref; // affiche 2
$var=3;
echo $ref; // affiche 3
$ref=4;
echo $var; // affiche 4
?>
Attention à la valeur constante NULL insensible à la casse. Affecter une valeur NULL à une variable signifie ne pas puis affecter de valeur.
Portée des variables
La portée d'une variable dépend du contexte. Une variable déclarée dans un script et hors d'une fonction est globale mais par défaut sa portée est limitée au script courant, ainsi qu'au code éventuellement inclus (include, require) et n'est pas accessible dans les fonctions ou d'autres scripts.
<?php
$a=1; // globale par défaut
function foo() {
echo $a; // c'est une variable locale à la fonction : n'affiche rien
}
?>
Pour accéder àunevariableglobaledansunefonction,ilfaututiliserlemot-clé global
<?php
$a=1; // globale par défaut
$b=2; // idem
function foo() {
global $a,$b; // on récupère les variables globales
$b=$a+$b;
}
echo $b; // affiche 3
?>
PHP accepte les variables statiques. Comme en C une variable statique ne perd pas sa valeur quand on sort d'une fonction.
<?php
function test_static() {
static $a=0;
echo $a; // +1 à chaque passage dans la fonction
$a++;
}
?>
Les variables prédéfinies
PHP dispose d'un grand nombre de variables prédéfinies. Ces variables sont généralement de type scalaires ou des tableaux. Elles sont souvent de type superglobales, c'est à dire accessible depuis n'importe où sans notion de portée. Voici quelques tableaux prédéfinis (voir au point Tableaux pour
comprendre leur utilisation).
- $_GLOBALS: tableau des variables globales.La clé est le nom de la variable.
- $_SERVER: variables fournies par le serveur web, par exemple 'SERVER_NAME'
- $_GET: variables fournies par HTTP par la méthode GET(formulaires)
- $_POST: idem que $_GET mais pour la méthode POST
- $_COOKIE: les variables fournies par un cookie
- $_FILES: variables sur le téléchargement d'un fichier (upload)
- $_ENV: accès aux variables d'environnement du serveur
- $_SESSION: les variables de session
Les variables dynamiques
Une variable dynamique utilise la valeur d'une variable comme nom d'une autre variable. On utilise les variables dynamiques en rajoutant un «$» devant le nom de la première variable.
<?php
$a="var";
$$a=1; // $$a=1 equivaut en fait à $var=1
echo $a; // affiche var
echo $$a; // affiche 1
echo $var; // affiche 1
?>
Attention avec les tableaux! Pour éviter toute ambiguïté, il est préférable de placer la variable entre accolades.
Les types de variables
-
booléens
Un booléen peut prendre deux valeurs TRUE ou FALSE. Les deux constantes TRUE et FALSE peuvent être utilisées sans aucune distinction de casse (pas de différences entre les majuscules et les minuscules).
<?php
$var=FALSE; // FALSE, False, false, ...
$var2=True; // TRUE, True, true, ...
?>
Tous les types peuvent être convertis en booléens. Voici les cas où une variable retournera FALSE en booléen suivant le type:
• Booléen :FALSE
• Entier :0 (zéro)
• Nombre flottant:0.0 (zéro)
• Chaîne:chaîne vide "" ou "0"(zéro)
• Tableau :tableau vide sans aucun élément
• Objet:objet vide sans aucun élément
• Constante spéciale NULL
Dans tous les autres cas, la valeur retournée est TRUE. Attention : -1 est considéré comme vrai donc TRUE. Comme en C, les tests de conditions dans les structures de contrôles effectuent une convertion booléenne de la condition.
<?php
if($var==true)
echo "ok";
if($var)
echo "ok"; // Identique
?>
-
Entiers
Un entier est l'ensemble des nombres naturels, c'est à dire sans virgule, positifs ou négatifs. Les entiers sont généralement codés sur 32 bits mais cela dépend de l'architecture. Si on affecte un nombre entier qui dépasse la capacité de la variable, celle-ci sera transformée en réel (float). Enfin il n'y a pas de notion d'entier non signé. Lors de la conversion d'un booléen en entier, FALSE devient 0 et TRUE devient 1. Lors de la conversion d'un nombre à virgule flottante, le nombre sera arrondi à la valeur inférieure s'il est positif, ou supérieure s'il est négatif (conversion vers zéro). Pour la conversion depuis les chaînes, voir à ce type.
-
flottants ou réels
On parte ici des nombres réels, double ou float, c'est à dire les nombres à virgules. La virgule est spécifiée par le point« . ». La puissance de 10 s'exprime avec le « e » ou le « E »
<?php
$var=1.234;
$var2=1.1e4; // 1.1 * 10^4 : 11000
?>
-
Chaînes de caractères
Une chaîne est une séquence de caractères. PHP travaille en ASCII soit 256 caractères, mais ne supporte pas encore le format Unicode, prévu dans la version 5. Il n'y a pas de limite théorique pour la taille de la chaîne. On distingue trois syntaxes pour utiliser une chaîne
- Les guillemets simples '...' (apostrophes) : Comme en shell, tous les caractères inclus dans la chaîne sont sortis tels quels sans interprétation. Si vous devez afficher un guillemet simple, il faudra l'échapper :\'
- Les guillemets doubles "..." : Certaines séquences de caractères sont interprétées et les variables sont substituées(remplacées par leur valeur).
- HereDoc : Identique aux HereScripts en Shell. Le texte saisi jusqu'à un délimiteur spécifié est placé dans la variable.
Voici une liste issu de la documentation PHP des séquences pouvant être utilisés avec les guillemets doubles.
\n Nouvelle ligne(linefeed, LFou 0x0A(10) en ASCII)
\r Retour à la ligne(carriage return, CRou 0x0D(13) en ASCII)
\t Tabulation horizontale(HTou 0x09(9) en ASCII)
\\ Antislash
\$ Caractère $
\" Guillemets doubles
\[0-7]{1,3} Une séquence de caractères qui permet de rechercher un nombre en notation octale.
\x[0-9A-Faf]{1,2} Une séquence de caractères qui permet de rechercher un nombre en notation hexadécimale.
<?php
echo 'Attention l\'abus d\'alcool est dangereux';
$var=2345;
echo "la valeur de \$var est $var\n";
$toto= <<<FIN
Salut les amis
Comment ça va ?
FIN;
echo $toto;
?>
N'importe quelle variable peut être affichée dans une chaîne comme ci-dessus mais attention si deux variables ont un nom proche ! Il faut alors utiliser les accolades { } comme en shell. Enfin on peut accéder à n'importe quel caractère dans une chaîne en indiquant sa position (qui commence à zéro) entre deux accolades collées juste après le nom de la variable.
<?php
$fic='toto.fic';
$fics='riri fifi loulou';
echo "$fics ${fic}s"; // affiche riri fifi loulou toto.fics
echo "$fic{3}"; // affiche o
?>
On peut facilement concaténer deux chaînes avec l'opérateur point « . ». On peut ajouter du texte à une chaîne avec l'opérateur point égal « .= »
<?php
$str="Salut les Amis !\n";
$str.="Comment ça va ?"; // "Salut les Amis !\nComment ça va ?
$str2=$str."\n"; // "Salut les Amis !\nComment ça va ?\n
?>
Si vous devez utiliser une chaîne de caractères comme valeur numérique (dans une addition par exemple, attention à son contenu. La chaîne sera de type double (réel) si elle contient un 'e' ou un 'E'. Sinon ce sera un entier. La valeur numérique est ensuite définie par le début de la chaîne. Si la chaîne commence par une valeur numérique, elle sera utilisée, sinon elle sera égale à 0 zéro. Si la première expression est une chaîne,le type de variable dépend de la seconde expression.
<?php
$val=10+"2.55"; // float, 12.55
$val=1+"toto2"; // 1 + 0 = 1
$val=2+"3 petits cochons"; /* 2 + 3 = 5
(le 3 est en premier dans la chaîne)
*/
?>
-
Les tableaux
Un tableau PHP est une association ordonnée. Une association fait correspondre des valeurs à des clés. Les tableaux sont très souples, ils peuvent avoir de multiples dimensions, être indexés par une clé numérique ou texte, être utilisés comme table de hachage, une pile, une queue, ... Une valeur de tableau peut être elle-même un tableau, pour créer des arbres par exemple. Un tableau est créé avec la fonction array() qui prend comme arguments des paires « key => value » séparées par des virgules. La clé peut être soit un entier soit du texte. Attention, 8 est un entier, 08 une chaîne ! Si la clé est absente alors c'est la dernière clé entière plus 1 qui est choisie. Si c'est la première, c'est 0 zéro.
On accède aux éléments d'un tableau à l'aide des crochets « [ et ] ». On place entre ces crochets la clé entière ou la chaîne.
<?php
$var=array(10,15,17,23,9);
echo $var[0]; // 10
echo $var[3]; // 17
$tab=array("a"=>12,"nom"=>"toto","pipo",17,4=>5);
echo $tab[0]; // pipo
echo $tab[1]; // 17
echo $tab['a']; // 12
echo $tab['nom']; // toto
?>
L'utilisation de la fonction array n'est pas obligatoire et on peut déclarer un tableau à la volée.
<?php
$tab2[1]=2;
$tab2[]=6; // equivaut $tab2[2]=6
$tab2['test']='Ma chaîne';
?>
On peut aussi créer des tableaux multidimensionnels à l'aide des deux méthodes précédentes.
<?php
$tab=array(
"un"=>array("riri",1=>"fifi",2=>'loulou'),
2=>array(1,2,3),
array('un','deux','trois')
);
echo $tab['un'][0]; // riri
echo $tab[2][1]; // 2
echo $tab[3][2]; // trois
$tab2['un']['deux']='test';// créé un tableau à deux dimensions
?>
Il existe une fonction très pratique pour lister le contenu d'un tableau, ou pour modifier les éléments : foreach()
<?php
$tab=array(1=>'un',2=>'deux',3=>'trois');
foreach($tab as $valeur) {
echo"$valeur\n"; // affiche un deux trois
}
foreach($tab as $cle=> $valeur) {
echo "$cle=> $valeur\n"; // affiche 1 => un, 2 => deux, 3 => trois
}
?>
-
La variable objet
Les objets se créent avec l'instruction class. Pour créer une instace de l'objet il faut utiliser le mot clé new.
<?php
class test{
function affiche_hello(){
echo "Hello !";
}
}
$obj=new test();
$obj->affiche_hello();
?>
Les constantes
Les constantes est un nom qui prend une valeur ne pouvant pas être modifiée une fois fixée. Une constante n'est accessible qu'en lecture seule. Elles sont sensibles à la casse et doivent par convention être écrites en majuscules.
On définit une constante avec la fonction define() et doit respecter certaines règles:
- une constante ne commence pas par un $
- une constante est accessible depuis n'importe quel endroit du code
- une constante ne peut pas être redéfinie
- une constante ne peut contenir d'un scalaire(entier, booléen, chaîne, double).
<?php
define(CONSTANTE,"valeur");
echo CONSTANTE; // affiche "valeur"
?>
Obtenir le type d'une variable
Pour obtenir le type d'une variable, on utilise la fonction « gettype » qui retourne une chaîne de texte indiquant le type. Mais attention rien ne garantit que le résultat soit le même d'une version PHP à une autre.
Les types retournés sont "boolean", "integer", "double" (pour des raisons historiques, "double" est retournée lorsqu'une valeur de type float est fournie, au lieu de la chaîne "float"), "string", "array", "object", "resource"(depuis PHP4), "NULL"(depuis PHP4), "unknown type" Si vous souhaitez réellement tester le type d'une variable, il est préférable d'utiliser les fonctions de type « is_* » : is_array, is_bool, is_double, is_float, is_int, is_integer, is_long, is_null, is_numeric, is_object, is_real,is_resource, is_string,is_callable(est-ce une fonction).
Définir et supprimer une variable
Si vous souhaitez savoir si une variable est définie, c'est à dire si elle est affectée, on utilise « isset ». Enfin si vous souhaitez supprimer une variable, il faut utiliser « unset ».