Opérateurs PHP

Opérateurs PHP

Dans ce chapitre, nous discuterons de l'application de différents opérateurs en PHP.

En PHP, l'opérateur d'affectation = est utilisé pour attribuer une valeur à une variable.

En PHP, l'opérateur arithmétique + est utilisé pour additionner des valeurs.

Opérateurs arithmétiques PHP

Opérateur                                                                                            ajout Soustraire la différence entre x et y 5 - 2 3

x*y 🎜>x / y                                                                                               Le quotient de x et y                                                                                                                                                                                  

                                                                                                                             Négation 2

a b                                                                                            « Utilisez % dans l'opérateur numérique pour trouver le reste. Si le dividende ($ a) est un nombre négatif, alors le résultat obtenu est également une valeur négative.

Les exemples suivants démontrent différents résultats obtenus en utilisant différents opérateurs arithmétiques :

Exemple

<?php 
 $x=10; 
 $y=6;
 echo ($x + $y); // 输出16
 echo '<br/>'
 echo ($x - $y); // 输出4
 echo '<br/>'
 echo ($x * $y); // 输出60
 echo '<br/>'
 echo ($x / $y); // 输出1.6666666666667 
 echo '<br/>'
 echo ($x % $y); // 输出4 
 ?>

Nouveaux opérateurs de division entière dans la version PHP7+ intdiv (), exemple d'utilisation :

<?php
var_dump(intdiv(10, 3));
?>

L'exemple ci-dessus affichera :

int(3)

Opérateur d'affectation PHP

opérateur Descriptionx = y                                        La valeur de l'expression

x + = y> x / = y connecter deux chaînes

En php, l'opérateur d'attribution de base est "=". Cela signifie que l'opérande de gauche est défini sur la valeur de l'expression de droite. Autrement dit, la valeur de « $x = 5 » est 5.

Les exemples suivants démontrent différents résultats obtenus en utilisant différents opérateurs d'affectation :

Exemple

<?php 
 $x=10; 
 echo $x; // 输出10
 
 $y=20; 
 $y += 100;
 echo $y; // 输出120
 
 $z=50;
 $z -= 25;
 echo $z; // 输出25
 
 $i=5;
 $i *= 6;
 echo $i; // 输出30
 
 $j=10;
 $j /= 5;
 echo $j; // 输出2
 
 $k=15;
 $k %= 4;
 echo $k; // 输出3
 ?>

Ce qui suit Des exemples démontrent différents résultats en utilisant différents opérateurs de chaîne :

Exemple

<?php
 $a = "Hello";
 $b = $a . " world!";
 echo $b; // 输出Hello world! 
 
 $x="Hello";
 $x .= " world!";
 echo $x; // 输出Hello world! 
 ?>

Opérateur d'incrémentation/diminution PHP

Opérateur                                                                 Pré-incrémenter x Ajouter 1 à x et renvoyer x

X ++ Retour à X, puis X ajouter 1

- X pré-diminuer x moins 1, puis revenir à x

x- puis diminuer à X, puis x moins réduction 1

L'exemple suivant montre le résultat de l'utilisation de l'opérateur d'incrémentation/décrémentation :

Exemple

<?php
 $x=10; 
 echo ++$x; // 输出11
 
 $y=10; 
 echo $y++; // 输出10
 
 $z=5;
 echo --$z; // 输出4
 
 $i=5;
 echo $i--; // 输出5
 ?>

Priorité des opérateurs

La préséance des opérateurs est une règle très complexe, voir

http:// php.net/manual /zh/lingual.operators.precedence.php

Pas besoin de le mémoriser par cœur, il suffit de comprendre les règles couramment utilisées, de haut en bas

•      ! NON logique

· Les opérations de multiplication et de division sont supérieures aux opérations d'addition et de soustraction (multiplication et division d'abord, puis addition et soustraction)

