Programmation PHP/Opérateurs

Un livre de Wikilivres.
Aller à : navigation, rechercher


Les opérateurs sont des symboles qui permettent de manipuler les variables.

Opérateurs arithmétiques[modifier | modifier le wikicode]

  • = Opérateur d'affectation
<?php
$un_chiffre = 4; //affectation de l'entier 4 à la variable un_chiffre
$un_mot = 'je suis fan des pâtes'; //affectation de la chaîne de caractères à la variable "un_mot"
?>
  • + : Opérateur d'addition
<?php
$mon_premier_chiffre = 3; //affectation du premier chiffre
$mon_deuxieme_chiffre = 4; //affectation du deuxieme chiffre
$resultat = $mon_premier_chiffre + $mon_deuxieme_chiffre; //affectation de l'addition des deux chiffres
echo $resultat; //affiche 3+4 soit 7
?>
  • - Opérateur de soustraction
<?php
$mon_premier_chiffre = 3; //affectation du premier chiffre
$mon_deuxieme_chiffre = 4; //affectation du deuxieme chiffre
$resultat = $mon_premier_chiffre - $mon_deuxieme_chiffre; //affectation de la soustraction des deux chiffres
echo $resultat; //affiche 3-4 soit -1
?>
  • * Opérateur de multiplication
<?php
$mon_premier_chiffre = 3; //affectation du premier chiffre
$mon_deuxieme_chiffre = 4; //affectation du deuxieme chiffre
$resultat = $mon_premier_chiffre * $mon_deuxieme_chiffre; //affectation de la multiplication des deux chiffres
echo $resultat; //affiche 3*4 soit 12
?>
  • / Opérateur de division
<?php
$mon_premier_chiffre = 3; //affectation du premier chiffre
$mon_deuxieme_chiffre = 4; //affectation du deuxieme chiffre
$resultat = $mon_premier_chiffre / $mon_deuxieme_chiffre; //affectation de la division des deux chiffres
echo $resultat; //affiche 3/4 soit 0,75
?>
  • % Opérateur modulo
<?php
$mon_premier_chiffre = 3; //affectation du premier chiffre
$mon_deuxieme_chiffre = 4; //affectation du deuxieme chiffre
$resultat = $mon_premier_chiffre % $mon_deuxieme_chiffre; //affectation du modulo  des deux chiffres
echo $resultat; //affiche 3 modulo 4 soit 3 (le modulo est le reste de la division euclidienne (sans virgule) )
?>

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

<?php
if ($nb % 3 == 0) { 
 // $nb est un multiple de trois
}
?>

Opérateurs logiques booléens[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

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)

Opérateur d'assignation[modifier | modifier le wikicode]

Ils permettent de simplifier l'écriture des assignations.

  • += 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')
  •  ??[1] renvoie l'opérande qui le précède s'il existe (isset), sinon l'opérande qui le suit.
  •  ?:[2] renvoie l'opérande qui le précède s'il existe et est non vide (empty), sinon l'opérande qui le suit.

Opérateur d'incrémentation[modifier | modifier le wikicode]

  • ++ : 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érateur de comparaison[modifier | modifier le wikicode]

  • == 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 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 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 différence : $x != 1 teste si la valeur $x est différente de 1.
  • === renvoie un booléen pour indiquer l'égalité à la fois de la valeur et du type.
  •  !== renvoie un booléen pour indiquer la différence ou de la valeur ou du type.
  • <=>[3] 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.

Opérateur divers[modifier | modifier le wikicode]

Opérateur ternaire[modifier | modifier le wikicode]

L'opérateur ? permet de renvoyer une valeur ou une autre en fonction d'un test. Par exemple :

$appreciation = ($note>10) ? "bon" : "mauvais";

qui est équivalent au bloc PHP suivant :

if ($note>10)
$appreciation="bon";
else
$appreciation="mauvais";

ou

if ($note > 10) {
    $appreciation = "bon";
} else {
    $appreciation = "mauvais";
}

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 à la place. Exemple :

print 1 ?: 0;
// 1

Opérateur objet[modifier | modifier le wikicode]

L'opérateur objet -> permet d'accéder aux propriétés d'un objet. Exemple :

print $voiture->couleur;
$voiture->repeindre('bleu');

Opérateur de résolution de portée[modifier | modifier le wikicode]

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

print $voiture::couleur;

Opérateur de contrôle d'erreur[modifier | modifier le wikicode]

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

print 1/0; //Warning: Division by zero, puis INF

print @(1/0); // INF

Opérateur de référence[modifier | modifier le wikicode]

"&" accolé avant une variable désigne sa référence[4], 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 :

public function archive(&$db)
{
    var_dump($db);
}

Opérateur de fonction variadique[modifier | modifier le wikicode]

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

Exemple :

public function somme(...$nombres) {
{
    $somme = 0;
    foreach ($nombres as $n) {
        $somme += $n;
    }
    return $somme;
}

echo somme(1, 2, 3);
echo somme(1, 2, 3, 4);

Précédence des opérateurs[modifier | modifier le wikicode]

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[5].

Références[modifier | modifier le wikicode]