# Programmation PHP/Opérateurs

* Introduction
* Installer PHP
* Composer
* IDE
** PhpStorm
** NetBeans
** Eclipse
** Visual Studio Code
* Bases du langage
** Commentaires
** Premier programme
** Variables
** Variables superglobales
** Constantes
** Opérateurs
** Fonctions
** Tableaux
** Structures de contrôle
** Boucles
* Programmation avancée
** Dates
** Sessions
** Cookies
** Cache
*** Memcached
*** Redis
** Formulaire
** Fichiers
*** Objets COM
*** Images
** Mails
** Sécurité
** Programmation orientée objet
** Bases de données
*** Microsoft SQL Server
*** MySQL
*** PDO
*** SQLite
** Expressions rationnelles
** Code de haute qualité
*** Analyse statique de programmes
** Exceptions
** Xdebug
** Mots réservés
* Apprendre par l'exemple
** Utilisation de variables
** Un sommaire simple
** Interaction avec un formulaire
** Afficher le résultat d'une requête BDD
** Modifier une table
** Faire un livre d'or
** Faire un mini forum de discussion
** Parser avec DomXml
** Coder en MVC
** Faire un webservice
** Vérification RIO
** AJAX
** Sommaire en Ajax
** Mise à jour périodique d'un cadre
** Mini CMS
** Introduction
** Développement
*** Les couches choisies
*** Code de service
*** Modélisation
*** Implémentation
*** La vue
*** Ajaxification
*** Premier noyau
*** Fournir les données
*** IHM
** Rétrospective
** Conclusion
* 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
* Introduction
* Installer PHP
* Composer
* IDE
** PhpStorm
** NetBeans
** Eclipse
** Visual Studio Code
* Bases du langage
** Commentaires
** Premier programme
** Variables
** Variables superglobales
** Constantes
** Opérateurs
** Fonctions
** Tableaux
** Structures de contrôle
** Boucles
* Programmation avancée
** Dates
** Sessions
** Cookies
** Cache
*** Memcached
*** Redis
** Formulaire
** Fichiers
*** Objets COM
*** Images
** Mails
** Sécurité
** Programmation orientée objet
** Bases de données
*** Microsoft SQL Server
*** MySQL
*** PDO
*** SQLite
** Expressions rationnelles
** Code de haute qualité
*** Analyse statique de programmes
** Exceptions
** Xdebug
** Mots réservés
* Apprendre par l'exemple
** Utilisation de variables
** Un sommaire simple
** Interaction avec un formulaire
** Afficher le résultat d'une requête BDD
** Modifier une table
** Faire un livre d'or
** Faire un mini forum de discussion
** Parser avec DomXml
** Coder en MVC
** Faire un webservice
** Vérification RIO
** AJAX
** Sommaire en Ajax
** Mise à jour périodique d'un cadre
** Mini CMS
** Introduction
** Développement
*** Les couches choisies
*** Code de service
*** Modélisation
*** Implémentation
*** La vue
*** Ajaxification
*** Premier noyau
*** Fournir les données
*** IHM
** Rétrospective
** Conclusion
* 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
[ Modifier le sommaire ]
Les opérateurs sont des symboles qui permettent de manipuler les variables.

## Opérateurs arithmétiques
### + Opérateur d'addition

Si les opérandes sont des tableaux, "+" est l'opérateur union.

### % Opérateur modulo

Il sert à tester si un nombre est le multiple d'un autre :

## Opérateurs logiques booléens

Les opérateurs logiques agissent sur les types booléens (true ou false).
* ! : négation. Transforme false en true et true en false.
* && : opérateur "et".
* and : opérateur "et" de moindre priorité.
* || : opérateur "ou"
* or : opérateur "ou" de moindre priorité.

## Opérateurs logiques bit à bit

Les opérateurs logiques bit à bit agissent sur chaque bit des valeurs entières.
* ~ Négation : 0 -> 1 et 1 -> 0
* & Opérateur et (and)
* | Opérateur ou (or)
* ^ Opérateur ou exclusif (xor)
* >> : décalage à droite (division par deux)
* << : décalage à gauche (multiplication par deux).

## Opérateurs d'assignation

Ils permettent de simplifier l'écriture des assignations.
* ??= : opérateur de coalescence nul
* += additionne deux valeurs et stocke le résultat dans la variable ($x += 5 équivaut à $x = $x+5)
* -= soustrait deux valeurs et stocke le résultat dans la variable ($x -= 5 équivaut à $x = $x-5)
* *= multiplie deux valeurs et stocke le résultat dans la variable ($x *= 5 équivaut à $x = $x*5)
* /= divise deux valeurs et stocke le résultat dans la variable ($x /= 5 équivaut à $x = $x/5)
* %= donne le reste de la division de deux valeurs et stocke le résultat dans la variable ($x %=5 équivaut à $x = $x%5)
* |= effectue un OU logique entre deux valeurs et stocke le résultat dans la variable ($x |=5 équivaut à $x = $x|5)
* ^= effectue un OU exclusif entre deux valeurs et stocke le résultat dans la variable ($x ^= 5 équivaut à $x = $x^5)
* &= effectue un ET logique entre deux valeurs et stocke le résultat dans la variable ($x &= 5 équivaut à $x = $x&5)
* .= concatène deux chaînes et stocke le résultat dans la variable ($x .= 'test' équivaut à $x = $x.'test')

