PHP 8.3.4 Released!

Essentiel

En PHP, les variables sont représentées par un signe dollar "$" suivi du nom de la variable. Le nom est sensible à la casse.

Les noms de variables suivent les mêmes règles de nommage que les autres entités PHP. Un nom de variable valide doit commencer par une lettre ou un souligné (_), suivi de lettres, chiffres ou soulignés. Exprimé sous la forme d'une expression régulière, cela donne : ^[a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*$

Note: Dans nos propos, une lettre peut être a-z, A-Z, et les octets de 128 à 255 (0x80-0xff).

Note: $this est une variable spéciale, qui ne peut pas être assignée. Avant PHP 7.1.0, l'affectation indirecte (c.à.d. en utilisant les variables variables) était impossible.

Astuce

Jetez un oeil sur Guide de nommage de l'espace utilisateur.

Pour obtenir des informations sur une variable, voyez les fonctions dédiées aux variables.

Exemple #1 Validité des noms de variables

<?php
$var
= 'Jean';
$Var = 'Paul';
echo
"$var, $Var"; // affiche "Jean, Paul"

$4site = 'pas encore'; // invalide : commence par un nombre
$_4site = 'pas encore'; // valide : commence par un souligné
$täyte = 'mansikka'; // valide : 'ä' est ASCII (étendu) 228.
?>

Les variables sont toujours assignées par valeur. C'est-à-dire, lorsque vous assignez une expression à une variable, la valeur de l'expression est recopiée dans la variable. Cela signifie, par exemple, qu'après avoir assigné la valeur d'une variable à une autre, modifier l'une des variables n'aura pas d'effet sur l'autre. Pour plus de détails sur ce genre d'assignation, reportez-vous aux expressions.

PHP permet aussi d'assigner les valeurs aux variables par référence. Cela signifie que la nouvelle variable ne fait que référencer (en d'autres termes, "devient un alias de", ou encore "pointe sur") la variable originale. Les modifications de la nouvelle variable affecteront l'ancienne et vice versa.

Pour assigner par référence, ajoutez simplement un & (ET commercial) au début de la variable qui est assignée (la variable source). Dans l'exemple suivant, Mon nom est Pierre s'affichera deux fois :

Exemple #2 Assignation de référence

<?php
$foo
= 'Pierre'; // Assigne la valeur 'Pierre' à $foo
$bar = &$foo; // Référence $foo avec $bar.
$bar = "Mon nom est $bar"; // Modifie $bar...
echo $foo; // $foo est aussi modifiée
echo $bar;
?>

Une chose importante à noter est que seules les variables nommées peuvent être assignées par référence.

Exemple #3 Assignation de référence et variables anonymes

<?php
$foo
= 25;
$bar = &$foo; // assignation valide
$bar = &(24 * 7); // assignation invalide : référence une expression sans nom
function test() {
return
25;
}
$bar = &test(); // assignation invalide.
?>

Il n'est pas nécessaire d'initialiser les variables en PHP, cependant, cela reste une excellente pratique. Les variables non initialisées ont une valeur par défaut selon leur type - false pour les booléens, zéro pour les entiers et les réels, chaîne vide pour les chaînes de caractères (comme utilisée avec echo) ou un tableau vide pour les tableaux.

Exemple #4 Valeurs par défaut des variables non initialisées

<?php
// Une variable non initialisée et non référencée (pas de contexte d'utilisation); retourne NULL
var_dump($unset_var);

// L'utilisation d'un booléen ; retourne 'false' (Voir l'opérateur ternaire pour comprendre cette syntaxe)
echo $unset_bool ? "true\n" : "false\n";

// Utilisation d'une chaîne de caractères ; retourne 'string(3) "abc"'
$unset_str .= 'abc';
var_dump($unset_str);

// Utilisation d'un entier; retourne 'int(25)'
$unset_int += 25; // 0 + 25 => 25
var_dump($unset_int);

// Utilisation d'un float; retourne 'float(1.25)'
$unset_float += 1.25;
var_dump($unset_float);

