Les opérateurs
Un opérateur est quelque chose qui prend une ou plusieurs valeurs
(ou expressions, dans le jargon de la programmation) et qui retourne une
autre valeur (donc la construction elle-même devient une expression).
Les opérateurs peuvent être regroupés en fonction du nombre de valeurs
qu'ils acceptent. L'opérateur unaire n'opère que sur une seule valeur,
par exemple !
(l'opérateur de négation)
ou ++
(l'opérateur d'incrémentation).
Le second type, les opérateurs binaires (comme le très célèbre
opérateur mathématique
+ ou -) contient la plupart des opérateurs
supportés par PHP. Enfin,
l'opérateur ternaire,
? :, qui accepte trois valeurs (on peut aussi l'appeler l'opérateur
conditionnel).
Une liste complète des opérateurs se trouve dans la section
précédence des opérateurs.
Cette section explique aussi la précédence des opérateurs et l'associativité, c'est à dire
les priorités d'exécution des opérateurs.
La priorité des opérateurs
La priorité des opérateurs spécifie
l'ordre dans lequel les valeurs doivent être analysées.
Par exemple, dans l'expression 1 + 5 * 3, le résultat est
16 et non 18, car la multiplication
("*") a une priorité supérieure par rapport à l'addition ("+").
Des parenthèses peuvent être utilisées pour forcer la priorité, si
nécessaire. Par exemple : (1 + 5) * 3 donnera
18.
Lorsque les opérateurs ont une priorité égale, leur association
décide la façon dont les opérateurs sont groupés. Par exemple,
"-" est une association par la gauche, ainsi 1 - 2 - 3
est groupé comme ceci (1 - 2) - 3 et sera évalué
à -4. D'un autre côté, "=" est une association par la
droite, ainsi, $a = $b = $c est groupé comme ceci
$a = ($b = $c).
Les opérateurs, dont la priorité est égale, qui ne sont pas associatifs,
ne peuvent pas être utilisés entre eux, par exemple,
1 < 2 > 1 est interdit en PHP. L'expression
1 <= 1 == 1 par contre, est autorisée, car l'opérateur
== a une précédence inférieure que l'opérateur
<=.
L'associativité à uniquement du sens pour les opérateurs binaire (et ternaire).
Les opérateurs unitaires sont soit préfixé soit suffixé ainsi cette notion
n'est pas applicable. Par exemple !!$a peut uniquement
être groupé de la manière suivante !(!$a).
L'utilisation des parenthèses, y compris lorsqu'elles ne sont pas nécessaires,
permet de mieux lire le code en effectuant des groupements explicites
plutôt qu'imaginer la priorité des opérateurs et leurs associations.
Le tableau qui suit liste les opérateurs par ordre de priorité, avec la
priorité la plus élevée en haut. Les opérateurs sur la même ligne ont
une priorité équivalente (donc l'associativité décide du groupement).
Priorité des opérateursAssociativitéOpérateursInformation additionnelle(n/a)clonenewclone et newdroite**arithmétique(n/a)+-++--~(int)(float)(string)(array)(object)(bool)@
arithmétique (unitaire + et -),
incrément/décrément
bit à bit,
casting de type&listendand;
contrôle d'erreur
gaucheinstanceof
type
(n/a)!
logique
gauche*/%
arithmétique
gauche+-.
arithmétique
(binaire + et -),
tableau&listendand;
chaîne de caractères
(. antérieur à PHP 8.0.0)
gauche<<>>
bitwise
gauche.
string (à partir de PHP 8.0.0)
non-associatif<<=>>=
comparaison
non-associatif==!====!==<><=>
comparaison
gauche&
bitwise&listendand;
référencesgauche^
bitwise
gauche|
bitwise
gauche&&
logique
gauche||
logique
droite??
coalescence nul
non-associatif? :
ternaire
(gauche--associatif antérieur à PHP 8.0.0)
droite=+=-=*=**=/=.=%=&=|=^=<<=>>=??=
affectation
(n/a)yield from
yield from
(n/a)yield
yield
(n/a)printprintgaucheand
logique
gauchexor
logique
gaucheor
logique
Associativité
$a = 5, $b = 5
?>
]]>
La priorité et l'association de l'opérateur ne déterminent que
la façon dont les expressions sont groupées ; ils ne spécifient
pas l'ordre de l'évaluation. PHP ne spécifie pas (de manière générale)
l'ordre dans lequel une expression est évaluée et le code qui suppose
un ordre spécifique d'évaluation ne devrait pas exister, car le
comportement peut changer entre les différentes versions de PHP
ou suivant le code environnant.
Ordre d'évaluation indéfini
]]>
<literal>+</literal>, <literal>-</literal> et <literal>.</literal>
ont la même priorité (antérieur à PHP 8.0.0)
]]>
&example.outputs;
Bien que = soit prioritaire sur
la plupart des opérateurs, PHP va tout de même exécuter des
expressions comme : if (!$a = foo()).
Dans cette situation, le résultat de foo()
sera placé dans la variable $a.
&reftitle.changelog;
&Version;&Description;8.0.0
La concaténation de chaînes de caractères (.) a désormais
une précédence moins élevée que l'addition/soustraction arithmétique
(+ et -) et les shifts bit-à-bit
gauche/droite (<< et >>);
auparavant ceci avait la même précédence que + et -,
et une précédence plus élevée que << et >>.
8.0.0
L'opérateur ternaire (? :) est désormais non associatif ;
auparavant il était gauche-associatif.
7.4.0
Dépendre de la précédence de la concaténation de chaînes de caractères
(.) relatif à l'addition/soustraction arithmétique
(+ ou -) ou les shifts bit-à-bit
gauche/droite (<< ou >>),
i.e. les utiliser ensemble dans une expression sans parenthèse, est obsolète.
7.4.0
Dépendre de la gauche-associativité de l'opérateur ternaire (? :),
c.-à-d. l'imbrication de plusieurs opérateurs ternaires qui ne sont pas
entre parenthèse, est obsolète.
Les opérateurs arithmétiques
Vous rappelez-vous des opérations élémentaires
apprises à l'école ? Les opérateurs arithmétiques fonctionnent comme elles.
Opérations élémentairesExempleNomRésultat+$aIdentitéConversion de $a vers int ou float,
selon le plus approprié.
-$aNégationOpposé de $a.$a + $bAdditionSomme de $a et $b.$a - $bSoustraction
Différence de $a et $b.
$a * $bMultiplicationProduit de $a et $b.$a / $bDivision
Quotient de $a et $b.
$a % $bModulus
Reste de $a divisé par $b.
$a ** $bExponentiationRésultat de l'élévation de $a à la puissance
$b.
L'opérateur de division ("/") retourne une valeur à virgule flottante
sauf si les 2 opérandes sont des entiers (ou une &string; qui a été convertie
en entiers) et que leur division est exacte (i.e. a pour reste 0), auquel cas une valeur
entière sera retournée. Pour la division entière, voir
intdiv.
Les opérandes du modulo sont converties en int avant exécution.
Pour le modulo sur des nombres décimaux, voir fmod.
Le résultat de l'opération modulo % a le même signe que
le premier opérande, ansi le résultat de $a % $b aura le signe de
$a. Par exemple:
]]>
&reftitle.seealso;
Les fonctions mathématiquesLes opérateurs d'affectation
L'opérateur d'affectation le plus simple est le signe "=".
Le premier réflexe est de penser que ce signe veut dire
"égal à". Ce n'est pas le cas. Il signifie que
l'opérande de gauche se voit affecter la valeur de
l'expression qui est à droite du signe égal.
La valeur d'une expression d'affectation est la valeur
affectée. Par exemple, la valeur de l'expression
'$a = 3' est la valeur 3. Cela permet d'utiliser
des astuces telles que :
]]>
En plus du simple opérateur d'affectation, il existe des
"opérateurs combinés" pour tous les opérateurs
arithmétiques,
l'union de tableaux et pour les opérateurs sur les chaînes de caractères.
Cela permet d'utiliser la valeur d'une variable dans une expression et
d'affecter le résultat de cette expression à cette variable.
Par exemple :
]]>
On peut noter que l'affectation copie le contenu de la variable originale
dans la nouvelle variable (affectation par valeur), ce qui fait que les
changements de valeur d'une variable ne modifieront pas la valeur de
l'autre. Cela peut se révéler important lors de la copie d'un grand tableau
durant une boucle.
Une exception au comportement d'affectation par valeur en PHP est le type
object, ceux-ci sont affectés par référence.
La copie d'objet doit être explicitement demandée grâce au mot-clé
clone.
Affectation par référence
L'affectation par référence est aussi supportée, au moyen de la syntaxe
"$var = &$othervar;". L'affectation par
référence signifie que les deux variables pointent vers le même conteneur de
donnée, rien n'est copié nulle part.
Affectation par référence
]]>
L'opérateur new
retourne une référence automatiquement, de ce fait, assigner le résultat de
new par référence est une erreur
]]>
&example.outputs;
Plus d'informations sur les références et leurs utilisations possibles peuvent être
trouvées dans la section du manuel Les références
expliquées.
Les opérateurs d'affectation arithmétiquesExempleEquivalentOpération$a += $b$a = $a + $bAddition$a -= $b$a = $a - $bSoustraction$a *= $b$a = $a * $bMultiplication$a /= $b$a = $a / $bDivision$a %= $b$a = $a % $bModulo$a **= $b$a = $a ** $bExponentiationOpérateurs d'affectation bits à bitsExempleEquivalentOpération$a &= $b$a = $a & $bOpérateur And$a |= $b$a = $a | $bOpérateur Or$a ^= $b$a = $a ^ $bOpérateur Xor$a <<= $b$a = $a << $bDécalage à gauche$a >>= $b$a = $a >> $bDécalage à droiteAutres opérateurs d'affectationExempleEquivalentOpération$a .= $b$a = $a . $bConcaténation d'une chaîne de caractères$a ??= $b$a = $a ?? $bOpérateur de coalescence nul
&reftitle.seealso;
les opérateurs arithmétiquesles opérateurs bits à bitsles opérateurs de coalescence nulOpérateurs sur les bits
Les opérateurs sur les bits vous permettent de
manipuler les bits dans un entier.
Les opérateurs sur les bitsExempleNomRésultat$a & $bAnd (Et)
Les bits positionnés à 1 dans $a ET dans
$b sont positionnés à 1.
$a | $bOr (Ou)
Les bits positionnés à 1 dans $a OU $b
sont positionnés à 1.
$a ^ $bXor (ou exclusif)
Les bits positionnés à 1 dans $a OU dans
$b mais pas dans les deux sont positionnés à 1.
~ $aNot (Non)
Les bits qui sont positionnés à 1 dans $a
sont positionnés à 0, et vice-versa.
$a << $bDécalage à gauche
Décale les bits de $a, $b fois
sur la gauche (chaque décalage équivaut à une multiplication par 2).
$a >> $bDécalage à droite
Décale les bits de $a, $b fois
sur la droite (chaque décalage équivaut à une division par 2).
Le décalage de bits en PHP est arithmétique.
Les bits qui sont décalés hors de l'entier sont perdus.
Les décalages à gauche font apparaître des zéros à droite,
tandis que le bit de signe est décalé à gauche, ce qui signifie
que le signe de l'entier n'est pas préservé.
Les décalages à droite décalent aussi le bit de signe sur la
droite, ce qui signifie que le signe est préservé.
Utilisez des parenthèses pour vous assurer que la
précédence
voulue est bien appliquée. Par exemple,
$a & $b == true applique d'abord
l'égalité, et ensuite le ET logique, alors que
($a & $b) == true applique d'abord le
ET logique, puis l'égalité.
Si les deux opérandes pour les opérateurs &,
| et ^ sont des chaines de caractères,
alors l'opération sera réalisée sur les valeurs ASCII des caractères et le
résultat sera une chaine de caractères. Dans tous les autres cas, les deux
opérandes seront
converties en entier
et le résultat sera un entier.
Si l'opérande pour l'opérateur ~ operator est une chaine
de caractères, l'opération sera effectuée sur les caractères ASCII composant
la chaine et le résultat sera une chaine de caractères. Sinon l'opérande et
le résultat seront traités comme des entiers.
Les opérandes et le résultat des opérateurs << et
>> sont traités comme des entiers.
Le rapport d'erreur de PHP utilise des champs de bits,
qui sont une illustration de l'extinction des bits.
Pour afficher les erreurs, sauf les notices, les
instructions du php.ini sont :
E_ALL & ~E_NOTICE
Cela se comprend en comparant avec E_ALL :
00000000000000000111011111111111
Puis en éteignant la valeur de E_NOTICE...
00000000000000000000000000001000
... et en l'inversant via ~:
11111111111111111111111111110111
Finalement, on utilise le ET logique (&) pour lire les bits activés
dans les deux valeurs :
00000000000000000111011111110111
Un autre moyen d'arriver à ce résultat est d'utiliser
le OU exclusif (^), qui cherche
les bits qui ne sont activés que dans l'une ou l'autre des
valeurs, exclusivement :
E_ALL ^ E_NOTICE
error_reporting peut aussi être utilisé pour
illustrer l'activation de bits. Pour afficher
uniquement les erreurs et les erreurs recouvrables,
on utilise :
E_ERROR | E_RECOVERABLE_ERROR
Cette approche combine E_ERROR
00000000000000000000000000000001
et E_RECOVERABLE_ERROR
00000000000000000001000000000000
Avec l'opérateur OR (|) pour s'assurer que
les bits sont activés dans l'une ou l'autre valeur :
00000000000000000001000000000001Opérations sur les bits et les entiers
]]>
&example.outputs;
Opération sur les bits et les chaînes
]]>
Décalage de bits sur les entiers
> $places;
p($res, $val, '>>', $places, 'copie du bit de signe maintenant à gauche');
$val = 4;
$places = 2;
$res = $val >> $places;
p($res, $val, '>>', $places);
$val = 4;
$places = 3;
$res = $val >> $places;
p($res, $val, '>>', $places, 'des bits sont sortis par la droite');
$val = 4;
$places = 4;
$res = $val >> $places;
p($res, $val, '>>', $places, 'même résultat que ci-dessus : pas de décalage au dela de 0');
echo "\n--- Décalages à droite sur des entiers négatifs ---\n";
$val = -4;
$places = 1;
$res = $val >> $places;
p($res, $val, '>>', $places, 'copie du bit de signe maintenant à gauche');
$val = -4;
$places = 2;
$res = $val >> $places;
p($res, $val, '>>', $places, 'des bits sont sortis par la droite');
$val = -4;
$places = 3;
$res = $val >> $places;
p($res, $val, '>>', $places, 'même résultat que ci-dessus : pas de décalage au dela de -1');
echo "\n--- Décalages à gauche sur des entiers positifs ---\n";
$val = 4;
$places = 1;
$res = $val << $places;
p($res, $val, '<<', $places, 'complément de zéros à droite');
$val = 4;
$places = (PHP_INT_SIZE * 8) - 4;
$res = $val << $places;
p($res, $val, '<<', $places);
$val = 4;
$places = (PHP_INT_SIZE * 8) - 3;
$res = $val << $places;
p($res, $val, '<<', $places, 'le bit de signe est sorti');
$val = 4;
$places = (PHP_INT_SIZE * 8) - 2;
$res = $val << $places;
p($res, $val, '<<', $places, 'des bits sont sortis à gauche');
echo "\n--- Décalages à gauche sur des entiers négatifs ---\n";
$val = -4;
$places = 1;
$res = $val << $places;
p($res, $val, '<<', $places, 'complément de zéros à droite');
$val = -4;
$places = (PHP_INT_SIZE * 8) - 3;
$res = $val << $places;
p($res, $val, '<<', $places);
$val = -4;
$places = (PHP_INT_SIZE * 8) - 2;
$res = $val << $places;
p($res, $val, '<<', $places, 'des bits sont sortis à gauche, y compris le bit de signe');
/*
* Ignorez cette section
* Elle contient du code pour le formatage de cet exemple
*/
function p($res, $val, $op, $places, $note = '') {
$format = '%0' . (PHP_INT_SIZE * 8) . "b\n";
printf("Expression : %d = %d %s %d\n", $res, $val, $op, $places);
echo " Décimal :\n";
printf(" val=%d\n", $val);
printf(" res=%d\n", $res);
echo " Binaire :\n";
printf(' val=' . $format, $val);
printf(' res=' . $format, $res);
if ($note) {
echo " Note : $note\n";
}
echo "\n";
}
?>
]]>
&example.outputs.32bit;
> 1
Décimal :
val=4
res=2
Binaire :
val=00000000000000000000000000000100
res=00000000000000000000000000000010
Note : copie du bit de signe maintenant à gauche
Expression : 1 = 4 >> 2
Décimal :
val=4
res=1
Binaire :
val=00000000000000000000000000000100
res=00000000000000000000000000000001
Expression : 0 = 4 >> 3
Décimal :
val=4
res=0
Binaire :
val=00000000000000000000000000000100
res=00000000000000000000000000000000
Note : des bits sont sortis par la droite
Expression : 0 = 4 >> 4
Décimal :
val=4
res=0
Binaire :
val=00000000000000000000000000000100
res=00000000000000000000000000000000
Note : même résultat que ci-dessus : pas de décalage au dela de 0
--- Décalages à droite sur des entiers négatifs ---
Expression : -2 = -4 >> 1
Décimal :
val=-4
res=-2
Binaire :
val=11111111111111111111111111111100
res=11111111111111111111111111111110
Note : copie du bit de signe à gauche
Expression : -1 = -4 >> 2
Décimal :
val=-4
res=-1
Binaire :
val=11111111111111111111111111111100
res=11111111111111111111111111111111
Note : des bits sont sortis par la droite
Expression : -1 = -4 >> 3
Décimal :
val=-4
res=-1
Binaire :
val=11111111111111111111111111111100
res=11111111111111111111111111111111
Note : même résultat que ci-dessus : pas de décalage au dela de -1
--- Décalages à gauche sur des entiers positifs ---
Expression : 8 = 4 << 1
Décimal :
val=4
res=8
Binaire :
val=00000000000000000000000000000100
res=00000000000000000000000000001000
Note : complément de zéros à droite
Expression : 1073741824 = 4 << 28
Décimal :
val=4
res=1073741824
Binaire :
val=00000000000000000000000000000100
res=01000000000000000000000000000000
Expression : -2147483648 = 4 << 29
Décimal :
val=4
res=-2147483648
Binaire :
val=00000000000000000000000000000100
res=10000000000000000000000000000000
Note : le bit de signe est sorti
Expression : 0 = 4 << 30
Décimal :
val=4
res=0
Binaire :
val=00000000000000000000000000000100
res=00000000000000000000000000000000
Note : des bits sont sortis à gauche
--- Décalages à gauche sur des entiers négatifs ---
Expression : -8 = -4 << 1
Décimal :
val=-4
res=-8
Binaire :
val=11111111111111111111111111111100
res=11111111111111111111111111111000
Note : complément de zéros à droite
Expression : -2147483648 = -4 << 29
Décimal :
val=-4
res=-2147483648
Binaire :
val=11111111111111111111111111111100
res=10000000000000000000000000000000
Expression : 0 = -4 << 30
Décimal :
val=-4
res=0
Binaire :
val=11111111111111111111111111111100
res=00000000000000000000000000000000
Note : des bits sont sortis à gauche, y compris le bit de signe
]]>
&example.outputs.64bit;
> 1
Décimal :
val=4
res=2
Binaire :
val=0000000000000000000000000000000000000000000000000000000000000100
res=0000000000000000000000000000000000000000000000000000000000000010
Note : copie du bit de signe maintenant à gauche
Expression : 1 = 4 >> 2
Décimal :
val=4
res=1
Binaire :
val=0000000000000000000000000000000000000000000000000000000000000100
res=0000000000000000000000000000000000000000000000000000000000000001
Expression : 0 = 4 >> 3
Décimal :
val=4
res=0
Binaire :
val=0000000000000000000000000000000000000000000000000000000000000100
res=0000000000000000000000000000000000000000000000000000000000000000
Note : des bits sont sortis par la droite
Expression : 0 = 4 >> 4
Décimal :
val=4
res=0
Binaire :
val=0000000000000000000000000000000000000000000000000000000000000100
res=0000000000000000000000000000000000000000000000000000000000000000
Note : même résultat que ci-dessus : pas de décalage au dela de 0
--- Décalages à droite sur des entiers négatifs ---
Expression : -2 = -4 >> 1
Décimal :
val=-4
res=-2
Binaire :
val=1111111111111111111111111111111111111111111111111111111111111100
res=1111111111111111111111111111111111111111111111111111111111111110
Note : copie du bit de signe maintenant à gauche
Expression : -1 = -4 >> 2
Décimal :
val=-4
res=-1
Binaire :
val=1111111111111111111111111111111111111111111111111111111111111100
res=1111111111111111111111111111111111111111111111111111111111111111
Note : des bits sont sortis par la droite
Expression : -1 = -4 >> 3
Décimal :
val=-4
res=-1
Binaire :
val=1111111111111111111111111111111111111111111111111111111111111100
res=1111111111111111111111111111111111111111111111111111111111111111
Note : même résultat que ci-dessus : pas de décalage au dela de -1
--- Décalage à gauche sur les entiers négatifs ---
Expression : 8 = 4 << 1
Décimal :
val=4
res=8
Binaire :
val=0000000000000000000000000000000000000000000000000000000000000100
res=0000000000000000000000000000000000000000000000000000000000001000
Note : complément de zéros à droite
Expression : 4611686018427387904 = 4 << 60
Décimal :
val=4
res=4611686018427387904
Binaire :
val=0000000000000000000000000000000000000000000000000000000000000100
res=0100000000000000000000000000000000000000000000000000000000000000
Expression : -9223372036854775808 = 4 << 61
Décimal :
val=4
res=-9223372036854775808
Binaire :
val=0000000000000000000000000000000000000000000000000000000000000100
res=1000000000000000000000000000000000000000000000000000000000000000
Note : le bit de signe est sorti
Expression : 0 = 4 << 62
Décimal :
val=4
res=0
Binaire :
val=0000000000000000000000000000000000000000000000000000000000000100
res=0000000000000000000000000000000000000000000000000000000000000000
Note : des bits sont sortis à gauche
--- Décalage à gauche sur les entiers négatifs ---
Expression : -8 = -4 << 1
Décimal :
val=-4
res=-8
Binaire :
val=1111111111111111111111111111111111111111111111111111111111111100
res=1111111111111111111111111111111111111111111111111111111111111000
Note : complément de zéros à droite
Expression : -9223372036854775808 = -4 << 61
Décimal :
val=-4
res=-9223372036854775808
Binaire :
val=1111111111111111111111111111111111111111111111111111111111111100
res=1000000000000000000000000000000000000000000000000000000000000000
Expression : 0 = -4 << 62
Décimal :
val=-4
res=0
Binaire :
val=1111111111111111111111111111111111111111111111111111111111111100
res=0000000000000000000000000000000000000000000000000000000000000000
Note : des bits sont sortis à gauche, y compris le bit de signe
]]>
Utilisez les fonctions de l'extension gmp
pour les manipulations sur les bits, lorsque les entiers dépassent
PHP_INT_MAX.
&reftitle.seealso;
packunpackgmp_andgmp_orgmp_xorgmp_testbitgmp_clrbitOpérateurs de comparaison
Les opérateurs de comparaison, comme leur nom l'indique,
vous permettent de comparer deux valeurs. Vous devriez également être
intéressés par les
tables de comparaisons de types,
car ils montrent des exemples de beaucoup de types de comparaisons.
Opérateurs de comparaisonExempleNomRésultat$a == $bÉgal&true; si $a est égal à
$b après le transtypage.$a === $bIdentique
&true; si $a est égal à $b et
qu'ils sont de même type.
$a != $bDifférent&true; si $a est différent de
$b après le transtypage.$a <> $bDifférent&true; si $a est différent de
$b après le transtypage.$a !== $bDifférent
&true; si $a est différent de $b
ou bien s'ils ne sont pas du même type.
$a < $bPlus petit que&true; si $a est strictement plus petit que
$b.$a > $bPlus grand&true; si $a est strictement plus grand que
$b.$a <= $bInférieur ou égal&true; si $a est plus petit ou égal à
$b.$a >= $bSupérieur ou égal&true; si $a est plus grand ou égal à
$b.$a <=> $bCombiné
Un &integer; inférieur, égal ou supérieur à zéro lorsque
$a est inférieur, égal, ou supérieur à
$b respectivement.
Si les deux opérandes sont des
chaînes numériques,
ou si un opérande est un nombre et l'autre est une
chaîne numérique,
alors la comparaison sera effectuée numériquement.
Ces règles s'appliquent également à l'instruction
switch.
La conversion de type n'intervient pas lorsque la comparaison est
=== ou !==
vu que ceci engendre aussi bien une comparaison de type que de valeur.
Antérieur à PHP 8.0.0, si une string est comparé à un nombre
ou à une chaîne numérique alors la string sera convertie en un
nombre avant d'effectuer la comparaison. Ceci peut mener à des résultats
surprenant comme il peut être vu avec l'exemple suivant :
]]>
&example.outputs.7;
&example.outputs.8;
1; // 0
echo 1 <=> 2; // -1
echo 2 <=> 1; // 1
// Nombre flottants
echo 1.5 <=> 1.5; // 0
echo 1.5 <=> 2.5; // -1
echo 2.5 <=> 1.5; // 1
// Chaines de caractères
echo "a" <=> "a"; // 0
echo "a" <=> "b"; // -1
echo "b" <=> "a"; // 1
echo "a" <=> "aa"; // -1
echo "zz" <=> "aa"; // 1
// Tableaux
echo [] <=> []; // 0
echo [1, 2, 3] <=> [1, 2, 3]; // 0
echo [1, 2, 3] <=> []; // 1
echo [1, 2, 3] <=> [1, 2, 1]; // 1
echo [1, 2, 3] <=> [1, 2, 4]; // -1
// Objets
$a = (object) ["a" => "b"];
$b = (object) ["a" => "b"];
echo $a <=> $b; // 0
$a = (object) ["a" => "b"];
$b = (object) ["a" => "c"];
echo $a <=> $b; // -1
$a = (object) ["a" => "c"];
$b = (object) ["a" => "b"];
echo $a <=> $b; // 1
// non seulement les valeurs sont comparées; les clés doivent correspondre
$a = (object) ["a" => "b"];
$b = (object) ["b" => "b"];
echo $a <=> $b; // 1
?>
]]>
Pour les différents types, la comparaison est faite en suivant
la table suivante (dans l'ordre).
Comparaison avec plusieurs typesType de l'opérande 1Type de l'opérande 2Résultatnull ou stringstringConvertit &null; en "", comparaison numérique ou lexicalebool ou nullN'importe quoiConvertit en bool, &false; < &true;objectobjectLes classes internes peuvent définir leur propre méthode de
comparaison ; différentes classes sont incomparables ; entre objets
de même classe voir Comparaison d'objet
&string;, &resource;, &integer; ou &float;
&string;, &resource;, &integer; ou &float;
Transforme les chaînes de caractères et les ressources en nombres
arrayarrayLe tableau avec le moins de membres est plus petit, si la clé de
l'opérande 1 n'est pas trouvée dans l'opérande 2, alors les tableaux
sont incomparables, sinon la comparaison se fait valeur par valeur
(voir l'exemple suivant)
objectN'importe quoiL'objet est toujours plus grandarrayN'importe quoiLe tableau est toujours plus grand
Comparaison Booléen/null
]]>
Transcription des comparaisons standards des tableaux
count($op2)) {
return 1; // $op1 > $op2
}
foreach ($op1 as $key => $val) {
if (!array_key_exists($key, $op2)) {
return 1;
} elseif ($val < $op2[$key]) {
return -1;
} elseif ($val > $op2[$key]) {
return 1;
}
}
return 0; // $op1 == $op2
}
?>
]]>
Comparaison de nombre à virgule flottante
A cause de la façon dont les nombres à virgule flottante sont représentés
en interne, vous ne devriez pas tester l'égalité entre deux nombres
de type float.
Voyez la documentation de float pour plus d'informations.
Soyer conscient que la manipulation des types n'est pas toujours évidente lors de la comparaison
de valeurs de différents types, en particulier comparant des &integer;s à des &boolean;s ou des
&integer;s à des &string;s. Il est par conséquent généralement recommandé d'utiliser les
opérateurs de comparaison === et !== au lieu de
== et != dans la plupart des cas.
Valeurs incomparables
Tandis que les comparaisons d'identité (=== et !==)
peuvent être appliqué à des valeurs arbitraires, les autres opérateurs de
comparaisons devrait seulement être appliqué à des valeurs comparables.
Le résultat de comparer des valeurs incomparables est indéfinie,
et ne devrait pas être dépendu.
&reftitle.seealso;
strcasecmpstrcmpopérateur de tableauxTypesL'opérateur ternaire
Un autre opérateur conditionnel est l'opérateur
ternaire ("?:").
Affectation d'une valeur par défaut
]]>
L'expression (expr1) ? (expr2) : (expr3)
est évaluée à expr2 si
expr1 est évaluée à &true;, et
expr3 si
expr1 est évaluée à &false;.
Il est possible d'omettre la partie centrale de l'opérateur ternaire.
L'expression expr1 ?: expr3 évalue le résultat de
expr1 si expr1
vaut &true;, et expr3 sinon.
expr1 n'est évalué qu'une seule fois dans ce cas.
Notez que l'opérateur ternaire est une expression, et il n'est pas
évalué en tant que variable, mais en tant que résultat de l'expression.
Il est important de le savoir si vous voulez retourner une variable
par référence. L'instruction
return $var == 42 ? $a : $b;
dans une fonction retournée par référence ne fonctionnera donc pas et une
alerte est émise.
Il est recommandé de ne pas "empiler" les expressions ternaires.
Le comportement de PHP lors de l'utilisation de plusieurs opérateurs
ternaire qui ne sont pas entre parenthèse en une unique expression est
non évident comparé à d'autres langages.
En effet antérieur à PHP 8.0.0, l'expression ternaire était évalué
gauche-associatif, au lieu de droite-associatif comme la plupart des
autres langages de programmations.
Dépendre de la gauche associativité est obsolète à partir de PHP 7.4.0.
À partir de PHP 8.0.0, l'opérateur ternaire est non associatif.
Comportement de PHP
]]>
La combinaison de ternaire court (?:), cependant, est stable et se comporte de manière résonable.
Ceci évaluera au premier argument qui évalue à une valeur non-falsy.
À noter que des valeurs indéfinies émettront toujours un avertissement.
Combinaison de ternaire court
]]>
Opérateur de fusion Null
Un autre opérateur court utile est l'opérateur "??" (ou fusion null).
Assigner une valeur par défaut
]]>
L'expression (expr1) ?? (expr2) retourne
expr2 si expr1 est
&null;, et expr1 dans les autres cas.
En particulier, cet opérateur n'émet pas de notice ou avertissement si
la partie gauche n'existe pas, exactement comme isset.
Ceci est particulièrement utile pour les clés des tableaux.
Veuillez noter que l'opérateur null de fusion est une expression, et qu'il
ne s'évalue pas comme une variable, mais comme le résultat d'une expression.
Il est important de le savoir si vous souhaitez renvoyer une variable
par référence.
L'expression return $foo ?? $bar; est un retour par
référence qui ne fonctionne donc pas et émet un avertissement.
L'opérateur de fusion null à une précédence faible. Ceci signifie que le mélanger
avec d'autres opérateurs (tel que la concaténation de chaînes ou les opérateurs
arithmétiques) des parenthèses seront requis.
]]>
Veuillez noter que l'opérateur de fusion null permet une imbrication simple:
Imbrication de l'opération de fusion null
]]>
Opérateur de contrôle d'erreur
PHP supporte un opérateur de contrôle d'erreur : l'arobase (@).
Lorsque cet opérateur est ajouté en préfixe d'une
expression PHP, les diagnostics d'erreurs qui peuvent être
générés par cette expression seront ignorés.
Si un gestionnaire d'erreur personnalisé est défini avec
set_error_handler, il sera quand même appelé même si
le diagnostic a été ignorée.
Antérieur à PHP 8.0.0, le error_reporting appelée dans le gestionnaire d'erreur
personnalisé retournait toujours 0 si le l'erreur a été ignorée avec l'opérateur @.
À partir de 8.0.0, il retourne la valeur E_ERROR | E_CORE_ERROR | E_COMPILE_ERROR | E_USER_ERROR | E_RECOVERABLE_ERROR | E_PARSE.
Tous les messages d'erreur générés par l'expression sont disponibles
dans l'élément "message" du tableau retourné par
la fonction error_get_last. Le résultat de la fonction
changera à chaque erreur, aussi, il convient de le vérifier souvent.
]]>
L'opérateur @ ne fonctionne qu'avec les
expressions.
La règle générale est : s'il est possible de prendre la valeur de quelque
chose alors on peut préfixer l'opérateur @ à celui-ci.
Par exemple, il peut être préfixé devant les variables, appels de fonctions,
certains appels aux constructions de langages (e.g.
include), etc.
Il ne peut pas être préfixé devant les définitions de fonctions ou de classes
ou structures conditionnelles telles que if et &foreach;, etc.
Antérieur à PHP 8.0.0, il était possible pour l'opérateur
@ de désactiver les erreurs critiques qui terminait
l'exécution du script.
Par exemple, préfixer @ à un appel d'une fonction qui
n'existe pas, en étant indisponible ou mal orthographiée, causait le script
à se terminer sans aucune indication pourquoi.
&reftitle.seealso;
error_reportingGestion d'Erreur et fonction de LoggingOpérateur d'exécution
PHP supporte un opérateur d'exécution : guillemets obliques
("``"). Notez bien qu'il ne s'agit pas de guillemets simples. PHP
essaie d'exécuter le contenu de ces guillemets obliques comme une commande
shell. Le résultat sera retourné (c'est-à-dire : il ne sera pas simplement
envoyé à la sortie standard, il peut être affecté à une variable).
Utiliser les guillemets obliques revient à utiliser la fonction
shell_exec.
Opérateur d'exécution
$output";
?>
]]>
Cet opérateur est désactivé lorsque la fonction
shell_exec est désactivée.
Contrairement à d'autres langages, les guillemets obliques
n'ont pas de signification spéciale dans une chaîne entourée
de guillemets doubles.
&reftitle.seealso;
Les fonctions d'exécution systèmepopenproc_openUtiliser PHP depuis la ligne de commandeOpérateurs d'incrémentation et décrémentation
PHP supporte les opérateurs de pre- et post-incrémentation et
décrémentation, comme en langage C.
Les opérateurs d'incrémentation/décrémentation n'affectent que les
nombres et les chaînes de caractères.
Les tableaux, objets, booléen et ressources ne sont pas affectées.
La décrémentation des valeurs &null; n'a également aucun effet,
mais leur incrémentation donnera comme résultat 1.
Opérateurs d'incrémentation et décrémentationExempleNomRésultat++$aPre-incrémente
Incrémente $a de 1, puis retourne
$a.
$a++Post-incrémenteRetourne $a, puis incrémente $a de 1.--$aPré-décrémente
Décrémente $a de 1, puis retourne
$a.
$a--Post-décrémente
Retourne $a, puis décrémente
$a de 1.
';
$a = 5;
echo "Devrait valoir 4: " . --$a . " \n";
echo "Devrait valoir 4: " . $a . " \n";
?>
]]>
PHP suit les conventions de Perl pour la gestion des opérateurs
arithmétiques sur les variables de caractères et non pas celle du C.
Par exemple, en PHP et en Perl, $a = 'Z'; $a++;
transforme $a en 'AA',
alors qu'en C, a = 'Z'; a++; transforme
a en '[' (la valeur ASCII de
'Z' est 90, la valeur ASCII de '['
est 91). Notez que les variables de caractères peuvent être incrémentés,
mais pas décrémentées, mais aussi que seuls les caractères ASCII pleins
et les chiffres (a-z, A-Z et 0-9) sont supportés.
L'incrémentation/décrémentation d'autres variables de caractères n'a
aucun effet, la chaîne originale n'est pas modifiée.
Opérations arithmétiques sur un caractère
]]>
&example.outputs;
L'incrémentation ou la décrémentation d'un booléen n'a aucun effet.
Les opérateurs logiques
Les opérateurs logiquesExempleNomRésultat$a and $bAnd (Et)&true; si $a ET $b valent &true;.$a or $bOr (Ou)&true; si $a OU $b valent &true;.$a xor $bXOR
&true; si $a OU $b est &true;,
mais pas les deux en même temps.
! $aNot (Non)&true; si $a n'est pas &true;.$a && $bAnd (Et)&true; si $a ET $b sont &true;.$a || $bOr (Ou)&true; si $a OU $b est &true;.
La raison pour laquelle il existe deux types de "ET" et de "OU"
est qu'ils ont des priorités différentes. Voir le
paragraphe
précédence d'opérateurs.
Illustration des opérateurs logiques
]]>
&example.outputs.similar;
Opérateurs de chaînes
Il y a deux opérateurs de chaînes de caractères string.
Le premier est l'opérateur de concaténation ('.'), qui
retourne la concaténation de ses deux arguments.
Le second est l'opérateur d'affectation
concaténant (.=). Reportez-vous à
opérateurs d'affectation
pour plus de détails.
Opérateur de concaténation
]]>
&reftitle.seealso;
Les types de chaînes de caractèresLes fonctions de chaînes de caractèresOpérateurs de tableaux
Opérateurs de tableauxExempleNomRésultat$a + $bUnionUnion de $a et $b.$a == $bÉgalité&true; si $a et $b contiennent les mêmes paires clés/valeurs.$a === $bIdentique&true; si $a et $b contiennent les mêmes paires clés/valeurs dans le même ordre et du même type.$a != $bInégalité&true; si $a n'est pas égal à $b.$a <> $bInégalité&true; si $a n'est pas égal à $b.$a !== $bNon-identique&true; si $a n'est pas identique à $b.
L'opérateur + retourne le tableau de gauche auquel sont
ajoutés les éléments du tableau de droite. Pour les clés présentes dans les
2 tableaux, les éléments du tableau de gauche seront utilisés alors que les
éléments correspondants dans le tableau de droite seront ignorés.
"pomme", "b" => "banane");
$b = array("a" =>"poire", "b" => "fraise", "c" => "cerise");
$c = $a + $b; // Union de $a et $b
echo "Union de \$a et \$b : \n";
var_dump($c);
$c = $b + $a; // Union de $b et $a
echo "Union de \$b et \$a : \n";
var_dump($c);
$a += $b; // Union de $a += $b est $a and $b
echo "Union de \$a += \$b: \n";
var_dump($a);
?>
]]>
À l'exécution, le script affichera :
string(5) "pomme"
["b"]=>
string(6) "banane"
["c"]=>
string(6) "cerise"
}
Union de $b et $a :
array(3) {
["a"]=>
string(5) "poire"
["b"]=>
string(6) "fraise"
["c"]=>
string(6) "cerise"
}
Union de $a += $b:
array(3) {
["a"]=>
string(5) "pomme"
["b"]=>
string(6) "banane"
["c"]=>
string(6) "cerise"
}
]]>
Les éléments d'un tableau sont égaux en termes de comparaison s'ils ont la
même clé et la même valeur.
Comparer des tableaux
"banane", "0" => "pomme");
var_dump($a == $b); // bool(true)
var_dump($a === $b); // bool(false)
?>
]]>
&reftitle.seealso;
Le Type TableauLes Fonctions de TableauxOpérateurs de typesinstanceof est utilisé pour déterminer si une variable PHP
est un objet instancié d'une certaine
classe :
Utilisation de <literal>instanceof</literal> avec des classes
]]>
&example.outputs;
instanceof peut également être utilisé pour déterminer
si une variable est un objet instancié d'une classe qui hérite d'une classe parente :
Utilisation de <literal>instanceof</literal> avec des classes héritées
]]>
&example.outputs;
Pour vérifier si un objet n'est pas une instance d'une classe,
l'opérateur logique not
peut être utilisé.
Utilisation de <literal>instanceof</literal> pour vérifier que l'objet
<emphasis>n'est pas</emphasis> une instance de la classe
]]>
&example.outputs;
Et finalement, instanceof peut être utilisé pour déterminer
si une variable est un objet instancié d'une classe qui implémente une
interface :
Utilisation de <literal>instanceof</literal> pour une interface
]]>
&example.outputs;
Bien que instanceof soit habituellement utilisé avec un nom
de classe littéral, il peut également être utilisé avec un autre objet ou une chaîne
représentant une variable :
Utilisation de <literal>instanceof</literal> avec d'autres variables
]]>
&example.outputs;
instanceof ne lance aucune erreur si la variable testée n'est pas
un objet, il retournera simplement &false;. Cependant, les constantes
ne sont pas autorisées.
Utilisation de <literal>instanceof</literal> pour tester d'autres variables
]]>
&example.outputs;
À partir de PHP 7.3.0, les constantes sont autorisées sur le côté gauche
de l'opérateur instanceof.
Utilisation de <literal>instanceof</literal> pour tester des constantes
]]>
&example.outputs.73;
À partir de PHP 8.0.0, instanceof peut désormais être
utilisé avec des expressions arbitraires.
L'expression doit être entre parenthèses et produire une string.
Utilisation de <literal>instanceof</literal> avec une expression arbitraire
]]>
&example.outputs.8;
L'opérateur instanceof a une variante fonctionnelle
avec la fonction is_a.
&reftitle.seealso;
get_classis_a