PHP
Les opérateurs

Introduction

Remarques

Opérateurs de chaîne (. Et. =)

Il n'y a que deux opérateurs de chaîne:

• Concaténation de deux chaînes (point):

  $a = "a";
  $b = "b";
  $c = $a . $b; // $c => "ab"
  

• Affectation concaténante (point =):

  $a = "a";
  $a .= "b"; // $a => "ab"
  

Affectation de base (=)

$a = "some string";

$a la valeur d' some string .

Le résultat d'une expression d'affectation est la valeur attribuée. Notez qu'un seul signe égal = N'EST PAS à des fins de comparaison!

$a = 3;
$b = ($a = 5);

fait ce qui suit:

1. La ligne 1 attribue 3 à $a .
2. La ligne 2 attribue 5 à $a . Cette expression donne également la valeur 5 .
3. La ligne 2 affecte ensuite le résultat de l'expression entre parenthèses ( 5 ) à $b .

Ainsi: $a et $b ont maintenant la valeur 5 .

Affectation combinée (+ = etc)

Les opérateurs d'affectation combinée sont un raccourci pour une opération sur une variable et affectent ensuite cette nouvelle valeur à cette variable.

Arithmétique:

$a = 1;   // basic assignment
$a += 2; // read as '$a = $a + 2'; $a now is (1 + 2) => 3
$a -= 1; // $a now is (3 - 1) => 2
$a *= 2; // $a now is (2 * 2) => 4
$a /= 2; // $a now is (16 / 2) => 8
$a %= 5; // $a now is (8 % 5) => 3 (modulus or remainder)

// array +
$arrOne = array(1);
$arrTwo = array(2);
$arrOne += $arrTwo;

Traitement de plusieurs tableaux ensemble

$a **= 2; // $a now is (4 ** 2) => 16 (4 raised to the power of 2)

Concaténation combinée et affectation d'une chaîne:

$a = "a";
$a .= "b"; // $a => "ab"

Opérateurs d'assignation binaire binaire combinés:

$a = 0b00101010;  // $a now is 42
$a &= 0b00001111; // $a now is (00101010 & 00001111) => 00001010 (bitwise and)
$a |= 0b00100010; // $a now is (00001010 | 00100010) => 00101010 (bitwise or)
$a ^= 0b10000010; // $a now is (00101010 ^ 10000010) => 10101000 (bitwise xor)
$a >>= 3;         // $a now is (10101000 >> 3) => 00010101 (shift right by 3)
$a <<= 1;         // $a now is (00010101 << 1) => 00101010 (shift left by 1)

Modification de la priorité de l'opérateur (avec des parenthèses)

L'ordre dans lequel les opérateurs sont évalués est déterminé par la priorité de l' opérateur (voir aussi la section Remarques).

Dans

$a = 2 * 3 + 4;

