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


Quelle est la différence entre == et ===?

  • Comment fait le lâche == travail de comparaison?
  • Comment exactement le strict === travail de comparaison?

Quels seraient des exemples utiles?


424
2017-09-17 06:56


origine


Réponses:


Différence entre == et ===

La différence entre les lâches == opérateur égal et strict === opérateur identique est exactement expliqué dans le Manuel:

Opérateurs de comparaison

┌────────────────────────────────────────────────────────────── ───────────────────────────
│ Exemple │ Nom │ Résultat │
├────────────────────────────────────────────────────────────── ───────────────────────────
│ $ a == $ b │ Égal UE TRUE si $ a est égal à $ b après le jonglage de type. │
│ $ a === $ b │ Identique │ TRUE si $ a est égal à $ b, et ils sont du même type. │
└────────────────────────────────────────────────────────────── ───────────────────────────

Librement == comparaison égale

Si vous utilisez le == opérateur, ou tout autre opérateur de comparaison qui utilise une comparaison souple comme !=, <> ou ==, vous devez toujours regarder le le contexte pour voir quoi, où et pourquoi quelque chose se convertit pour comprendre ce qui se passe.

Règles de conversion

Tableau de comparaison de type

Comme référence et exemple, vous pouvez voir le tableau de comparaison dans le Manuel:

Comparaisons lâches avec ==

┌──────────────────────────────────────────────────────────────── ┬─────────────────────────────────────────────────────────────── ┬───────┐
│ │ TRUE │ FALSE │ 1 │ 0 │ -1 │ "1" │ "0" │ "-1" │ NULL │ tableau () │ "php" │ "" │
├──────────────────────────────────────────────────────────────── ┼─────────────────────────────────────────────────────────────── ┼───────┤
│ VRAI │ VRAI │ FAUX │ VRAI │ FAUX │ VRAI │ VRAI │ FAUX │ VRAI │ FAUX │ FAUX │ VRAI │ FAUX │
│ FAUX │ FAUX │ VRAI │ FAUX │ VRAI │ FAUX │ FAUX │ VRAI │ FAUX │ VRAI │ VRAI │ FAUX │ VRAI │
│ 1 │ VRAI │ FAUX │ VRAI │ FAUX │ FAUX │ VRAI │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │
│ 0 │ FAUX │ VRAI │ FAUX │ VRAI │ FAUX │ FAUX │ VRAI │ FAUX │ VRAI │ FAUX │ VRAI │ VRAI │
│ -1 │ VRAI │ FAUX │ FAUX │ FAUX │ VRAI │ FAUX │ FAUX │ VRAI │ FAUX │ FAUX │ FAUX │ FAUX │
│ "1" │ VRAI │ FAUX │ VRAI │ FAUX │ FAUX │ VRAI │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │
│ "0" │ FAUX │ VRAI │ FAUX │ VRAI │ FAUX │ FAUX │ VRAI │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │
│ "-1" │ VRAI │ FAUX │ FAUX │ FAUX │ VRAI │ FAUX │ FAUX │ VRAI │ FAUX │ FAUX │ FAUX │ FAUX │
│ NULL │ FAUX │ VRAI │ FAUX │ VRAI │ FAUX │ FAUX │ FAUX │ FAUX │ VRAI │ VRAI │ FAUX │ VRAI │
│ array () │ FALSE │ TRUE │ FALSE │ FALSE │ FALSE │ FAUX │ FAUX │ FAUX │ VRAI │ VRAI │ FAUX │ FAUX │
│ "php" │ TRUE │ FALSE │ FALSE │ TRUE │ FALSE │ FALSE │ FALSE │ FAUX │ FAUX │ FAUX │ VRAI │ FAUX │
│ "" │ FAUX │ VRAI │ FAUX │ VRAI │ FAUX │ FAUX │ FAUX │ FAUX │ VRAI │ FAUX │ FAUX │ VRAI │
└──────────────────────────────────────────────────────────────── ┴─────────────────────────────────────────────────────────────── ┴───────┘

Strict === comparaison identique

Si vous utilisez le === opérateur, ou tout autre opérateur de comparaison qui utilise une comparaison stricte tels que !== ou ===, alors vous pouvez toujours être sûr que les types ne seront pas magiquement changer, car il n'y aura pas de conversion en cours. Donc, avec une comparaison stricte, le type et la valeur doivent être identiques, pas seulement la valeur.

Tableau de comparaison de type

Comme référence et exemple, vous pouvez voir le tableau de comparaison dans le Manuel:

Comparaisons strictes avec ===

