Wie funktionieren die PHP Gleichheit (== Doppel equals) und Identität (=== triple equals) Vergleichsoperatoren unterscheiden?

Question

Was ist der Unterschied zwischen == und ===?

• Wie genau funktioniert der losen == Vergleich arbeiten?
• Wie genau funktioniert die strenge === Vergleich arbeiten?

Was würden einige nützliche Beispiele sein?

Answer 1

Unterschied zwischen == und ===

Der Unterschied zwischen dem losen == gleich Operator und dem strengen === identisch Operator wird genau erklärt in dem Handbuch :

  

Vergleichsoperator

┌──────────┬───────────┬───────────────────────────────────────────────────────────┐
│ Example  │ Name      │ Result                                                    │
├──────────┼───────────┼───────────────────────────────────────────────────────────┤
│$a ==  $b │ Equal     │ TRUE if $a is equal to $b after type juggling.            │
│$a === $b │ Identical │ TRUE if $a is equal to $b, and they are of the same type. │
└──────────┴───────────┴───────────────────────────────────────────────────────────┘

---

lose == gleich Vergleich

Wenn Sie den == Operator verwenden, oder einen anderen Vergleichsoperator, den losen Vergleich wie !=, <> oder == verwendet, Sie immer auf dem Kontext aussehen müssen , um zu sehen, was, wo und warum etwas wird umgewandelt zu verstehen, was los ist.

Converting Regeln

• Umwandlung nach boolean
• Konvertierung in Integer
• Konvertieren zu schweben
• bespannen Konvertieren
• auf Array-Converting
• Konvertieren in das Objekt
• Umstellung auf
• Konvertieren auf NULL

Typ Vergleichstabelle

Als Referenz und Beispiel können Sie die Vergleichstabelle in der Handbuch :

  

Los Vergleiche mit ==

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

Strikte === identisch Vergleich

Wenn Sie den === Operator verwenden, oder einen anderen Vergleichsoperator, den strengen Vergleich wie !== oder === verwendet, dann können Sie immer sicher sein, dass die Typen wird nicht magisch zu ändern, weil es wird auf keine Umwandlung gehen. Also mit strengem Vergleich haben die Art und Wert das gleiche, nicht nur der Wert sein.

Typ Vergleichstabelle

Als Referenz und Beispiel können Sie die Vergleichstabelle in der Handbuch :

  

strenge Vergleiche mit ===

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

Answer 2

Der Operator == wirft zwischen zwei verschiedenen Typen, wenn sie unterschiedlich sind, während der Operator === einen ‚typsichere Vergleichs‘ durchführt. Das bedeutet, dass es nur wahr zurück, wenn beide Operanden die gleiche Art und den gleichen Wert haben.

Beispiele:

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

Warnung : zwei Instanzen der gleichen Klasse mit gleichwertigen Mitgliedern entsprechen nicht den === Operator. Beispiel:

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

Answer 3

Ein Bild sagt mehr als tausend Worte:

PHP Doppel Equals == Gleichheit Diagramm:

PHP Triple-Equals === Gleichheit Diagramm:

Der Quellcode um diese Bilder zu erstellen:

https://github.com/sentientmachine/php_equality_charts

Guru Meditation

Diejenigen, die ihre geistige Gesundheit halten wollen, lesen Sie nicht weiter, weil nichts davon wird keinen Sinn machen, außer zu sagen, dass dies, wie der Wahnsinn-Fraktal, von PHP entwickelt wurde.

1. NAN != NAN aber NAN == true.
2. == wird linke und rechte Operanden in Zahlen umwandeln, wenn links eine Zahl ist. So 123 == "123foo", aber "123" != "123foo"

3. Ein in Anführungszeichen Hex-String ist gelegentlich ein Schwimmer und wird überrascht Guss schweben gegen Ihren Willen sein, einen Laufzeitfehler verursacht.

4. == nicht transitiv, weil "0"== 0 und 0 == "" aber "0" != ""