$a obtient une valeur de 10 car 2 * 3 est évalué en premier (la multiplication a une priorité plus élevée que l'addition), ce qui donne un sous-résultat de 6 + 4 , ce qui équivaut à 10.

La préséance peut être modifiée en utilisant des parenthèses: dans

$a = 2 * (3 + 4);

$a obtient une valeur de 14 car (3 + 4) est évalué en premier.

Association

Association de gauche

Si la précédence de deux opérateurs est égale, l'associativité détermine le regroupement (voir aussi la section Remarques):

$a = 5 * 3 % 2; // $a now is (5 * 3) % 2 => (15 % 2) => 1

* Et % ont la même priorité et associativité gauche. Parce que la multiplication se produit en premier (à gauche), elle est groupée.

$a = 5 % 3 * 2; // $a now is (5 % 3) * 2 => (2 * 2) => 4

Maintenant, l'opérateur de module se produit en premier (à gauche) et est donc regroupé.

Association de droit

$a = 1;
$b = 1;
$a = $b += 1;

Les deux $a et $b ont maintenant la valeur 2 car $b += 1 est groupé et le résultat ( $b est 2 ) est assigné à $a .

Opérateurs de comparaison

Égalité

Pour le test d'égalité de base, l'opérateur égal == est utilisé. Pour des vérifications plus complètes, utilisez l'opérateur identique === .

L'opérateur identique fonctionne de la même manière que l'opérateur égal, nécessitant que ses opérandes aient la même valeur, mais exige également qu'ils aient le même type de données.

Par exemple, l'exemple ci-dessous affichera «a et b sont égaux», mais pas «a et b sont identiques».

$a = 4;
$b = '4';
if ($a == $b) {
    echo 'a and b are equal'; // this will be printed
}
if ($a === $b) {
    echo 'a and b are identical'; // this won't be printed
}

Lors de l'utilisation de l'opérateur égal, les chaînes numériques sont converties en entiers.

Comparaison d'objets

=== compare deux objets en vérifiant s'ils sont exactement la même instance . Cela signifie que new stdClass() === new stdClass() résout en false, même si elles sont créées de la même manière (et ont exactement les mêmes valeurs).

== compare deux objets en vérifiant de manière récursive s'ils sont égaux ( égaux en profondeur ). Cela signifie que pour $a == $b , si $a et $b sont:

1. de même classe
2. avoir les mêmes propriétés, y compris les propriétés dynamiques
3. pour chaque propriété $property ensemble de $property , $a->property == $b->property est vraie (donc cochée de manière récursive).

Autres opérateurs couramment utilisés

Ils comprennent:

1. Supérieur à ( > )
2. Inférieur à ( < )
3. Supérieur ou égal à ( >= )
4. Inférieur ou égal à ( <= )
5. Pas égal à ( != )
6. Pas identique à ( !== )

1. Supérieur: $a > $b , retourne true si $a « valeur s est supérieure à de $b , sinon retourne false.

Exemple :

var_dump(5 > 2); // prints bool(true)
var_dump(2 > 7); // prints bool(false)

2. Moindre que: $a < $b , retourne true si $a valeur de plus petite est celle de $b , sinon retourne false.

Exemple :

var_dump(5 < 2); // prints bool(false)
var_dump(1 < 10); // prints bool(true)

3. Supérieur ou égal à : $a >= $b , renvoie true si la $a est supérieure à $b ou égale à $b , sinon retourne false .

Exemple :

var_dump(2 >= 2); // prints bool(true)
var_dump(6 >= 1); // prints bool(true)
var_dump(1 >= 7); // prints bool(false)

4. Plus petit que ou égal à : $a <= $b , renvoie true si la $a est inférieure à $b ou égale à $b , sinon retourne false .

Exemple :

var_dump(5 <= 5); // prints bool(true)
var_dump(5 <= 8); // prints bool(true)
var_dump(9 <= 1); // prints bool(false)

5/6. Non égal / identique à: Pour reprendre l'exemple précédent sur l'égalité, l'exemple ci-dessous affiche «a et b ne sont pas identiques», mais pas «a et b ne sont pas égaux».

$a = 4;
$b = '4';
if ($a != $b) {
    echo 'a and b are not equal'; // this won't be printed
}
if ($a !== $b) {
    echo 'a and b are not identical'; // this will be printed
}

Opérateur de vaisseau spatial (<=>)

PHP 7 introduit un nouveau type d'opérateur, qui peut être utilisé pour comparer des expressions. Cet opérateur renverra -1, 0 ou 1 si la première expression est inférieure, égale ou supérieure à la deuxième expression.

// Integers
print (1 <=> 1); // 0
print (1 <=> 2); // -1
print (2 <=> 1); // 1

// Floats
print (1.5 <=> 1.5); // 0
print (1.5 <=> 2.5); // -1
print (2.5 <=> 1.5); // 1
 
// Strings
print ("a" <=> "a"); // 0
print ("a" <=> "b"); // -1
print ("b" <=> "a"); // 1

Les objets ne sont pas comparables, ce qui entraîne un comportement indéfini.

Cet opérateur est particulièrement utile lors de l'écriture d'une fonction de comparaison définie par l'utilisateur à l'aide de usort , uasort ou uksort . Étant donné un tableau d'objets à trier par leur propriété de weight , par exemple, une fonction anonyme peut utiliser <=> pour renvoyer la valeur attendue par les fonctions de tri.

usort($list, function($a, $b) { return $a->weight <=> $b->weight; });

En PHP 5, cela aurait nécessité une expression plus élaborée.

usort($list, function($a, $b) {
    return $a->weight < $b->weight ? -1 : ($a->weight == $b->weight ? 0 : 1);
});

Opérateur de coalescence nul (??)

La coalescence nulle est un nouvel opérateur introduit dans PHP 7. Cet opérateur retourne son premier opérande s'il est défini et non NULL . Sinon, il retournera son deuxième opérande.

L'exemple suivant:

$name = $_POST['name'] ?? 'nobody';

est équivalent aux deux:

if (isset($_POST['name'])) {
    $name = $_POST['name'];
} else {
    $name = 'nobody';
}

et:

$name = isset($_POST['name']) ? $_POST['name'] : 'nobody'; 

Cet opérateur peut également être chaîné (avec une sémantique associative à droite):

$name = $_GET['name'] ?? $_POST['name'] ?? 'nobody';

qui est équivalent à:

if (isset($_GET['name'])) {
    $name = $_GET['name'];
} elseif (isset($_POST['name'])) {
    $name = $_POST['name'];
} else {
    $name = 'nobody';
}

Remarque:
Lors de l'utilisation d'un opérateur de coalescence sur une concaténation de chaîne, n'oubliez pas d'utiliser des parenthèses ()

$firstName = "John";
$lastName = "Doe";
echo $firstName ?? "Unknown" . " " . $lastName ?? "";

Cela ne produira que John , et si son $ firstName est null et que $ lastName est Doe il affichera Unknown Doe . Pour sortir John Doe , nous devons utiliser des parenthèses comme ceci.

$firstName = "John";
$lastName = "Doe";
echo ($firstName ?? "Unknown") . " " . ($lastName ?? "");

Cela affichera John Doe au lieu de John uniquement.

instanceof (type opérateur)

Pour vérifier si un objet est d'une certaine classe, l'opérateur (binaire) instanceof peut être utilisé depuis la version 5 de PHP.

Le premier paramètre (à gauche) est l'objet à tester. Si cette variable n'est pas un objet, instanceof renvoie toujours false . Si une expression constante est utilisée, une erreur est générée.

Le second paramètre (à droite) est la classe à comparer. La classe peut être fournie comme nom de classe lui-même, une variable de chaîne contenant le nom de la classe (pas une constante de chaîne!) Ou un objet de cette classe.

class MyClass {
}

$o1 = new MyClass();
$o2 = new MyClass();
$name = 'MyClass';

// in the cases below, $a gets boolean value true
$a = $o1 instanceof MyClass;
$a = $o1 instanceof $name;
$a = $o1 instanceof $o2;

// counter examples:
$b = 'b';
$a = $o1 instanceof 'MyClass'; // parse error: constant not allowed
$a = false instanceof MyClass; // fatal error: constant not allowed
$a = $b instanceof MyClass;    // false ($b is not an object)

instanceof peut également être utilisé pour vérifier si un objet appartient à une classe qui étend une autre classe ou implémente une interface:

interface MyInterface {
}

class MySuperClass implements MyInterface {
}

class MySubClass extends MySuperClass {
}

$o = new MySubClass();

// in the cases below, $a gets boolean value true    
$a = $o instanceof MySubClass;
$a = $o instanceof MySuperClass;
$a = $o instanceof MyInterface;

Pour vérifier si un objet n'est pas d'une classe, l'opérateur not ( ! ) Peut être utilisé:

class MyClass {
}

class OtherClass {
}

$o = new MyClass();
$a = !$o instanceof OtherClass; // true

Notez que les parenthèses autour de $o instanceof MyClass ne sont pas nécessaires car instanceof a une priorité plus élevée que ! , bien que cela puisse rendre le code plus lisible avec des parenthèses.

Mises en garde

Si une classe n'existe pas, les fonctions de chargement automatique enregistrées sont appelées pour tenter de définir la classe (il s'agit d'un sujet ne relevant pas de cette partie de la documentation!). Dans les versions de PHP antérieures à 5.1.0, l’opérateur instanceof déclencherait également ces appels, définissant ainsi la classe (et si la classe ne pouvait pas être définie, une erreur fatale se produirait). Pour éviter cela, utilisez une chaîne:

// only PHP versions before 5.1.0!
class MyClass {
}

$o = new MyClass();
$a = $o instanceof OtherClass; // OtherClass is not defined!
// if OtherClass can be defined in a registered autoloader, it is actually
// loaded and $a gets boolean value false ($o is not a OtherClass)
// if OtherClass can not be defined in a registered autoloader, a fatal
// error occurs.

$name = 'YetAnotherClass';
$a = $o instanceof $name; // YetAnotherClass is not defined!
// $a simply gets boolean value false, YetAnotherClass remains undefined.

Depuis PHP version 5.1.0, les autochargeurs enregistrés ne sont plus appelés dans ces situations.

Anciennes versions de PHP (avant 5.0)

Dans les anciennes versions de PHP (avant 5.0), la fonction is_a peut être utilisée pour déterminer si un objet appartient à une classe. Cette fonction est obsolète dans la version 5 de PHP et non précisée dans la version 5.3.0 de PHP.

Opérateur Ternaire (? :)

L'opérateur ternaire peut être considéré comme une instruction en ligne if . Il se compose de trois parties. L' operator et deux résultats. La syntaxe est la suivante:

$value = <operator> ? <true value> : <false value>

Si l' operator est évalué comme true , la valeur du premier bloc sera renvoyée ( <true value> ), sinon la valeur du deuxième bloc sera renvoyée ( <false value> ). Comme nous définissons $value sur le résultat de notre opérateur ternaire, il stockera la valeur renvoyée.

Exemple:

$action = empty($_POST['action']) ? 'default' : $_POST['action'];

$action contient la chaîne 'default' si elle est empty($_POST['action']) évaluée à true. Sinon, il contiendrait la valeur de $_POST['action'] .

L'expression (expr1) ? (expr2) : (expr3) évaluée à expr2 si expr1 évaluée à true et expr3 si expr1 évaluée à false .

Il est possible de laisser de côté la partie centrale de l'opérateur ternaire. Expression expr1 ?: expr3 renvoie expr1 si expr1 évaluée à TRUE et expr3 sinon. ?: est souvent appelé opérateur Elvis .

Cela se comporte comme l' opérateur Null Coalescing ?? , sauf que ?? nécessite l'opérande gauche pour être exactement null alors ?: tente de résoudre l'opérande gauche dans un booléen et vérifier si elle décide de booléen false .

Exemple:

function setWidth(int $width = 0){
    $_SESSION["width"] = $width ?: getDefaultWidth();
}

Dans cet exemple, setWidth accepte un paramètre de largeur, ou 0 par défaut, pour modifier la valeur de session de largeur. Si $width est getDefaultWidth() 0 (si $width n'est pas fourni), ce qui se traduira par une valeur booléenne false, la valeur de getDefaultWidth() est utilisée à la place. La fonction getDefaultWidth() ne sera pas appelée si $width ne s'est pas résolu en booléen false.

Reportez-vous à la section Types pour plus d'informations sur la conversion de variables en valeurs booléennes.

Opérateurs d'incrémentation (++) et de décrémentation (-)

Les variables peuvent être incrémentées ou décrémentées de 1 avec ++ ou -- , respectivement. Ils peuvent soit précéder ou succéder à des variables et varier légèrement sémantiquement, comme indiqué ci-dessous.

$i = 1;
echo $i; // Prints 1

// Pre-increment operator increments $i by one, then returns $i
echo ++$i; // Prints 2

// Pre-decrement operator decrements $i by one, then returns $i
echo --$i; // Prints 1

// Post-increment operator returns $i, then increments $i by one
echo $i++; // Prints 1 (but $i value is now 2)

// Post-decrement operator returns $i, then decrements $i by one
echo $i--; // Prints 2 (but $i value is now 1)

Vous trouverez plus d'informations sur l'incrémentation et la décrémentation des opérateurs dans la documentation officielle .

Opérateur d'exécution (``)

L'opérateur d'exécution PHP est constitué de backticks (``) et permet d'exécuter des commandes shell. La sortie de la commande sera renvoyée et pourra donc être stockée dans une variable.

// List files
$output = `ls`;
echo "<pre>$output</pre>";

Notez que l'opérateur d'exécution et shell_exec() donneront le même résultat.

Opérateurs logiques (&& / AND et || / OR)

En PHP, il existe deux versions des opérateurs logiques AND et OR.

Notez que les && et || les opérateurs ont une préséance supérieure à and et or . Voir le tableau ci-dessous:

À cause de cela, il est plus sûr d'utiliser && et || au lieu de and et or .

Opérateurs sur les bits

Préfixe opérateurs binaires

Les opérateurs binaires sont comme des opérateurs logiques mais exécutés par bit plutôt que par valeur booléenne.

// bitwise NOT ~: sets all unset bits and unsets all set bits
printf("%'06b", ~0b110110); // 001001

Opérateurs Bitmask-Bitmask

Bitwise AND & : un bit est défini uniquement s'il est défini dans les deux opérandes

printf("%'06b", 0b110101 & 0b011001); // 010001

Bit à bit OU | : un bit est défini s'il est défini dans l'un ou l'autre des opérandes

printf("%'06b", 0b110101 | 0b011001); // 111101

Bit-bit XOR ^ : un bit est défini s'il est défini dans un opérande et n'est pas défini dans un autre opérande, c'est-à-dire uniquement si ce bit est dans un état différent dans les deux opérandes

printf("%'06b", 0b110101 ^ 0b011001); // 101100

Exemple d'utilisation de masques de bits

Ces opérateurs peuvent être utilisés pour manipuler des masques de bits. Par exemple:

file_put_contents("file.log", LOCK_EX | FILE_APPEND);

Ici, le | L'opérateur est utilisé pour combiner les deux masques de bits. Bien que + a le même effet, | souligne que vous combinez des masques de bits, sans ajouter deux entiers scalaires normaux.

class Foo{
    const OPTION_A = 1;
    const OPTION_B = 2;
    const OPTION_C = 4;
    const OPTION_A = 8;

    private $options = self::OPTION_A | self::OPTION_C;

    public function toggleOption(int $option){
        $this->options ^= $option;
    }

    public function enable(int $option){
        $this->options |= $option; // enable $option regardless of its original state
    }

    public function disable(int $option){
        $this->options &= ~$option; // disable $option regardless of its original state,
                                    // without affecting other bits
    }

    /** returns whether at least one of the options is enabled */
    public function isOneEnabled(int $options) : bool{
        return $this->options & $option !== 0;
        // Use !== rather than >, because 
        // if $options is about a high bit, we may be handling a negative integer
    }

    /** returns whether all of the options are enabled */
    public function areAllEnabled(int $options) : bool{
        return ($this->options & $options) === $options;
        // note the parentheses; beware the operator precedence
    }
}

Cet exemple (en supposant $option contient toujours un seul bit) utilise:

• l'opérateur ^ pour commuter facilement les masques de bits.
• le | opérateur pour mettre un peu en négligeant son état d'origine ou d'autres bits
• l'opérateur ~ pour convertir un entier avec un seul bit mis en un entier avec un seul bit non défini
• l'opérateur & pour supprimer un peu, en utilisant ces propriétés de & :
  • Puisque &= avec un bit défini ne fera rien ( (1 & 1) === 1 , (0 & 1) === 0 ), faire &= avec un entier avec un seul bit non défini ne fera que supprimer ce bit , n'affectant pas les autres bits.
  • &= avec un bit non défini supprimera ce bit ( (1 & 0) === 0 , (0 & 0) === 0 )
• L'utilisation de l'opérateur & avec un autre masque de bits élimine tous les autres bits non définis dans ce masque.
  • Si la sortie a des bits définis, cela signifie que l'une des options est activée.
  • Si la sortie contient tous les bits du masque de bits, cela signifie que toutes les options du masque de bits sont activées.

Gardez à l' esprit que ces opérateurs de comparaison: ( < > <= >= == === != !== <> <=> ) ont une priorité plus élevée que ces opérateurs bitmask-bitmask: ( | ^ & ). Étant donné que les résultats de comparaison sont souvent comparés à l'aide de ces opérateurs de comparaison, il s'agit d'un piège courant à prendre en compte.

Opérateurs de décalage de bits

Décalage bit à gauche << : décaler tous les bits vers la gauche (plus significatif) du nombre de pas donné et rejeter les bits dépassant la taille int

<< $x équivaut à supprimer les plus hauts bits $x et à multiplier par la puissance $x de 2

printf("%'08b", 0b00001011<< 2); // 00101100

assert(PHP_INT_SIZE === 4); // a 32-bit system
printf("%x, %x", 0x5FFFFFFF << 2, 0x1FFFFFFF << 4); // 7FFFFFFC, FFFFFFFF

Décalage binaire à droite >> : supprimer le décalage le plus bas et décaler les bits restants vers la droite (moins significatif)

>> $x équivaut à diviser par la puissance $x th de 2 et ignorer la partie non entière

printf("%x", 0xFFFFFFFF >> 3); // 1FFFFFFF

Exemple d'utilisations du décalage de bits:

Division rapide par 16 (meilleure performance que /= 16 )

$x >>= 4;

Sur les systèmes 32 bits, cela supprime tous les bits de l'entier, en définissant la valeur sur 0. Sur les systèmes 64 bits, cela supprime les 32 bits les plus significatifs et conserve le moins

$x = $x << 32 >> 32;

32 bits significatifs, équivalent à $x & 0xFFFFFFFF

Remarque: Dans cet exemple, printf("%'06b") est utilisé. Il délivre la valeur en 6 chiffres binaires.

Opérateurs d'objets et de classes

Les membres des objets ou des classes peuvent être accédés en utilisant l'opérateur d'objet ( -> ) et l'opérateur de classe ( :: .

class MyClass {
    public $a = 1;
    public static $b = 2;
    const C = 3;
    public function d() { return 4; }
    public static function e() { return 5; }
}

$object = new MyClass();
var_dump($object->a);   // int(1)
var_dump($object::$b);  // int(2)
var_dump($object::C);   // int(3)
var_dump(MyClass::$b);  // int(2)
var_dump(MyClass::C);   // int(3)
var_dump($object->d()); // int(4)
var_dump($object::d()); // int(4)
var_dump(MyClass::e()); // int(5)
$classname = "MyClass";
var_dump($classname::e()); // also works! int(5)

Notez qu'après l'opérateur de l'objet, le $ ne doit pas être écrit ( $object->a au lieu de $object->$a ). Pour l'opérateur de classe, ce n'est pas le cas et le $ est nécessaire. Pour une constante définie dans la classe, le $ n'est jamais utilisé.

Notez également que var_dump(MyClass::d()); n'est autorisé que si la fonction d() ne fait pas référence à l'objet:

class MyClass {
    private $a = 1;
    public function d() {
        return $this->a;
    }
}

$object = new MyClass();
var_dump(MyClass::d());   // Error!

Cela provoque une erreur PHP fatale: erreur non détectée: utilisation de $ this lorsque le contexte de l'objet n'est pas atteint

Ces opérateurs ont laissé une associativité, qui peut être utilisée pour «chaîner»:

class MyClass {
    private $a = 1;
    
    public function add(int $a) {
        $this->a += $a;
        return $this;
    }
    
    public function get() {
        return $this->a;
    }
}

$object = new MyClass();
var_dump($object->add(4)->get());  // int(5)

Ces opérateurs ont la priorité la plus élevée (ils ne sont même pas mentionnés dans le manuel), encore plus que le clone . Ainsi:

class MyClass {
    private $a = 0;
    public function add(int $a) {
        $this->a += $a;
        return $this;
    }
    public function get() {
        return $this->a;
    }
}

$o1 = new MyClass();
$o2 = clone $o1->add(2);
var_dump($o1->get()); // int(2)
var_dump($o2->get()); // int(2)

La valeur de $o1 est ajoutée avant que l'objet ne soit cloné!

Notez que l'utilisation de parenthèses pour influencer la préséance ne fonctionnait pas dans PHP version 5 et antérieure (c'est le cas en PHP 7):

// using the class MyClass from the previous code
$o1 = new MyClass();
$o2 = (clone $o1)->add(2);  // Error in PHP 5 and before, fine in PHP 7
var_dump($o1->get()); // int(0) in PHP 7
var_dump($o2->get()); // int(2) in PHP 7