• Opérateurs de comparaison (calculer d'abord puis comparer)

• Opérateurs logiques (le résultat de la comparaison est logique)

Veuillez analyser le résultat de $result = 3 * 2 + 1 > 8 / 4 - 1 == 1 ;

Utilisez des parenthèses, même lorsque cela n'est pas strictement nécessaire, cela peut généralement améliorer la lisibilité du code

$result = 3 * 2 + 1 >

Une bonne façon de l'écrire est 🎜>

Opérateurs de comparaison PHP

Les opérateurs de comparaison vous permettent de comparer deux valeurs :

Description des opérateursIf Renvoie vrai si x est égal à y et qu'ils sont du même type 5= ==="5" Renvoie false

x != y Différent de y Si x n'est pas égal à y, renvoie vrai 5!=8 Renvoie vrai

x & lt;> > 🎜>x<y

x >= y                                                                                                                                                                                                                                                Inférieur ou égal à Si x est inférieur ou égal à y, alors renvoie vrai                           5<=8 Renvoie vrai

. 

Parmi eux, les moins courants sont === et ! ==. $a===$b signifie que $a et $b sont non seulement égaux numériquement, mais ont également le même type. ! == et === ont des significations opposées. $a!==$b signifie que $a et $b ne sont pas égaux en valeur ou en type.

En PHP, toutes les valeurs suivantes représentent des vides : null, false, array(), "", 0, "0".

Si == est utilisé, null == false, 0 == "0", null== array(), false == ""...tous renvoient vrai, tandis que l'utilisation de === renverra false

Des millions ! Dix millions ! N'écrivez pas par erreur == comme =

C'est l'erreur la plus courante pour les novices. = est le symbole d'affectation et == est la comparaison pour l'égalité

Les exemples suivants démontrent l'utilisation de quelques opérateurs de comparaison pour obtenir des résultats différents pour :

Instance

<?php
 $x=100; 
 $y="100";
 
 var_dump($x == $y);
 echo "<br>";
 var_dump($x === $y);
 echo "<br>";
 var_dump($x != $y);
 echo "<br>";
 var_dump($x !== $y);
 echo "<br>";
 
 $a=50;
 $b=90;
 
 var_dump($a > $b);
 echo "<br>";
 var_dump($a < $b);
 ?>

Opérateur logique PHP

Opérateur                                                        Exemple

x et y                                                                                                                                                           🎜>                                                      (x < 10 et y > 1) Renvoie vrai

x ou y

                                                                                                                                                                             (x==6 ou y==5) Renvoie vrai

x xor y                                                                                                                 pour renvoyer vrai 6

y = 3

( x == 6 xou y == 3) Retournez à false

x && y et si x et y sont vrais, alors retournez vrai x=6

                                                          y=3

                                                      (x < 10 && y > 1) Renvoie vrai

x ||                                                   y =3

                                                                                                                                                                                                                           pour renvoyer false                  x=6

🎜>

                                                                                                                                                                                            🎜>

Opérateur                                                                     set Si x et y ont la même paire clé/valeur, renvoie true

x === y n'est pas égal si Si x n'est pas égal à y, renvoie vrai

x <> y                                                                                                                                                         Pas identique, puis retournez true

Les exemples suivants démontrent différents résultats obtenus en utilisant certains opérateurs de tableau :

Exemple

<?php
 $x = array("a" => "red", "b" => "green"); 
 $y = array("c" => "blue", "d" => "yellow"); 
 $z = $x + $y; // $x 和 $y 数组合并
 var_dump($z);
 var_dump($x == $y);
 var_dump($x === $y);
 var_dump($x != $y);
 var_dump($x <> $y);
 var_dump($x !== $y);
 ?>

Opérateur ternaire

Un autre L'opérateur conditionnel est l'opérateur « ? : » (ou opérateur ternaire méta).

Format de grammaire

(expr1) ? (expr2) : (expr3)

La valeur lorsque expr1 est évaluée à VRAI est expr2, et lorsque expr1 est évaluée à FAUX, la valeur est expr3.

Depuis PHP 5.3, la partie médiane de l'opérateur ternaire peut être omise. L'expression expr1 ? : expr3 renvoie expr1 si expr1 est évaluée à TRUE et expr3 sinon.

Exemple

Dans l'exemple suivant, il est jugé que la requête $_GET contient la valeur utilisateur Si tel est le cas, $_GET['user'] est renvoyé, sinon personne n'est renvoyé :

<?php
$test = '欢迎学习PHP';
// 普通写法
$username = isset($test) ? $test : 'nobody';
echo $username, PHP_EOL;
 
// PHP 5.3+ 版本写法
$username = $test ?: 'nobody';
echo $username, PHP_EOL;
?>

Bienvenue pour apprendre PHP

Bienvenue pour apprendre PHP

Remarque : PHP_EOL est un caractère de nouvelle ligne et est compatible avec les plates-formes plus grandes.

Il existe un opérateur de coalescence NULL supplémentaire dans la version PHP7+. L'exemple est le suivant :

<?php
// 如果 $_GET['user'] 不存在返回 'nobody'，否则返回 $_GET['user'] 的值
$username = $_GET['user'] ?? 'nobody';
// 类似的三元运算符
$username = isset($_GET['user']) ? $_GET['user'] : 'nobody';
?>

Opérateurs de comparaison combinés (PHP7+)

PHP7+ prend en charge les opérateurs de comparaison combinés, les exemples sont les suivants :

<?php
// 整型
echo 1 <=> 1; // 0
echo 1 <=> 2; // -1
echo 2 <=> 1; // 1
 
// 浮点型
echo 1.5 <=> 1.5; // 0
echo 1.5 <=> 2.5; // -1
echo 2.5 <=> 1.5; // 1
 
// 字符串
echo "a" <=> "a"; // 0
echo "a" <=> "b"; // -1
echo "b" <=> "a"; // 1
?>