5. PHP-Variablen, die noch nicht falsch deklariert worden sind, obwohl PHP eine Art und Weise nicht definierte Variablen zu vertreten hat, ist diese Funktion deaktiviert mit ==.

6. "6" == " 6", "4.2" == "4.20" und "133" == "0133" aber 133 != 0133. Aber "0x10" == "16" und "1e3" == "1000" dass Überraschung String-Konvertierung Aussetzen sowohl Oktal tritt ohne Ihre Anweisung oder Genehmigung, einen Laufzeitfehler verursacht.

7. False == 0, "", [] und "0".

8. Wenn Zahlen sind groß genug, sie sind == Unendlichkeit.

9. Eine neue Klasse == 1.

10. False ist der gefährlichste Wert, weil False die meisten anderen Variablen == wird, meist zu besiegen seinen Zweck.

Hope:

Wenn Sie PHP verwenden, Du sollst nicht verwenden die doppelte Operator ist gleich, denn wenn man triple equals verwenden, die nur Grenzfälle zu befürchten sind NAN und Zahlen so nah bis unendlich, dass sie bis ins Unendliche geworfen werden. Mit Doppel-Gleichen können alle Überraschung == sein, irgendetwas oder, oder Überraschung gegossen wird gegen Ihren Willen und != zu etwas, von dem es offenbar gleich sein sollte.

überall verwenden Sie == in PHP ein schlechten Code Geruch ist wegen des 85 Bugs in es durch implizite Casting Regeln ausgesetzt, die von Millionen von Programmierern entwickelt, scheinen die Programmierung durch die Brownsche Bewegung.

Answer 4

In Bezug auf JavaScript:

Der Operator === funktioniert genauso wie der Operator ==, aber es erfordert, dass seine Operanden haben nicht nur den gleichen Wert, sondern auch die gleichen Datentyp.

Zum Beispiel wird die Probe unter dem Display 'x und y sind gleich', aber nicht 'x und y sind gleich'.

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

Answer 5

Eine Ergänzung zu den anderen Antworten in Bezug auf Objektvergleich:

== vergleicht Objekte, um den Namen des Objekts und deren Werte. Wenn zwei Objekte vom gleichen Typ und haben die gleichen Elementwerte sind, $a == $b ergibt wahr.

=== vergleicht die interne Objekt-ID der Objekte. Auch wenn die Mitglieder gleich sind, $a !== $b wenn sie Objekt nicht genau gleich sind.

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

Answer 6

In einfachen Worten ausgedrückt:

== prüft, ob äquivalent (Wert nur)

=== prüft, ob die gleiche (Wert && Typ)
Entspricht vs. Same: Eine Analogie

1 + 1 = 2 + 0 (äquivalent)

1 + 1 = 1 + 1 (gleich)
In PHP:

true == 1 (true - das entspricht in Wert)

true === 1 (false - nicht gleich in Wert && Typ)

• wahr boolean
• 1 int

Answer 7

Es geht um Datentypen. Nehmen Sie einen BOOL (wahr oder falsch), zum Beispiel:

true auch gleich 1 und false auch gleich 0

Die == kümmern sich nicht um die Datentypen bei einem Vergleich: Also, wenn Sie hatte eine Variable, die 1 ist (was auch true werden könnte):

$var=1;

Und dann vergleichen mit dem ==:

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

Aber $var nicht wirklich gleich true, nicht wahr? Es hat den int-Wert von 1 statt, die wiederum gleich wahr ist.

Mit === werden die Datentypen überprüft, um sicherzustellen, dass die beiden Variablen / Objekte / was auch immer sind den gleichen Typ.

Also, wenn ich tat

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

, dass diese Bedingung nicht wahr sein würde, als $var !== true es nur == true (wenn Sie wissen, was ich meine).

Warum würden Sie brauchen das?

Einfach - lassen Sie uns einen Blick auf eine der PHP-Funktionen: array_search():

