Programmation PHP/Variables

Premier programme

Variables superglobales

Programmation PHP

Introduction
Installer PHP
Composer
IDE
Bases du langage
Programmation avancée
Apprendre par l'exemple
- AJAX
1. Sommaire en Ajax
2. Mise à jour périodique d'un cadre
- Mini CMS
Extensions PHP
- cURL
- DOMDocument
- JSON
- MING
- SPL
Bibliothèques externes
- ADODB
- DOMPDF
- FPDF
- PHPExcel
- PHPMailer
- PHPWord
- RabbitMQ
Cadriciels
- CakePHP
- PEAR
- Symfony
- Frameworks de tests
  - PHPUnit
  - SimpleTest
  - Behat
Logiciels métier
Problèmes connus

Version imprimable

[ Modifier le sommaire ]

Premier programme

Variables superglobales

Définition

En PHP, les variables sont représentées par un signe dollar "$" suivi du nom de la variable, ou d'un underscore "_" pour les constantes (un warning apparait quand ces dernières sont redéfinies).

Le nom est sensible à la casse (par exemple $MaVariable est différent de $mavariable). Dans tous les cas, les variables doivent commencer par une lettre (a-z, A-Z) :

     $1MaVariable // incorrect
     $MaVariable  // correct
     $_MaVariable // correct
     $àéè         // correct
     MA_CONSTANTE  // correct
     _MA_CONSTANTE  // correct

Exemple

  <?php
  // Initialisation des variables
  $Prenom = 'Romuald';
  $Age    = '23 ans';
  $Profession = 'informaticien';

  // Affichage
   echo 'Bonjour ' . $Prenom . ', tu as ' . $Age . ' et ta profession est ' . $Profession . '.';
  // Ce qui affichera sur votre navigateur : Bonjour Romuald, tu as 23 ans et ta profession est informaticien.

  // Une autre manière de faire
  echo "Bonjour $Prenom, tu as $Age et ta profession est $Profession";
  // Ce qui affichera sur votre navigateur : Bonjour Romuald, tu as 23 ans et ta profession est informaticien.

  // Subtilité des " et des '
  echo 'Bonjour $Prenom, tu as $Age et ta profession est $Profession';
  // Ce qui affichera sur votre navigateur : Bonjour $Prenom, tu as $Age et ta profession est $Profession
  // Le contenu d'une chaîne construite avec des " sera interprété par PHP et les variables
  // éventuellement utilisées seront remplacées par leurs valeurs.

Nota bene : une variable accolée à du texte est précédée d'un point. Ce dernier sert à la concaténation et dans le cas présent est surtout utile pour indiquer à l'interpréteur que l'on passe du texte, puis à une variable. On lui évite ainsi un temps de réflexion qu'il aurait si l'on avait écrit :

echo "Bonjour $Prenom, tu as $Age et ta profession est $Profession";

Pour citer du texte contenant uniquement des apostrophes ou des guillemets, on peut encadrer les uns par les autres :

echo 'Hello "World"!';

Pour citer du texte contenant les deux symboles, on peut utiliser le caractère d'échappement "\" :

echo 'Hello \'the\' "World" !';

Here document

Pour éviter de s'encombrer des caractères d'échappement, il existe aussi les syntaxes heredoc et nowdoc avec l'opérateur "<<<"^[1]. Ex :

$v = 1;

echo <<<Test
 'Hello' "World" \\ $v heredoc
Test;
// 'Hello' "World" \ 1 heredoc

echo <<<'Test'
 'Hello' "World" \\ $v nowdoc
Test;
// 'Hello' "World" \\ $v nowdoc

heredoc interprète similairement à une chaine entre guillemets et nowdoc entre apostrophes.

