and

L'opérateur and en PHP

PHP dispose de deux opérateurs ET logiques : && et and. Les deux renvoient true uniquement lorsque les deux opérandes s'évaluent à true, et false dans le cas contraire. La différence réside dans la précédence des opérateurs : && lie beaucoup plus fortement que and. Cette unique différence est responsable de presque tous les bugs impliquant and, c'est pourquoi cette page la couvre avec soin.

Ce guide explique la syntaxe de and, le fonctionnement de l'évaluation en court-circuit, pourquoi la précédence est importante, et le piège classique de l'affectation à éviter.

Syntaxe

L'opérateur and combine deux conditions en une seule expression booléenne. Il est le plus souvent utilisé à l'intérieur d'une instruction if pour exiger que plusieurs conditions soient vérifiées simultanément :

<?php

if (condition1 and condition2) {
  // Runs only if BOTH conditions are true
}

Le bloc s'exécute uniquement lorsque les deux opérandes sont vrais. L'expression condition1 and condition2 s'évalue elle-même en un boolean (true ou false), vous pouvez donc stocker le résultat dans une variable — mais attention au piège de l'affectation décrit ci-dessous.

Comportement de and

PHP évalue and de gauche à droite et effectue un court-circuit : si l'opérande gauche est faux, l'opérande droit n'est jamais évalué, car le résultat ne peut plus être true. Cela est utile pour protéger une vérification coûteuse ou risquée derrière une vérification bon marché :

<?php

$user = null;

// isLoggedIn() is never called because $user is null,
// so we avoid a "method on null" error.
if ($user !== null and $user->isLoggedIn()) {
  echo "Welcome back." . PHP_EOL;
} else {
  echo "Please log in." . PHP_EOL;
}

// Output: Please log in.

Exemples

<?php

// Example 1
$age = 25;
$hasID = true;

if ($age >= 18 and $hasID) {
  echo "You may enter the club." . PHP_EOL;
}

// Output: You may enter the club.

// Example 2
$username = "admin";
$password = "password123";

if ($username == "admin" and $password == "password123") {
  echo "Access granted." . PHP_EOL;
}

// Output: Access granted.

// Example 3
$isWeekday = true;
$time = "12:30";

if ($isWeekday and $time >= "09:00" and $time <= "17:00") {
  echo "The office is open." . PHP_EOL;
}

// Output: The office is open.

Chaque if combine plusieurs conditions avec and, et le bloc s'exécute uniquement lorsque toutes sont vraies.

Précédence : and vs &&

and a une précédence très faible — inférieure à ||, inférieure à =, et inférieure à or (and est supérieur à or, mais tous deux se situent en bas du tableau de précédence). L'opérateur &&, en revanche, se situe haut — juste en dessous des opérateurs de comparaison. Mélanger des opérateurs logiques avec de l'arithmétique, des affectations ou or nécessite donc souvent des parenthèses.

Lorsque and et or apparaissent ensemble, and est évalué en premier :

<?php

$age = 16;
$hasID = false;
$isStudent = true;

// Reads as: ($age >= 18 and $hasID) or $isStudent
if ($age >= 18 and $hasID or $isStudent) {
  echo "Access granted." . PHP_EOL;
}

// Output: Access granted.

Ajoutez des parenthèses pour rendre le regroupement explicite ou pour le remplacer :

<?php

$age = 16;
$hasID = false;
$isStudent = true;

// Force the OR to be checked first
if ($age >= 18 and ($hasID or $isStudent)) {
  echo "Access granted." . PHP_EOL;
} else {
  echo "Access denied." . PHP_EOL;
}

// Output: Access denied.

Le piège de l'affectation

C'est le piège qui pousse la plupart des développeurs à préférer &&. Parce que and a une précédence inférieure à =, l'affectation se produit avant le and :

<?php

$a = true;
$b = false;

// Parsed as: ($result = $a) and $b
$result = $a and $b;
var_dump($result); // bool(true)  — NOT false!

// With && (higher precedence than =) you get what you expect:
$result = $a && $b;
var_dump($result); // bool(false)

Dans le premier cas, $result reçoit la valeur de $a (true) en premier, et la partie and $b est évaluée puis ignorée. Utilisez && pour les expressions booléennes, et réservez and aux cas où la faible précédence est intentionnelle.

Quand utiliser and

• Préférez && pour la valeur d'une expression booléenne (tout ce que vous affectez ou retournez).
• and est pratique comme connecteur de flux de contrôle où sa faible précédence est sans danger et se lit bien, par exemple : $db->connect() or die('No DB') utilise or de la même façon.
• Dans une condition if (...) sans = ni or mélangés, and et && se comportent de manière identique.

Opérateurs associés

• or — OU logique (vrai si l'un ou l'autre opérande est vrai).
• xor — OU exclusif logique (vrai si exactement un opérande est vrai).
• Opérateurs PHP — la référence complète des opérateurs.
• PHP if...else...elseif — construction de la logique conditionnelle.

Conclusion

L'opérateur and combine des conditions et renvoie true uniquement lorsque les deux sont vraies, avec court-circuit sur un opérande gauche faux. Il est fonctionnellement identique à && mais a une précédence bien plus faible, ce qui explique précisément pourquoi $x = $a and $b ne fait pas ce qu'il semble faire. Utilisez && pour les valeurs booléennes et choisissez and délibérément lorsque sa faible précédence est ce que vous souhaitez.

Pratique