Die array_search() Funktion sucht einfach nach einem Wert in einem Array und gibt den Schlüssel des Elements des Wert gefunden wurde. Wenn der Wert nicht im Array gefunden werden kann, gibt sie false . Aber was, wenn Sie einen array_search() auf einem Wert haben, der in dem ersten Elemente des Arrays gespeichert wurde (die den Array-Schlüssel von 0 hätten) .... die array_search() Funktion würde 0 zurück .. .Welche ist gleich falsch ..

Also, wenn Sie getan haben:

$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.
}

Also, Sie sehen, wie das jetzt ein Problem sein könnte?

Die meisten Leute benutzen == false nicht, wenn geprüft wird, ob eine Funktion false zurückgibt. Stattdessen verwenden sie die !. Aber eigentlich ist dies genau die gleiche wie mit ==false, wenn Sie also tun:

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

Also für solche Dinge, würden Sie die === stattdessen verwenden, so dass der Datentyp geprüft wird.

Answer 8

Ein Beispiel dafür ist, dass ein Datenbankattribut null sein kann oder „“:

$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

Answer 9

Bei x = 5

1) Betreiber: == ist "gleich". x == 8 ist falsch
2) Betreiber: === ist "genau gleich" (Wert und Typ) x === 5 ist wahr, x === "5" ist false

Answer 10

Ein paar der Beispiele

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.

  

== Vergleicht nur der Wert ist, wird es über die Datentypen nicht stören

vs.

  

=== Vergleicht die Werte und Datentypen

Answer 11

$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

Seien Sie aber vorsichtig. Hier ist ein notorisches Problem.

// '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...
}

Answer 12

Kurz gesagt, === funktioniert auf die gleiche Art und Weise, dass == funktioniert in den meisten anderen Programmiersprachen.

PHP ermöglicht es Ihnen, Vergleiche zu machen, die nicht wirklich Sinn machen kann. Beispiel:

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

Während dies für einige interessante „Shortcuts“ können sollten Sie da eine Funktion passen, die etwas zurückgibt es nicht (wie „error“ statt einer Nummer) nicht erwischt werden, und Sie werden sich fragen, links, was passiert ist.

In PHP, == Werten vergleicht und führt eine Umwandlung geben, wenn nötig (beispielsweise die Zeichenfolge „12343sdfjskfjds“ wird in einem ganzzahligen comparison „12343“ werden). === den Wert vergleichen, und geben Sie und kehren falsch, wenn der Typ nicht gleich ist.

Wenn Sie in dem PHP-Handbuch schauen, sehen Sie, dass viele Funktionen „false“ zurück, wenn die Funktion fehlschlägt, aber sie könnten 0 in einem erfolgreichen Szenario zurückkehren, weshalb sie empfiehlt, „if (function () ! == false)“, um Fehler zu vermeiden.

Answer 13

Sie würden verwenden === zu testen, ob eine Funktion oder Variable falsch ist und nicht nur das entspricht falsch (Null oder eine leere Zeichenkette).

$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;
}

In diesem Fall strpos würde 0 zurück, was zu falsch im Test entsprechen würde

if ($pos == false)

oder

if (!$pos)

das ist nicht das, was Sie wollen hier.

Answer 14

Was, wenn man über die andere zu verwenden, nehmen Sie zum Beispiel der fwrite() Funktion in PHP.

Diese Funktion schreibt Inhalte auf einen Datei-Stream. Nach PHP, „liefert fwrite() die Anzahl der Bytes geschrieben oder FALSE bei einem Fehler.“. Wenn Sie bei der Funktionsaufruf war erfolgreich testen möchten, ist diese Methode fehlerhaft:

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

Es kann Null zurück (und wird als erfolgreich betrachtet), und Ihr Zustand wird immer noch ausgelöst. Der richtige Weg wäre:

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

Answer 15

PHP ist eine lose typisierte Sprache. den doppelten Gleichheitsoperator ermöglicht eine lose Überprüfung einer Variablen.

lose Überprüfung ein Wert für ein ähnlichen erlauben würde, aber nicht gleich, Werte wie die gleichen gleichzusetzen:

• ''
• null
• false
• 0

Alle diese Werte würden als gleich gleichsetzen die doppelte gleich Operator.

Answer 16

php == ist ein Vergleichsoperator, der den Wert der Variablen vergleicht. Aber === vergleicht den Wert und den Datentyp.

Beispiel:

<?php 
  $var1 = 10;
  $var2 = '10';

  if($var1 == $var2) {
    echo 'Variables are equal';
  } else {
    echo 'Variables are not equal';
  }
?>

In diesem Fall wird der Ausgang sein ‚Variablen gleich sind‘, obwohl ihre Datentypen unterschiedlich sind.

Aber wenn wir === statt == verwenden, wird der Ausgang sein ‚Variablen nicht gleich sind‘. Die PHP vergleicht zuerst den Wert der Variablen und dann den Datentyp. Hier werden die Werte sind die gleichen, aber die Datentypen unterschiedlich sind.

Answer 17

Variablen haben einen Typ und einen Wert.

• $ var = "test" ist eine Zeichenfolge, die "test"
enthalten
• $ var2 = 24 ein ganze Zahl vhose Wert ist 24.

Wenn Sie diese Variablen (in PHP) verwenden, manchmal müssen Sie nicht die gute Art. Zum Beispiel, wenn Sie das tun

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

PHP zu konvertieren ( "zu werfen") $ var auf Integer. In diesem Fall „$ var == 1“ wahr ist, weil jede nicht leere Zeichenfolge auf 1 gegossen wird.

Wenn === verwenden, prüfen Sie, dass der Wert und die Art gleich sind, so "$ var === 1" falsch ist.

Dies ist zum Beispiel nützlich, wenn Sie eine Funktion haben, die falsch zurückgeben können (bei einem Fehler) und 0 (Ergebnis):

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

Dieser Code ist falsch, als ob myFunction() 0 zurück, um es zu falsch gegossen wird und Sie scheinen einen Fehler zu haben. Der richtige Code lautet:

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

, da der Test ist, dass der Rückgabewert „ein boolean ist und falsch ist“ und nicht „kann zu falsch gegossen werden.“

Answer 18

Der === Operator sollte vergleichen genau Inhalt Gleichheit während des == Betreiber würde semantische Gleichheit vergleichen. Insbesondere wird es Strings in Zahlen zwingen.

Gleichheit ist ein großes Thema. Siehe Wikipedia-Artikel über die Gleichstellung .

Answer 19

<?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);
?>

Answer 20

Alle Antworten so ignorieren weit ein gefährliches Problem mit ===. Es wurde nebenbei bemerkt, nicht aber betont, dass integer und Doppel sind verschiedene Typen, so dass der folgende Code:

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

gibt:

 equal
 not equal

Beachten Sie, dass dies kein Fall eines „Rundungsfehler“ ist. Die beiden Zahlen sind genau gleich bis auf den letzten Bit, aber sie haben verschiedene Typen.

Dies ist ein unangenehmes Problem, weil ein mit dem Programm === kann glücklich jahrelang laufen, wenn alle Zahlen klein genug sind (wobei „klein genug“ auf der Hardware und Betriebssystem ab, die Sie laufen auf). Wenn jedoch zufällig, geschieht eine ganze Zahl groß genug sein, um zu einem Doppel umgewandelt zu werden, wird seine Art geändert „für immer“ auch eine nachfolgende Operation obwohl, oder viele Operationen, könnte es auf eine kleine ganze Zahl im Wert bringen. Und es kommt noch schlimmer. Es kann verbreiten - doppelt-ness-Infektion kann es zu einer Zeit berührt, eine Berechnung entlang zu irgendetwas übergeben werden.

In der realen Welt ist dies wahrscheinlich ein Problem in den Programmen sein, die Daten über das Jahr 2038, zum Beispiel handhaben. Zu diesem Zeitpunkt UNIX Zeitstempel (Anzahl der Sekunden seit 1970-01-01 00.00.00 UTC) wird mehr als 32 Bits erfordern, so dass ihre Darstellung auf „magische Weise“ -Schalter auf manchen Systemen zu verdoppeln. Wenn Sie also die Differenz zwischen zwei Zeiten berechnen können Sie mit ein paar Sekunden am Ende, sondern als Doppel, anstatt die ganze Zahl Ergebnis, das 2017 im Jahr stattfindet.