// Utilisation d'un tableau : retourne array(1) { [3]=> string(3) "def" }
$unset_arr[3] = "def"; // array() + array(3 => "def") => array(3 => "def")
var_dump($unset_arr);

// Utilisation d'un objet ; crée un nouvel objet stdClass (voir http://www.php.net/manual/fr/reserved.classes.php)
// Retourne : object(stdClass)#1 (1) { ["foo"]=> string(3) "bar" }
$unset_obj->foo = 'bar';
var_dump($unset_obj);
?>

Utiliser la valeur par défaut d'une variable non initialisée est problématique lorsque vous incluez un fichier dans un autre qui utilise le même nom de variable. Une erreur de niveau E_WARNING (antérieur à PHP 8.0.0, E_NOTICE) sera émise lorsque vous travaillerez avec des variables non initialisées, cependant, aucune erreur ne sera lancée lorsque vous tenterez d'insérer un élément dans un tableau non initialisé. La structure de langage isset() peut être utilisée pour détecter si une variable a déjà été initialisée.

add a note

User Contributed Notes 2 notes

up
74
jeff dot phpnet at tanasity dot com
13 years ago
This page should include a note on variable lifecycle:

Before a variable is used, it has no existence. It is unset. It is possible to check if a variable doesn't exist by using isset(). This returns true provided the variable exists and isn't set to null. With the exception of null, the value a variable holds plays no part in determining whether a variable is set.

Setting an existing variable to null is a way of unsetting a variable. Another way is variables may be destroyed by using the unset() construct.

<?php
print isset($a); // $a is not set. Prints false. (Or more accurately prints ''.)
$b = 0; // isset($b) returns true (or more accurately '1')
$c = array(); // isset($c) returns true
$b = null; // Now isset($b) returns false;
unset($c); // Now isset($c) returns false;
?>

is_null() is an equivalent test to checking that isset() is false.

The first time that a variable is used in a scope, it's automatically created. After this isset is true. At the point at which it is created it also receives a type according to the context.

<?php
$a_bool
= true; // a boolean
$a_str = 'foo'; // a string
?>

If it is used without having been given a value then it is uninitalized and it receives the default value for the type. The default values are the _empty_ values. E.g Booleans default to FALSE, integers and floats default to zero, strings to the empty string '', arrays to the empty array.

A variable can be tested for emptiness using empty();

<?php
$a
= 0; //This isset, but is empty
?>

Unset variables are also empty.

<?php
empty($vessel); // returns true. Also $vessel is unset.
?>

Everything above applies to array elements too.

<?php
$item
= array();
//Now isset($item) returns true. But isset($item['unicorn']) is false.
//empty($item) is true, and so is empty($item['unicorn']

$item['unicorn'] = '';
//Now isset($item['unicorn']) is true. And empty($item) is false.
//But empty($item['unicorn']) is still true;

$item['unicorn'] = 'Pink unicorn';
//isset($item['unicorn']) is still true. And empty($item) is still false.
//But now empty($item['unicorn']) is false;
?>

For arrays, this is important because accessing a non-existent array item can trigger errors; you may want to test arrays and array items for existence with isset before using them.
up
17
anisgazig at gmail dot com
3 years ago
clear concept of variable declaration rules and classification

variable declaration rules:

1.start with dollar sign($)
2.first letter of variable name comes from a-zA-z_
3.next letters of variable name comes from a-zA-Z0-9_
4.no space,no syntex

classification of variables:

Variable are mainly Two types
1.Predefined Variable
2.User Define Variable

Predefined Variable
There are 12 predefined variables in php 8
1.$GLOBALS
2.$_SERVER
3.$_REQUEST
4.$_FILES
5.$_ENV
6.$_SESSION
7.$_COOKIE
8.$_GET
9.$_POST
10.$http_response_header
11.$argc
12.$argv

User Define Variable
User Define variable are 3 types
1.variable scope
2.variable variables
3.reference variable

Variable Scope
variable scope are 3 types
1.local scope
2.global scope
3.static variable
To Top