## Opérateurs d'incrémentation

* ++ : incrémente de 1 la valeur de la variable si "$x = 1 ", "$x++" vaut "++$x" qui vaut "2".
* -- : décrémente de 1 la valeur de la variable si "$x = 2", "$x--" vaut "--$x" qui vaut "1".
Ces opérateurs sont très utiles dans les boucles (notamment for).

## Opérateurs de comparaison

* == renvoie un booléen pour indiquer l'égalité (ce n'est pas =) : $x == 1 teste si la valeur $x est égale à 1.
* === renvoie un booléen pour indiquer à l'identique, c'est-à-dire l'égalité à la fois de la valeur et du type.
* != (alias <>) renvoie un booléen pour indiquer la différence : $x != 1 teste si la valeur $x est différente de 1.
* !== renvoie un booléen pour indiquer la différence ou de la valeur ou du type.
* > renvoie un booléen pour indiquer la supériorité stricte si $x > 1 teste si la valeur $x est strictement supérieure à 1.
* < renvoie un booléen pour indiquer l'infériorité stricte : $x < 1 teste si la valeur $x est strictement inférieure à 1.
* >= renvoie un booléen pour indiquer la supériorité-égalité si $x >= 1 teste si la valeur $x est supérieure ou égale à 1.
* <= renvoie un booléen pour indiquer l'infériorité-égalité si $x <= 1 teste si la valeur $x est inférieure ou égale à 1.
* <=> renvoie 1 si le premier opérande est supérieur, 0 s'il est égal, et -1 s'il est inférieur au deuxième.
Si les opérandes sont des tableaux :
* "==" est l'opérateur d'égalité (mêmes paires clés/valeurs).
* "===" vérifie aussi le type et l'ordre des paires clés/valeurs.
* "!=" (alias "<>") est l'opérateur d'inégalité.
* "!==" est l'opérateur non identique.

## Opérateurs divers
### Opérateur ?

L'opérateur ? permet de renvoyer une valeur ou une autre en fonction d'un test.
* ?? (depuis PHP 7) (Null Coalescing Operator) opérateur binaire qui renvoie l'opérande qui le précède s'il existe (isset), sinon l'opérande qui le suit.
* ?: (depuis PHP 7) opérateur ternaire qui renvoie l'opérande qui le précède s'il existe et est non vide (empty), sinon l'opérande qui le suit.
Par exemple :
qui est équivalent au bloc PHP suivant :
Toutefois il présente un autre avantage que sa concision : la stratégie d'évaluation de cet opérateur ne calcule pas le "else" si le script n'a pas besoin d'y aller. Il devient donc moins gourmand en ressources.
En l'absence de premier résultat, le ternaire renvoie l'expression comparée si non nulle ou vide. Exemple :

### -> Opérateur objet

L'opérateur objet -> permet d'accéder aux propriétés d'un objet (variables et méthodes de classe). Exemple :
Depuis PHP 8 il a une version qui renvoie null si l'objet est null :

### :: Opérateur de résolution de portée

L'opérateur ::, également appelé en PHP Paamayim Nekudotayim, permet d'accéder aux membres statiques ou constants d'une classe. Exemple :

### @ Opérateur de contrôle d'erreur

L'arobase permet d'ignorer les erreurs de l'expression qui le suit. Ex :

### & Opérateur de référence

"&" accolé avant une variable désigne sa référence, qui est en quelque sorte un pointeur en lecture seule. Elles sont utiles par exemple pour éviter copier un grand tableau en mémoire quand il est en paramètre d'une fonction. Exemple :
Son utilisation pour les fonctions sera détaillée dans le chapitre sur les fonctions, mais on peut aussi l'utiliser dans les boucles.

### ... Opérateur de fonction variadique

Depuis PHP 5.6, "..." dans la liste des arguments d'une fonction indique que ceux-ci sont d'un nombre variable.
Exemple :

## Précédence des opérateurs

Quand une opérande est entourée de deux opérateurs (ex : 1 + 2 * 3 = 7), des règles de priorités s'appliquent systématiquement pour résoudre les opérations.
Site source légèrement incomplet, ex : $$.

## Références

* ↑ https://www.php.net/manual/fr/language.operators.array.php
* ↑ https://www.php.net/manual/fr/function.fmod.php
* ↑ https://www.php.net/manual/fr/language.operators.assignment.php
* ↑ PHP>=7
* ↑ https://wiki.php.net/rfc/isset_ternary
* ↑ http://php.net/manual/fr/language.references.php
* ↑ https://www.php.net/manual/fr/language.operators.precedence.php