Ich denke, das ist viel schlimmer als Konvertierungen zwischen Strings und Zahlen, weil es subtil ist. Ich finde es leicht, den Überblick zu behalten, was ein String ist und was ist eine Zahl, aber die Verfolgung der Anzahl von Bits in einer Zahl ist mir schleierhaft.

Also, in den oben genannten Antworten gibt es einige netten Tabellen, aber keine Unterscheidung zwischen 1 (als ganzer Zahl) und 1 (subtile Doppel) und 1,0 (offensichtliche Doppelzimmer). Auch Ratschläge, die Sie sollten immer verwenden === und nie == ist nicht groß, weil === manchmal scheitern, wo == richtig funktioniert. Auch ist JavaScript in dieser Hinsicht nicht gleichwertig, weil es nur eine Nummer Typ (intern kann es unterschiedliche bitweise Darstellungen haben, aber es verursacht keine Probleme für ===) hat.

Mein Rat - weder verwenden. Sie benötigen eine eigene Vergleichsfunktion zu schreiben, wirklich dieses Chaos zu beheben.

Answer 21

Es gibt zwei Unterschiede zwischen == und === in PHP Arrays und Objekten, die ich denke hier nicht erwähnt haben; zwei Arrays mit unterschiedlichen Schlüsselarten und Objekte.

Zwei Arrays mit unterschiedlichen Schlüsselarten

Wenn Sie ein Array mit einem Schlüssel zu sortieren und zu einem anderen Array mit einer anderen Schlüssel Art haben, sind sie streng verschieden (das heißt mit ===). Das kann verursachen, wenn Sie Schlüssel-Sortierung ein Array, und versucht, die sortierten Array mit dem Original zu vergleichen.

Zum Beispiel ein leeres Array betrachten. Zuerst versuchen wir einige neue Indizes auf das Array ohne besondere Art zu schieben. Ein gutes Beispiel wäre ein Array mit Strings als Schlüssel. Nun tief in ein Beispiel:

// Define an array
$arr = [];

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

Jetzt haben wir eine nicht sortierte-Tasten-Array (zum Beispiel ‚er‘ kam nach ‚du‘). Betrachten wir die gleiche Anordnung, aber wir sortiert seine Tasten in alphabetischer Reihenfolge:

// Declare array
$alphabetArr = [];

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

Tipp: : Sie können ein Array sortieren, indem Schlüssel ksort () Funktion.

Jetzt haben Sie ein weiteres Array mit einer anderen Schlüssel Art, die aus dem ersten. Also, wir werden sie vergleichen:

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

Hinweis : Es mag offensichtlich sein, aber den Vergleich von zwei andere Arrays mit strengen Vergleichsergebnisse immer false. Jedoch sind zwei beliebige Arrays gleich sein können === verwenden oder nicht.

Sie würden sagen: „Dieser Unterschied vernachlässigbar ist“. Dann sage ich es ein Unterschied ist und berücksichtigt werden soll, und zu jeder Zeit passieren kann. Wie oben erwähnt, ein gutes Beispiel dafür ist, dass Tasten in einer Anordnung zu sortieren.

Objekte

Beachten Sie, zwei verschiedene Objekte sind nie streng-gleich . Diese Beispiele helfen würde:

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

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

Hinweis : ein Objekt auf eine andere Variable zuweisen erstellen keine Kopie - sondern es erzeugt einen Verweis auf den gleichen Speicherplatz wie das Objekt. Sehen Sie hier .

Hinweis : Ab PHP7, anonyme Klassen hinzugefügt wurde. Aus den Ergebnissen gibt es keinen Unterschied zwischen new class {} und new stdClass() in den Tests oben.