de L'opérateur == jette entre deux types différents s'ils sont différents, alors que l' === opérateur effectue un "typesafe comparaison'. Ce qui signifie qu'il ne retourne true 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

Warning : 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)

Une image vaut mille mots:

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

PHP Triple est Égal à === l'Égalité graphique:

code Source pour créer ces images:

https://github.com/sentientmachine/php_equality_charts

Méditation De Gourou

ceux qui veulent garder leur santé mentale, ne lisez plus.

1. '==' convertit les opérandes gauche et droite en nombres quand c'est possible (123 == "123foo", mais "123" != "123foo "
2. une corde hexadécimale entre guillemets est de temps en temps un flotteur et sera moulée contre votre volonté.
3. == n'est pas transitive car ("0" = = 0, et 0 = = "" mais "0" != "")
4. "6" == "6", "4.2" == "4.20", et "133" == "0133". Mais 133 != 0133, parce que 0133 est octal. Mais "0x10" == "16" et "1e3" == "1000"

5. les Variables PHP qui n'ont pas encore été déclarées sont fausses.

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

7. Quand les nombres sont grands ils sont == l'Infini.

8. NAN n'est pas == elle-même, mais c'est Vrai.

9. Une nouvelle classe == à 1.

10. Faux est le plus dangereux de la valeur parce que de Faux est de == pour la plupart des autres variables, principalement l'abattre.

l'Espérance": 151950920"

si vous utilisez PHP, vous ne devez pas utiliser l'opérateur double equals, toujours utilisez Triple égal.

en ce qui concerne JavaScript:

L' === opérateur fonctionne de la même façon que l'opérateur==, mais il exige que ses opérandes ont non seulement la même valeur, mais aussi le même type de données.

Par exemple, l'exemple ci-dessous affiche "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');
}

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

= = compare les 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 membres, $a == $b donne true.

= = = compare l'id 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

en termes simples:

= = contrôle si équivalent (valeur seulement)

= = = contrôle si le même (valeur && type)





Équivalent vs la Même: Une Analogie

1 + 1 = 2 + 0 (équivalent)

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





En PHP:

true == 1 (vrai - d'une valeur équivalente)

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

• true boolean
• 1 est int

tout est dans les types de données. Prenez un BOOL (vrai ou faux) par exemple:

true égale aussi 1 et false égale aussi 0

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

$var=1;

et ensuite comparer avec le == :

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

mais $var n'est pas réellement égal à true , n'est-ce pas? Il a la valeur int de 1 à la place, qui à son tour, est égale à vrai.

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

donc si je l'ai fait

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

cette condition ne serait pas vraie, car $var !== true il seulement == true (si vous voyez ce que je veux dire).

Pourquoi auriez-vous besoin?

Simple - jetons un oeil à L'une des fonctions de PHP: array_search() :

la fonction array_search() 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 n'a pas pu être trouvée dans le tableau, elle retourne false . Mais, si vous avez fait un array_search() sur une valeur qui a été stocké dans le premier élément du tableau (qui aurait la clé de tableau de 0 )....la fonction array_search() retournerait 0...ce qui est égal à faux..

donc si vous l'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 pour vérifier si une fonction retourne false. Au lieu de cela, ils utilisent le ! . Mais en réalité, c' est exactement le même que l'utilisation de ==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 soit vérifié.

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

Donné x = 5

1) Opérateur: = = est"égal à". x == 8 est faux

2) opérateur: = = = est " exactement égal à "(valeur et type) x === 5 est vrai, x === "5" est faux

$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

faites attention. Ici, c'est un problème notoire.

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

vs.

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

En bref, === fonctionne de la même manière qu' == dans la plupart des autres langages de programmation.

PHP vous permet de faire des comparaisons qui n'ont pas vraiment de sens. Exemple:

$y = "wauv";
$x = false;
if ($x == $y)
    ...

bien que cela permette quelques" raccourcis "intéressants, vous devriez faire attention car une fonction qui renvoie quelque chose qu'elle ne devrait pas (comme" erreur " au lieu d'un nombre) ne sera pas attrapée, et vous resterez à vous demander ce qui s'est passé.