Le mot de fin ("Test" dans l'exemple) des syntaxes heredoc ne doit pas être indenté ni suivi d'autres caractères que le ";", dans les versions PHP antérieures à 7.3^[2].

Le délimiteur heredoc ou nowdoc permet de forcer une coloration syntaxique dans certains IDE comme PhpStorm ou vscode^[3]. Par exemple, echo <<<HTML a un rendu différent de echo <<<SQL.

Par défaut, on peut accéder aux propriétés et méthodes d'objets en heredoc. Ex :

$v1 = new stdClass();
$v1->name = "World";
$v2 = ['one', 'two'];
echo <<<Test
 Hello $v1->name $v2[1]
Test;

Mais si cela pose problème, utiliser les accolades pour forcer l'interpolation :

$v1 = new stdClass();
$v1->name = ['one', 'two'];
echo <<<Test
 Hello $v1->name[1]   // Hello Array[1]
 Hello {$v1->name[1]} // Hello two
Test;

Chaines binaires

A ne pas confondre avec les nombres binaires qui sont composés de 0 et de 1, les chaines binaires sont apparues en PHP 5.2.1 et indiquées avec le préfixe "b". Ex :

b'ma_chaine'

Elles se distinguent des autres chaines par leur encodage, qui ne permet pas à ses caractères non ASCII d'être affichés brutes. Par exemple, print(b'é'); donne : �.

On peut alors la convertir avec :

print(iconv('ISO-8859-1', 'UTF-8', b'é'));

Types de variables

Contrairement à de nombreux langages de programmation, en PHP il ne faut pas prédéclarer une variable mais celle-ci est typée lors de son instanciation.

$x = 1; // indique implicitement que $x est un entier
$mot = 'test'; // indique que $mot est une chaîne de caractères

En PHP il y a donc quatre types de variables scalaires :

entiers (integer) : nombres naturels sans décimale (sans virgule) ;
réels (float) : nombres décimaux (on parle généralement de type "double", car il s'agit de nombre décimaux à double précision). On peut y introduire des puissances de 10 avec la lettre "e" (ex : 2e1 = 20, 4e-3 = 0.004) ;
booléens (boolean) : deux valeurs possibles : 1 ou 0. Elles sont équivalentes aux mots réservés true ou false (en français, vrai ou faux) ;
chaînes de caractères (string) : ensembles de caractères (des phrases).

De plus, on trouve les types complexes :

tableaux (array) : listes d'éléments ordonnés.
objets (object) : classe instanciée.

Pratique sur les nombres flottant

Il faut toujours arrondir les nombres flottant à l'affichage, mais aussi lors des comparaisons^[4].

Exemple :

 $ php -r "var_dump(8 - 6.4 == 1.6);"
 bool(false)

 $ php -r "var_dump(round(8 - 6.4, 1) == 1.6);"
 bool(true)

Lors de la division de nombres à virgules flottantes, on peut facilement avoir une imprécision à cause du mode de leur stockage en mémoire :

echo PHP_VERSION.PHP_EOL;
var_dump(fmod(9999.00000, 9998.00001));

donne :

7.3.14
float(0.99999000000025)

Variables dynamiques

Il est pratique d'avoir parfois des noms de variables qui sont variables. C'est-à-dire un nom de variable qui est affecté et utilisé dynamiquement. La valeur MaVariable est affectée à une variable classique appelée a avec l'instruction suivante :

 <?php
    $a = "MaVariable";

Une variable dynamique, ou variable variable, utilise le nom d'une autre variable. Dans l'exemple ci-dessous, la valeur bonjour est affectée à la variable dynamique $$a, c'est-à-dire à une variable dont le nom est la valeur $a de la variable a. La variable classique a contient la valeur MaVariable donc le code :

 <?php
    $$a = "bonjour";

est équivalent à : $MaVariable="bonjour";

Attention : cette syntaxe est inutile pour les fonctions. Ex :

 <?php
    function direBonjour()
    {
        echo "Bonjour !";
    }

    $a = 'direBonjour';
    $a();

Dans le cas des tableaux variables, il faut préciser si l'index s'applique à la variable ou à la variable dynamique à l'aide d'accolades^[5] :

 <?php
    $a = ['Hello', 'World'];
    echo ${$a[0]}; // Undefined variable: Hello
    echo ${$a}[0]; // Array to string conversion

Variable de classe variable

Les variables de classe seront introduites en détails dans un chapitre ultérieur. Mais il faut savoir que leurs noms peuvent aussi être variables avec ces notations :

 echo $this->$myVariableName;
 echo $this->{'variable'.$i};
 echo self::$myStaticVariableName;
 echo constant(self::class.'::'.strtoupper($myConstantName));

Autres variables

Les variables présentées dans ce paragraphe sont des tableaux indicés par le nom de la valeur accédée (une chaîne de caractère).

Variables superglobales

Pour plus de détails voir : Programmation PHP/Variables superglobales.

Variables de sessions

Pour plus de détails voir : Programmation PHP/Sessions.

Lors de la création d'une session (session_start()), il est possible d'enregistrer des variables (par session_register('nom_variable') = $variable ). On peut aussi utiliser le tableau $_SESSION pour créer et modifier une variable de session (par exemple : $_SESSION['ma_variable'] = 3; )

Il est également possible de supprimer les sessions courantes dans le code PHP en utilisant la fonction session_destroy(). La destruction de la session en cours peut aussi se faire par la fermeture du navigateur.

Pour supprimer une variable de session sans supprimer la session entière, il suffit d'utiliser la fonction unset($_SESSION['ma_variable']).

Variables de cookie

Pour plus de détails voir : Programmation PHP/Cookies.

Le tableau $_COOKIE permet de gérer les cookies (définis avec setcookie()^[6]). Ces cookies sont d'une très grande importance mais sont limités à 20 dans la configuration par défaut de PHP.

Ne pas mettre d'informations privées (mots de passe du serveur...) dans ces variables car elles sont stockées dans un fichier non protégé, sur le disque dur de l'utilisateur.

Variables de requêtes

$_REQUEST est un tableau associatif constitué du contenu des variables $_GET, $_POST, $_COOKIE.

Variables de fichiers

Pour plus de détails voir : Programmation PHP/Fichiers.

Lors d'un téléchargement de fichiers vers le serveur, une variable est assignée aux données de ce fichier. Il s'agit de $_FILES. Elle permet de récupérer le nom du fichier envoyé (exemple : mon_image.png), le nom du fichier temporaire où PHP a copié les données et où il est donc possible de les lire (exemple: C:\temp\T0001AF7.tmp).

Exemple :

 $_FILES['nom_fichier']

Variables mixtes

Le mot clé mixed permet de définir une variable mixte.

Variables de serveurs

$_SERVER permet d'obtenir des renseignements sous forme d'un tableau sur le serveur.

'PHP_SELF': Le nom du fichier du script en cours d'exécution, par rapport à la racine web. Par exemple, $_SERVER['PHP_SELF'] dans le script situé à l'adresse http://www.monsite.com/test.php/foo.bar sera /test.php/foo.bar. La constante __FILE__ contient le chemin complet ainsi que le nom du fichier courant.
'argv': Tableau des arguments passées au script. Lorsque le script est appelé en ligne de commande, cela donne accès aux arguments, comme en langage C. Lorsque le script est appelé avec la méthode GET, ce tableau contiendra la chaîne de requête.
'argc': Contient le nombre de paramètres de la ligne de commande passés au script (si le script fonctionne en ligne de commande).
'GATEWAY_INTERFACE': Numéro de révision de l'interface CGI du serveur : i.e. ' CGI/1.1 '.
'SERVER_NAME': Le nom du serveur hôte qui exécute le script suivant. Si le script est exécuté sur un hôte virtuel, ce sera la valeur définie pour cet hôte virtuel.
'SERVER_SOFTWARE': Chaîne d'identification du serveur, qui est donnée dans les en-têtes lors de la réponse aux requêtes.
'SERVER_PROTOCOL': Nom et révision du protocole de communication : i.e. ' HTTP/1.0 ';
'REQUEST_METHOD': Méthode de requête utilisée pour accéder à la page; i.e. ' GET ', ' HEAD ', ' POST ', ' PUT '.
'REQUEST_TIME': Le temps Unix depuis le début de la requête. Disponible depuis PHP 5.1.0.
'QUERY_STRING': La chaîne de requête, si elle existe, qui est utilisée pour accéder à la page.
'DOCUMENT_ROOT': La racine sous laquelle le script courant est exécuté, comme défini dans la configuration du serveur.
'HTTP_ACCEPT': Contenu de l'en-tête Accept: de la requête courante, s'il y en a une.
'HTTP_ACCEPT_CHARSET': Contenu de l'en-tête Accept-Charset: de la requête courante, si elle existe. Par exemple : ' iso-8859-1,*,utf-8 '.
'HTTP_ACCEPT_ENCODING': Contenu de l'en-tête Accept-Encoding: de la requête courante, si elle existe. Par exemple : ' gzip '.
'HTTP_ACCEPT_LANGUAGE': Contenu de l'en-tête Accept-Language: de la requête courante, si elle existe. Par exemple : ' fr '.
'HTTP_CONNECTION': Contenu de l'en-tête Connection: de la requête courante, si elle existe. Par exemple : ' Keep-Alive '.
'HTTP_HOST': Contenu de l'en-tête Host: de la requête courante, si elle existe.
'HTTP_REFERER': L'adresse de la page (si elle existe) qui a conduit le client à la page courante. Cette valeur est affectée par le client, et tous les clients ne le font pas. Certains navigateur permettent même de modifier la valeur de HTTP_REFERER sous forme de fonctionnalité. En bref, ce n'est pas une valeur de confiance.
'HTTP_USER_AGENT': Contenu de l'en-tête User_Agent: de la requête courante, si elle existe. C'est une chaîne qui décrit le client HTML utilisé pour voir la page courante. Par exemple : Mozilla/4.5 [en] (X11; U; Linux 2.2.9 i586). Entre autres choses, vous pouvez utiliser cette valeur avec get_browser pour optimiser votre page en fonction des capacités du client.
'HTTP_header': Valeur de l'en-tête HTTP correspondant envoyé dans la requête du client.
'HTTPS': Définissez à une valeur non-vide si le script nécessite d'utiliser le protocole HTTPS.
'REMOTE_ADDR': L'adresse IP du client qui demande la page courante.
'REMOTE_HOST': Le nom de l'hôte qui lit le script courant. La résolution DNS inverse est basée sur la valeur de REMOTE_ADDR
'REMOTE_PORT': Le port utilisé par la machine cliente pour communiquer avec le serveur web.
'SCRIPT_FILENAME': Le chemin absolu vers le fichier contenant le script en cours d'exécution.
'SERVER_ADMIN': La valeur donnée à la directive SERVER_ADMIN (pour Apache), dans le fichier de configuration. Si le script est exécuté par un hôte virtuel, ce sera la valeur définie par l'hôte virtuel.
'SERVER_PORT': Le port de la machine serveur utilisé pour les communications. Par défaut, c'est '80'. En utilisant SSL, par exemple, il sera remplacé par le numéro de port HTTP sécurisé.
'SERVER_SIGNATURE': Chaîne contenant le numéro de version du serveur et le nom d'hôte virtuel, qui sont ajoutés aux pages générées par le serveur, si cette option est activée.
'PATH_TRANSLATED': Chemin dans le système de fichier (pas le document-root) jusqu'au script courant, une fois que le serveur a fait une traduction chemin virtuel -> réel.
'SCRIPT_NAME': Contient le nom du script courant. Cela sert lorsque les pages doivent s'appeler elles-mêmes. La constante __FILE__ contient le chemin complet ainsi que le nom du fichier (i.e. inclut) courant.
'REQUEST_URI': L'URI qui a été fourni pour accéder à cette page. Par exemple : ' /index.html '.
'PHP_AUTH_DIGEST': Lorsque vous utilisez PHP avec Apache en tant que module faisant une identification HTTP Digest cette variable est définie dans l'en-tête 'Authorization' envoyé par le client (que vous devez donc utiliser pour réaliser la validation appropriée).
'PHP_AUTH_USER': Lorsque vous utilisez PHP avec Apache ou IIS (ISAPI en PHP 5) en tant que module faisant une identification HTTP, cette variable est définie à l'utilisateur fourni par l'utilisateur.
'PHP_AUTH_PW': Lorsque vous utilisez PHP avec Apache ou IIS (ISAPI en PHP 5) en tant que module faisant une identification HTTP, cette variable est définie au mot de passe fourni par l'utilisateur.
'AUTH_TYPE': Lorsque vous utilisez PHP avec Apache en tant que module faisant une identification HTTP, cette variable est définie au type d'identification.

Détection du protocole

Pour déterminer si l'utilisateur se connecte en HTTP ou HTTPS à partir de la superglobale $_SERVER :

$_SERVER['REQUEST_SCHEME'] semble la meilleure option, car renvoie "http" ou "https".
$_SERVER['SERVER_PORT'] renvoie 80 ou 443.
$_SERVER['HTTPS'] donne true en HTTPS ou null en HTTP (provoque un warning unset).
$_SERVER['SERVER_PROTOCOL'] ne convient pas du tout car renvoie "HTTP/1.1" dans les deux cas.
$_SERVER['HTTP_X_FORWARDED_PROTO'] et $_SERVER['HTTP_FRONT_END_HTTPS'] : à creuser...

Si ces variables renvoient les caractéristiques HTTP en connexion HTTPS, c'est qu'il faut activer SSL pour le site.

Tester les types

Plusieurs fonctions permettent de déterminer les types des objets.

Soit une variable $v :

gettype($v) donne son type simple ("object" si c'est une instance de classe).
get_class($v) donne son type complexe si c'est une instance de classe.
is_null($v) teste si un objet est null. Équivaut à "=== null"^[7].
is_bool($v) est vrai si booléen.
is_numeric($v) est vrai si numérique.
is_int($v) est vrai si entier.
is_float($v) est vrai si décimal.
is_string($v) est vrai si chaine.
is_array($v) est vrai si tableau.
is_object($v) est vrai si objet.
$v instanceof MaClasse est vrai si l'objet est de type "MaClasse".

Conversions

En PHP, il n'y a pas de déclaration de variable selon un type figé. Pour le forcer, il faut donc utiliser les fonctions suivantes, ou un cast (vers un type entre parenthèses).

Soit une variable $v, et $s un séparateur :

intval($v) ou (int) $v convertit en entier.
floatval($v) ou (float) $v convertit en flottant.
chr($v) convertit en caractère.
strval($v) ou (string) $v convertit un scalaire en chaine de caractères.
implode($s, $v) ou join($s, $v) transforme un tableau en chaine selon un séparateur donné.
explode($s, $v) convertit une chaine en tableau avec un séparateur donné entre les valeurs.

De plus, il est possible de réaliser un transtypage en préfixant la variable avec le type entre parenthèses. Exemple :

$a = 1;
$b = (bool) $a;
print gettype($a); // integer
print gettype($b); // boolean

(bool) "false" renvoie true car toute string non vide est vraie.

URLs

Tous les caractères Unicode n'étant pas admis dans les URL, on utilisera urlencode() pour convertir une chaine dans ce format.

De plus, si l'URL contient des paramètres HTTP, http_build_query() permet, en plus de l'encodage, de les générer à partir d'un tableau associatif.

Références

Voir aussi

Pour les conversions d'encodage : Coder_avec_Unicode/Conversion#PHP

[1] ttp://fr2.php.net/manual/fr/language.types.string.php#language.types.string.syntax.heredoc

[2] ttps://www.php.net/manual/fr/language.types.string.php#language.types.string.syntax.heredoc

[3] ttps://github.com/microsoft/vscode/issues/137539

[4] ttps://www.php.net/manual/en/language.types.float.php

[5] ttp://php.net/manual/fr/language.variables.variable.php

[6] ttp://www.php.net/manual/fr/function.setcookie.php

[7] ttp://php.net/manual/fr/function.is-null.php

[1]

[2]

[3]

[4]

[5]

[6]

[7]