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




9 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)
ternaire string equals

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?




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.




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



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




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!');
}



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é .




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.




Related