En PHP, = = compare les valeurs et effectue la conversion de type si nécessaire (par exemple, la chaîne "12343sdfjskfjds" deviendra "12343" dans une comparaison d'entier). === comparera la valeur ET le type et retourne false si le type n'est pas le même.

si vous regardez dans le manuel PHP, vous verrez que beaucoup de fonctions retournent "false" si la fonction échoue, mais elles pourraient retourner 0 dans un scénario réussi, c'est pourquoi elles recommandent de faire "if (function() != = faux) " à éviter les erreurs.

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.

P. S.

= = compare la valeur seulement, il ne se souciera pas des types de données

vs.

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

vous utiliseriez === pour tester si une fonction ou une variable est false plutôt que de simplement équivaloir à false (zéro ou une chaîne vide).

$needle = 'a';
$haystack = 'abc';
$pos = strpos($haystack, $needle);
if ($pos === false) {
    echo $needle . ' was not found in ' . $haystack;
} else {
    echo $needle . ' was found in ' . $haystack . ' at location ' . $pos;
}

dans ce cas, strpos renverrait 0, ce qui équivaudrait à false dans le test

if ($pos == false)

ou

if (!$pos)

qui n'est pas ce que vous voulez ici.

pour savoir quand utiliser l'un sur l'autre, prenez par exemple la fonction fwrite() en PHP.

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

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. Le droit chemin serait:

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

PHP est un langage peu structuré. L'utilisation de l'opérateur double equal permet une vérification lâche d'une variable.

vérifier vaguement une valeur permettrait à des valeurs similaires, mais non égales, de correspondre à la même:

• "
• null
• false
• 0

toutes ces valeurs seraient égales en utilisant l'opérateur double equal.

Variables ont un type et une valeur.

• $var = "test" est une chaîne qui contient "test"
• $ var2 = 24 est une valeur entière vhose de 24.

lorsque vous utilisez ces variables (en PHP), parfois vous n'avez pas le bon type. Par exemple, si vous faites

if ($var == 1) {... do something ...}

PHP pour les convertir ("cast") $var entier. Dans ce cas, "$var == 1" est vrai, parce que tout non-vide la corde est placée à 1.

quand vous utilisez ===, vous vérifiez que la valeur et le TYPE sont égaux, donc" $var === 1 " est faux.

ceci est utile, par exemple, lorsque vous avez une fonction qui peut retourner false (sur erreur) et 0 (résultat):

if(myFunction() == false) { ... error on myFunction ... }

ce code est erroné comme si myFunction() renvoie 0, Il est placé à false et vous semblez avoir une erreur. Le code correct est:

if(myFunction() === false) { ... error on myFunction ... }

parce que le test c'est que la valeur de retour "est un booléen est faux" et non pas "peut être utilisé pour de faux".

l'opérateur === est censé comparer exact content equality alors que l'opérateur == comparerait semantic equality. En particulier, il va forcer les chaînes à des nombres.

l'Égalité est un vaste sujet. Voir L'article de Wikipedia sur l'égalité .

<?php

    /**
     * Comparison of two PHP objects                         ==     ===
     * Checks for
     * 1. References                                         yes    yes
     * 2. Instances with matching attributes and its values  yes    no
     * 3. Instances with different attributes                yes    no
     **/

    // There is no need to worry about comparing visibility of property or
    // method, because it will be the same whenever an object instance is
    // created, however visibility of an object can be modified during run
    // time using ReflectionClass()
    // http://php.net/manual/en/reflectionproperty.setaccessible.php
    //
    class Foo
    {
        public $foobar = 1;

        public function createNewProperty($name, $value)
        {
            $this->{$name} = $value;
        }
    }

    class Bar
    {
    }
    // 1. Object handles or references
    // Is an object a reference to itself or a clone or totally a different object?
    //
    //   ==  true   Name of two objects are same, for example, Foo() and Foo()
    //   ==  false  Name of two objects are different, for example, Foo() and Bar()
    //   === true   ID of two objects are same, for example, 1 and 1
    //   === false  ID of two objects are different, for example, 1 and 2

    echo "1. Object handles or references (both == and    ===) <br />";

    $bar = new Foo();    // New object Foo() created
    $bar2 = new Foo();   // New object Foo() created
    $baz = clone $bar;   // Object Foo() cloned
    $qux = $bar;         // Object Foo() referenced
    $norf = new Bar();   // New object Bar() created
    echo "bar";
    var_dump($bar);
    echo "baz";
    var_dump($baz);
    echo "qux";
    var_dump($qux);
    echo "bar2";
    var_dump($bar2);
    echo "norf";
    var_dump($norf);

    // Clone: == true and === false
    echo '$bar == $bar2';
    var_dump($bar == $bar2); // true

    echo '$bar === $bar2';
    var_dump($bar === $bar2); // false

    echo '$bar == $baz';
    var_dump($bar == $baz); // true

    echo '$bar === $baz';
    var_dump($bar === $baz); // false

    // Object reference: == true and === true
    echo '$bar == $qux';
    var_dump($bar == $qux); // true

    echo '$bar === $qux';
    var_dump($bar === $qux); // true

    // Two different objects: == false and === false
    echo '$bar == $norf';
    var_dump($bar == $norf); // false

    echo '$bar === $norf';
    var_dump($bar === $norf); // false

    // 2. Instances with matching attributes and its values (only ==).
    //    What happens when objects (even in cloned object) have same
    //    attributes but varying values?

    // $foobar value is different
    echo "2. Instances with matching attributes  and its values (only ==) <br />";

    $baz->foobar = 2;
    echo '$foobar' . " value is different <br />";
    echo '$bar->foobar = ' . $bar->foobar . "<br />";
    echo '$baz->foobar = ' . $baz->foobar . "<br />";
    echo '$bar == $baz';
    var_dump($bar == $baz); // false

    // $foobar's value is the same again
    $baz->foobar = 1;
    echo '$foobar' . " value is the same again <br />";
    echo '$bar->foobar is ' . $bar->foobar . "<br />";
    echo '$baz->foobar is ' . $baz->foobar . "<br />";
    echo '$bar == $baz';
    var_dump($bar == $baz); // true

    // Changing values of properties in $qux object will change the property
    // value of $bar and evaluates true always, because $qux = &$bar.
    $qux->foobar = 2;
    echo '$foobar value of both $qux and $bar is 2, because $qux = &$bar' . "<br />";
    echo '$qux->foobar is ' . $qux->foobar . "<br />";
    echo '$bar->foobar is ' . $bar->foobar . "<br />";
    echo '$bar == $qux';
    var_dump($bar == $qux); // true

    // 3. Instances with different attributes (only ==)
    //    What happens when objects have different attributes even though
    //    one of the attributes has same value?
    echo "3. Instances with different attributes (only ==) <br />";

    // Dynamically create a property with the name in $name and value
    // in $value for baz object
    $name = 'newproperty';
    $value = null;
    $baz->createNewProperty($name, $value);
    echo '$baz->newproperty is ' . $baz->{$name};
    var_dump($baz);

    $baz->foobar = 2;
    echo '$foobar' . " value is same again <br />";
    echo '$bar->foobar is ' . $bar->foobar . "<br />";
    echo '$baz->foobar is ' . $baz->foobar . "<br />";
    echo '$bar == $baz';
    var_dump($bar == $baz); // false
    var_dump($bar);
    var_dump($baz);
?>

Toutes les réponses jusqu'à présent ignorer un problème dangereux avec ===. Il a été noté en passant, mais pas souligné, que l'entier et le double sont des types différents, de sorte que le code suivant:

$n = 1000;
$d = $n + 0.0e0;
echo '<br/>'. ( ($n ==  $d)?'equal' :'not equal' );
echo '<br/>'. ( ($n === $d)?'equal' :'not equal' );

donne:

 equal
 not equal

noter qu'il ne s'agit pas d'une"erreur d'arrondissement". Les deux nombres sont exactement égaux jusqu'au dernier bit, mais ils ont des types différents.

c'est un problème désagréable parce qu'un programme utilisant === peut courir joyeusement pendant des années si tous les chiffres sont assez petits (où "assez petit" dépend du matériel et votre système d'exploitation). Cependant, si par hasard, un entier se trouve être assez grand pour être converti en double, son type est changé "pour toujours" même si une opération ultérieure, ou de nombreuses opérations, pourrait le ramener à un petit entier en valeur. Et, il y a pire. Elle peut se propager - double-ness infection peut être transmise à tout ce qu'il touche, un calcul à la fois.

dans le monde réel, il est probable que ce soit un problème dans les programmes qui traitent des dates au-delà de l'année 2038, par exemple. À ce moment, les horodateurs UNIX (nombre de secondes depuis 1970-01-01 00:00:00 UTC) nécessiteront plus de 32 bits, de sorte que leur représentation sera "magiquement" commuté pour doubler sur certains systèmes. Par conséquent, si vous calculez la différence entre deux fois vous pourriez finir avec quelques secondes, mais comme un double, plutôt que le résultat entier qui se produit dans l'année 2017.

je pense que c'est bien pire que les conversions entre chaînes et des nombres, parce que c'est subtil. Je trouve facile de garder la trace de ce qui est une chaîne et ce qui est un nombre, mais garder la trace du nombre de bits dans un nombre est au-dessus de moi.

ainsi, dans les réponses ci-dessus il y a quelques belles tables, mais aucune distinction entre 1 (comme un entier) et 1 (subtile double) et 1.0 (évident double). Aussi, des conseils que vous devriez toujours utiliser === et jamais == n'est pas grande, parce que === parfois échouer où == fonctionne correctement. De plus, JavaScript n'est pas équivalent à cet égard parce qu'il n'a qu'un seul type de nombre (à l'interne, il peut avoir des représentations bit-wise différentes, mais il ne cause pas de problèmes pour====).

mon conseil-n'utilisez ni l'un ni l'autre. Vous devez écrire votre propre fonction de comparaison pour vraiment résoudre ce gâchis.

il y a deux différences entre == et === dans les tableaux et objets PHP qui, je pense, n'ont pas été mentionnés ici; deux tableaux avec des clés de différentes sortes, et des objets.

deux tableaux avec différentes sortes de clés

si vous avez un tableau avec un tri de clé et un autre tableau avec un tri de clé différent, ils sont strictement différents (i.e. en utilisant === ). Cela peut causer si vous tri-clé un tableau, et essayer de comparer les tableau avec celui d'origine.

par exemple, considérez un tableau vide. Tout d'abord, nous essayons de pousser quelques nouveaux index dans le tableau sans aucune sorte spéciale. Un bon exemple serait un tableau avec des chaînes comme clés. Maintenant en profondeur dans un exemple:

// Define an array
$arr = [];

// Adding unsorted keys
$arr["I"] = "we";
$arr["you"] = "you";
$arr["he"] = "they";

maintenant, nous avons un tableau de clés non-triées (par exemple, 'il' est venu après 'vous'). Considérez le même tableau, mais nous avons trié ses clés par ordre alphabétique:

// Declare array
$alphabetArr = [];

// Adding alphabetical-sorted keys
$alphabetArr["I"] = "we";
$alphabetArr["he"] = "they";
$alphabetArr["you"] = "you";

Tip : vous pouvez trier un tableau par clé en utilisant la fonction ksort () .

Maintenant vous avez un autre tableau avec un tri de clé différent du premier. Nous allons donc les comparer:

$arr == $alphabetArr; // true
$arr === $alphabetArr; // false

Note : cela peut être évident, mais comparer deux tableaux différents tableaux utilisant une comparaison stricte donne toujours false . Cependant, deux tableaux arbitraires peuvent être égaux en utilisant === ou non.

Vous diriez: "Cette différence est négligeable". Alors je dis que c'est une différence et devrait être considéré et peut se produire n'importe quand. Comme mentionné ci-dessus, le tri des clés dans un tableau en est un bon exemple.

objets

Keep in mind, deux objets différents ne sont jamais strictement égaux . Ces exemples pourraient aider:

$stdClass1 = new stdClass();
$stdClass2 = new stdClass();
$clonedStdClass1 = clone $stdClass1;

// Comparing
$stdClass1 == $stdClass2; // true
$stdClass1 === $stdClass2; // false
$stdClass1 == $clonedStdClass1; // true
$stdClass1 === $clonedStdClass1; // false

Note : L'assignation d'un objet à une autre variable ne crée pas de copie - elle crée plutôt une référence au même emplacement de mémoire que l'objet. voir ici .

Note : à partir de PHP7, classes anonymes a été ajouté. D'après les résultats, il n'y a pas de différence entre new class {} et new stdClass() dans les essais ci-dessus.