┌──────────────────────────────────────────────────────────────── ┬─────────────────────────────────────────────────────────────── ┬───────┐
│ │ TRUE │ FALSE │ 1 │ 0 │ -1 │ "1" │ "0" │ "-1" │ NULL │ tableau () │ "php" │ "" │
├──────────────────────────────────────────────────────────────── ┼─────────────────────────────────────────────────────────────── ┼───────┤
│ TRUE │ VRAI FAUX │ │ FAUX FAUX │ │ FAUX FAUX │ │ FAUX FAUX │ │ FAUX FAUX │ │ FAUX FAUX │ │
│ FAUX │ FAUX │ VRAI │ FAUX SE FAUX │ FAUX │ FAUX SE FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │
│ │ 1 FAUX FAUX │ │ │ VRAI FAUX FAUX │ │ │ FAUX FAUX FAUX │ │ │ FAUX FAUX FAUX │ │ │ FALSE
0 │ │ │ FAUX FAUX FAUX │ │ │ VRAI FAUX FAUX │ │ │ FAUX FAUX FAUX │ │ │ FAUX FAUX FAUX │ │
│ │ -1 FAUX FAUX │ │ │ FAUX FAUX FAUX │ │ │ TRUE FAUX FAUX │ │ FAUX FAUX │ │ FAUX FAUX │ │
1 "1" AL FAUX │ FAUX │ FAUX │ FAUX │ FAUX UE VRAI │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │
0 "0" │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX UE VRAI │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │
-1 "-1" │ FAUX │ FAUX │ FAUX SE FAUX │ FAUX │ FAUX │ FAUX │ VRAI SE FAUX │ FAUX │ FAUX │ FAUX │
│ NULL │ FAUX FAUX │ │ FAUX FAUX │ │ FAUX FAUX │ │ FAUX FAUX │ │ VRAI FAUX │ │ FAUX FAUX │ │
│ tableau () │ FAUX │ FAUX │ FAUX SE FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ VRAI │ FAUX │ FAUX │
Ph "php" │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ VRAI │ FAUX │
│ "" │ FAUX FAUX │ │ FAUX FAUX │ │ FAUX FAUX │ │ FAUX FAUX │ │ FAUX FAUX │ │ FAUX │ TRUE │
└──────────────────────────────────────────────────────────────── ┴─────────────────────────────────────────────────────────────── ┴───────┘

558
2017-09-17 06:57



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 à la === opérateur. Exemple:

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

226
2018-02-26 07:52



Une image vaut mieux que mille mots:

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

enter image description here

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

enter image description here

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 hexagonale entre guillemets est parfois un flottant et sera lancée 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 tableau 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 == pour la plupart des autres variables, ce qui va à l'encontre de son objectif.

Espérer:

Si vous utilisez PHP, vous ne devez pas utiliser l'opérateur double égalité, utilisez toujours des triples égaux.


41
2017-11-03 00:42



En ce qui concerne JavaScript:

L'opérateur === fonctionne de la même manière que l'opérateur ==, mais il requiert que ses opérandes aient non seulement la même valeur, mais aussi le même type de données.

Par exemple, l'exemple ci-dessous affichera «x et y sont égaux», mais pas «x et y sont identiques».

var x = 4;
var y = '4';
if (x == y) {
    alert('x and y are equal');
}
if (x === y) {
    alert('x and y are identical');
}

37
2017-09-17 07:27



Un ajout aux autres réponses concernant la comparaison d'objets:

== compare des objets en utilisant le nom de l'objet et leurs valeurs. Si deux objets sont du même type et ont les mêmes valeurs de membre, $a == $b les rendements sont vrais.

=== compare l'ID d'objet interne des objets. Même si les membres sont égaux, $a !== $b s'ils ne sont pas exactement le même objet.

class TestClassA {
    public $a;
}

class TestClassB {
    public $a;
}

$a1 = new TestClassA();
$a2 = new TestClassA();
$b = new TestClassB();

$a1->a = 10;
$a2->a = 10;
$b->a = 10;

$a1 == $a1;
$a1 == $a2;  // Same members
$a1 != $b;   // Different classes

$a1 === $a1;
$a1 !== $a2; // Not the same object

20
2018-02-26 09:12



En termes simples:

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

=== vérifie si le même (type de valeur)


Equivalent vs. Same: An Analogie

1 + 1 = 2 + 0 (équivalent)

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


En PHP:

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

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

  • vrai est booléen
  • 1 est int

11
2018-02-19 09:52



Tout est question de types de données. Prendre un BOOL (vrai ou faux) par exemple:

true est égal à 1 et false est égal à 0

le == ne se soucie pas des types de données lors de la comparaison: Donc, si vous aviez une variable qui est 1 (ce qui pourrait aussi être true):

$var=1;

Et puis comparez avec le ==:

if ($var == true)
{
    echo"var is true";
}

Mais $var ne correspond pas réellement trueest-ce que c'est? Il a la valeur int de 1 au lieu de cela, qui à son tour est égal à vrai.

Avec ===, les types de données sont vérifiés pour s'assurer que les deux variables / objets / tout utilisent le même type.

Donc si je l'ai fait

if ($var === true)
{
    echo "var is true";
}

cette condition ne serait pas vraie, $var !== true seulement == true (si tu vois ce que je veux dire).

Pourquoi auriez-vous besoin de cela?

Simple - regardons l'une des fonctions de PHP: array_search():

le array_search() function recherche simplement une valeur dans un tableau et renvoie la clé de l'élément dans lequel la valeur a été trouvée. Si la valeur est introuvable dans le tableau, elle renvoie faux. Mais si vous faisiez une array_search() sur une valeur qui était stockée dans le Premier élément du tableau (qui aurait la clé de tableau de 0)....la array_search() La fonction retournera 0 ... ce qui est faux.

Donc si vous avez fait:

$arr = array("name");
if (array_search("name", $arr) == false)
{
    // This would return 0 (the key of the element the val was found
    // in), but because we're using ==, we'll think the function
    // actually returned false...when it didn't.
}

Alors, voyez-vous comment cela pourrait être un problème maintenant?

La plupart des gens n'utilisent pas == false lors de la vérification si une fonction renvoie false. Au lieu de cela, ils utilisent le !. Mais en fait, c'est exactement la même chose que d'utiliser ==false, donc si vous avez fait:

$arr = array("name");
if (!array_search("name", $arr)) // This is the same as doing (array_search("name", $arr) == false)

Donc, pour des choses comme ça, vous utiliseriez le === à la place, de sorte que le type de données est vérifié.


8
2017-07-18 16:08



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

8
2017-10-14 13:09



Donné x = 5

1) Opérateur: == est "égal à". x == 8 c'est faux
2) Opérateur: === est "exactement égal à" (valeur et type) x === 5 est vrai, x === "5" c'est faux


6
2017-08-17 12:33