Comment les opérateurs de comparaison d'égalité PHP (== double égal) et d'identité (=== triple égal) sont-ils différents?


Answers

L'opérateur == diffuse entre deux types différents s'ils sont différents, tandis que l'opérateur === effectue une 'comparaison de typesafe'. Cela signifie qu'il ne retournera vrai que si les deux opérandes ont le même type et la même valeur.

Exemples:

1 === 1: true
1 == 1: true
1 === "1": false // 1 is an integer, "1" is a string
1 == "1": true // "1" gets casted to an integer, which is 1
"foo" === "foo": true // both operands are strings and have the same value

Attention : deux instances de la même classe avec des membres équivalents ne correspondent PAS à l'opérateur === . Exemple:

$a = new stdClass();
$a->foo = "bar";
$b = clone $a;
var_dump($a === $b); // bool(false)
Question

Quelle est la difference entre == et === ?

  • Comment exactement la comparaison lâche fonctionne-t-elle?
  • Comment fonctionne exactement la comparaison stricte === ?

Quels seraient des exemples utiles?




Un exemple est qu'un attribut de base de données peut être null ou "":

$attributeFromArray = "";
if ($attributeFromArray ==  ""){}  //true
if ($attributeFromArray === ""){}  //true
if ($attributeFromArray ==  null){}  //true
if ($attributeFromArray === null){}  //false

$attributeFromArray = null;
if ($attributeFromArray ==  ""){}  //true
if ($attributeFromArray === ""){}  //false
if ($attributeFromArray ==  null){}  //true
if ($attributeFromArray === null){}  //true



$a = 5;   // 5 as an integer

var_dump($a == 5);       // compare value; return true
var_dump($a == '5');     // compare value (ignore type); return true
var_dump($a === 5);      // compare type/value (integer vs. integer); return true
var_dump($a === '5');    // compare type/value (integer vs. string); return false

Soyez prudent cependant. Voici un problème notoire.

// 'test' is found at position 0, which is interpreted as the boolean 'false'
if (strpos('testing', 'test')) {
    // code...
}

contre.

// true, as strict comparison was made (0 !== false)
if (strpos('testing', 'test') !== false) {
    // code...
}



Quelques exemples

var_dump(5 == 5);    // True
var_dump(5 == "5");  // True because == checks only same value not type
var_dump(5 === 5);   // True
var_dump(5 === "5"); // False because value are same but data type are different.

PS

== Compare uniquement la valeur, cela ne dérange pas les types de données

contre.

=== Compare les valeurs et les types de données




L'opérateur === est supposé comparer l'égalité de contenu exacte tandis que l'opérateur == comparerait l'égalité sémantique. En particulier, il va contraindre les chaînes à des chiffres.

L'égalité est un vaste sujet. Voir l'article de Wikipédia sur l'égalité .




Une image vaut mieux que mille mots:

PHP Double Equals == graphique d'égalité:

PHP Triple Equals === Tableau d'égalité:

Code source pour créer ces images:

https://github.com/sentientmachine/php_equality_charts

Guru Méditation

Ceux qui souhaitent garder leur santé mentale, ne lisez pas plus loin.

  1. '==' convertit les opérandes gauche et droit en nombres si possible (123 == "123foo", mais "123"! = "123foo"
  2. Une chaîne hexadécimale entre guillemets est parfois un float et sera casté contre votre volonté.
  3. == n'est pas transitif parce que ("0" est == à 0, et 0 est == à "" mais "0"! = "")
  4. "6" == "6", "4.2" == "4.20" et "133" == "0133". Mais 133! = 0133, car 0133 est octal. Mais "0x10" == "16" et "1e3" == "1000"
  5. PHP Les variables qui n'ont pas encore été déclarées sont fausses.

  6. False est égal à 0, blankstring et array vide et "0".

  7. Quand les nombres sont assez grands, ils sont == Infinity.
  8. NAN n'est pas == lui-même, mais c'est vrai.

  9. Une nouvelle classe est == à 1.

  10. False est la valeur la plus dangereuse car False est == à la plupart des autres variables, la plupart du temps à l'encontre de son but.

Espérer:

Si vous utilisez PHP, vous n'utiliserez pas l'opérateur double equals, utilisez toujours triple equals.




PHP est un langage faiblement typé. L'utilisation de l'opérateur double égal permet une vérification approximative d'une variable.

La vérification approximative d'une valeur permettrait d'égaler des valeurs similaires mais non égales:

  • ''
  • nul
  • faux
  • 0

Toutes ces valeurs seraient égales en utilisant l'opérateur double égal.




En termes simples:

== vérifie si équivalent (valeur seulement)

=== vérifie si la même chose (valeur && type)


Équivalent vs. Même: une analogie

1 + 1 = 2 + 0 (équivalent)

1 + 1 = 1 + 1 (même chose)


En PHP:

vrai == 1 (vrai - équivalent en valeur)

vrai === 1 (faux - pas la même valeur && type)

  • true est booléen
  • 1 est int



Quant à savoir quand utiliser l'un sur l'autre, prenons par exemple la fonction fwrite() en PHP.

Cette fonction écrit le contenu dans un flux de fichier. Selon PHP, " fwrite() renvoie le nombre d'octets écrits, ou FALSE en cas d'erreur.". Si vous voulez tester si l'appel de fonction a réussi, cette méthode est erronée:

if (!fwrite(stuff))
{
    log('error!');
}

Il peut retourner zéro (et est considéré comme réussi), et votre condition est toujours déclenchée. La bonne façon serait:

if (fwrite(stuff) === FALSE)
{
    log('error!');
}