Wie unterscheiden sich die Vergleichsoperatoren PHP-Gleichheit (== Doppel gleich) und Identität (=== Dreifach gleich)?

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

  • Wie genau funktioniert das lose == Vergleich arbeiten?
  • Wie genau funktioniert die strenge === Vergleich arbeiten?

Was würde werden einige nützliche Beispiele?

Kommentar zu dem Problem

InformationsquelleAutor der Frage nickf | 2008-09-17

  1. 549

    Unterschied zwischen == und ===

    Den Unterschied zwischen den lose == gleich-operator und die strenge === identische operator ist genau beschrieben, in der Handbuch:

    Vergleichsoperatoren

    ┌──────────┬───────────┬───────────────────────────────────────────────────────────┐ 
│ B. │ Name │ Ergebnis │ 
├──────────┼───────────┼───────────────────────────────────────────────────────────┤ 
ł$a == $b │ Gleich │ TRUE, wenn $a gleich $b ist nach Art jonglieren. │ 
ł$a === $b │ Identisch │ TRUE, wenn $a gleich $b ist und beide vom gleichen Typ sind. │ 
└──────────┴───────────┴───────────────────────────────────────────────────────────┘

    Locker == gleich Vergleich

    Wenn Sie die == Betreiber oder andere Vergleichsmethode, die verwendet lose-Vergleich wie !=, <> oder == haben Sie immer den Blick auf die Kontext, um zu sehen, was, wo und warum etwas umgewandelt wird, zu verstehen, was Los ist.

    Umwandlung von Regeln

    Art Vergleichstabelle

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

    Locker Vergleiche mit ==

    ┌─────────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬─────────┬───────┬───────┐ 
│ │ TRUE │ FALSE │ 1 │ 0 │ -1 │ "1" │ "0" │ "-1" │ NULL │ array() │ "php" │ "" │ 
├─────────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼─────────┼───────┼───────┤ 
│ STIMMT │ STIMMT │ FALSE │ TRUE │ FALSE │ STIMMT │ STIMMT │ FALSE │ TRUE │ FALSE │ FALSE │ TRUE │ FALSE │ 
│ FALSE │ FALSE │ TRUE │ FALSE │ TRUE │ FALSE │ FALSE │ TRUE │ FALSE │ STIMMT │ STIMMT │ FALSE │ STIMMT │ 
│ 1 │ TRUE │ FALSE │ TRUE │ FALSE │ FALSE │ TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ 
│ 0 │ FALSE │ TRUE │ FALSE │ TRUE │ FALSE │ FALSE │ TRUE │ FALSE │ TRUE │ FALSE │ STIMMT │ STIMMT │ 
│ -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 │ STIMMT │ STIMMT │ FALSE │ STIMMT │ 
│ array() │ FALSE │ TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ STIMMT │ STIMMT │ 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 │ STIMMT │ 
└─────────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴─────────┴───────┴───────┘

    Strengen === identisch Vergleich

    Wenn Sie die === Betreiber oder andere Vergleichsmethode, die verwendet strengen Vergleich wie !== oder ===, dann können Sie immer sicher sein, dass die Typen nicht magisch ändern, denn es wird keine Konvertierung geht. So strengen Vergleich die Art und den Wert gleich zu sein haben, nicht nur den Wert.

    Art Vergleichstabelle

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

    Strenge Vergleiche mit ===

    ┌─────────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬─────────┬───────┬───────┐ 
│ │ TRUE │ FALSE │ 1 │ 0 │ -1 │ "1" │ "0" │ "-1" │ NULL │ array() │ "php" │ "" │ 
├─────────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼─────────┼───────┼───────┤ 
│ STIMMT │ STIMMT │ 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 │ STIMMT │ 
└─────────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴─────────┴───────┴───────┘

    InformationsquelleAutor der Antwort nickf

  2. 227

    Den operator == CASTET zwischen zwei verschiedenen Typen, wenn Sie unterschiedlich sind, während die = = = - operator führt eine 'typesafe-Vergleich'. Das heißt, es wird nur true zurückgegeben, wenn beide Operanden den gleichen Typ und den gleichen Wert.

    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, die NICHT mit den === Betreiber. Beispiel:

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

    InformationsquelleAutor der Antwort Patrick Glandien

  3. 37

    In Bezug auf JavaScript:

    Den === operator funktioniert genauso wie der = = - operator, aber es erfordert, dass seine Operanden haben nicht nur den gleichen Wert, aber auch den gleichen Datentyp.

    Zum Beispiel das Beispiel unten zeigt 'x und y sind gleich', aber nicht 'x und y sind identisch'.

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

    InformationsquelleAutor der Antwort

  4. 35

    Ein Bild sagt mehr als tausend Worte:

    PHP Doppel-Entspricht == Gleichheit Diagramm:

    Wie unterscheiden sich die Vergleichsoperatoren PHP-Gleichheit (== Doppel gleich) und Identität (=== Dreifach gleich)?

    PHP Dreifach Gleich === Gleichheit Diagramm:

    Wie unterscheiden sich die Vergleichsoperatoren PHP-Gleichheit (== Doppel gleich) und Identität (=== Dreifach gleich)?

    Source code zum erstellen der Bilder:

    https://github.com/sentientmachine/php_equality_charts

    Guru Meditation

    Diejenigen, die wollen, halten Sie Ihre geistige Gesundheit haben, Lesen Sie nicht weiter.

    1. '==' konvertiert linken und rechten Operanden in zahlen, wenn möglich (123 == "123foo", aber "123" != "123foo"
    2. Einen hex-string in Anführungszeichen ist gelegentlich ein float und wird gegossen werden, um es gegen Ihren Willen.
    3. == ist nicht transitiv, da ("0" = = 0, und 0 ist = = "" aber "0" != "")
    4. "6" == "6", "4.2" == "4.20", und "133" == "0133". Aber 133 != 0133, weil 0133 ist eine Oktalzahl. Aber "0x10" == "16" und "1e3" == "1000"

    5. PHP-Variablen, die nicht erklärt wurden, noch falsch sind.

    6. False ist gleich 0, blankstring und leeres array, und "0".

    7. , Wenn die zahlen groß genug sind Sie == die Unendlichkeit.

    8. NAN nicht == selbst, aber es ist Wahr.

    9. Einer frischen Klasse ist == 1.

    10. Falsch ist, ist der gefährlichste Wert, denn False ist == zu den meisten anderen Variablen, meist zu besiegen Ihren Zweck.

    Hoffnung:

    Wenn Sie mit PHP, sollst Du Sie nicht verwenden die Doppel-ist-gleich-operator, verwenden Sie immer triple entspricht.

    InformationsquelleAutor der Antwort Eric Leschinski

  5. 19

    Ergänzung zu den anderen Antworten in Bezug auf das Objekt-Vergleich:

    == vergleicht bei Objekten mit dem Namen des Objekts und deren Werte. Wenn zwei Objekte den gleichen Typ und die gleichen member-Werte, $a == $b ergibt true.

    === vergleicht die interne Objekt-id der Objekte. Auch wenn die Mitglieder gleich sind, $a !== $b wenn Sie nicht genau das gleiche Objekt.

    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

    InformationsquelleAutor der Antwort soulmerge

  6. 11

    In einfachen Worten:

    == prüft, ob entspricht (Wert nur)

    === prüft, ob die gleichen (value && Typ)


    Äquivalent vs. Gleiche: Eine Analogie

    1 + 1 = 2 + 0 (äquivalent)

    1 + 1 = 1 + 1 (gleichen)


    In PHP:

    true == 1 (true - Gegenwert)

    true === 1 (false - nicht den gleichen Wert && Typ)

    • wahr ist boolean
    • 1 ist int

    InformationsquelleAutor der Antwort silver

  7. 8

    Es ist alles über Datentypen. Nehmen Sie ein BOOL (true oder false) Beispiel:

    true auch gleich 1 und
    false auch gleich 0

    Den == kümmert sich nicht um die Datentypen beim Vergleich:
    Also, wenn Sie hatte eine variable, die 1 ist (und das kann auch true):

    $var=1;

    Vergleichen und dann mit der ==:

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

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

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

    So, wenn ich

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

    dass die Bedingung nicht wahr sein, wie $var !== true es nur == true (wenn Ihr wisst was ich meine).

    Warum würden Sie brauchen?

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

    Den array_search() Funktion einfach sucht einen Wert in einem array, und gibt den Schlüssel des Elements der Wert gefunden wurde. Wenn der Wert konnte nicht im array gefunden wird, gibt es false. Was aber, wenn Sie haben einen array_search() auf einen Wert, der gespeichert wurde, in die erste element des Arrays (das wäre die array-Schlüssel von 0)....die array_search() hätte, würde die Funktion 0 zurück...das ist gleich false..

    Also, wenn Sie 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.
}

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

    Meisten Menschen nicht verwenden == false bei der Prüfung, ob eine Funktion den Wert false zurückgibt. Stattdessen nutzen Sie die !. Aber eigentlich ist das genau das gleiche wie mit ==false, so dass, wenn Sie haben:

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

    Also für Dinge wie, dass, Sie verwenden die === statt, so dass der Datentyp überprüft.

    InformationsquelleAutor der Antwort

  8. 8

    Ein Beispiel ist, dass eine Datenbank-Attribut kann null 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

    InformationsquelleAutor der Antwort fico7489

  9. 6

    Gegeben x = 5

    1) Operator: = = ("gleich"). x == 8 false

    2) Operator : === ist "genau gleich" (Wert und Typ) x === 5 ist wahr, x === "5" ist falsch

    InformationsquelleAutor der Antwort Mannusanghi

  10. 3
    $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

    Aber vorsichtig sein. 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...
}

    InformationsquelleAutor der Antwort Seph

  11. 3

    Kurz gesagt, === funktioniert in der gleichen Weise, = = bedeutet in den meisten anderen Programmiersprachen.

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

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

    Während dieser erlaubt es für einige interessante "shortcuts" sollten Sie sich hüten, da eine Funktion, die etwas zurückgibt, sollte es nicht (wie "error", statt einer Nummer) wird man nicht erwischt, und Sie werden sich Fragen, was passiert ist.

    In PHP, == vergleicht Werte und führt eine Typkonvertierung, wenn notwendig (zum Beispiel die Zeichenfolge "12343sdfjskfjds" wird zu "12343" in einem integer-Vergleich). === vergleichen Sie den Wert UND den Typ und den Wert false zurück, wenn der Typ nicht das gleiche.

    Wenn Sie einen Blick in das PHP-Handbuch werden Sie sehen, dass eine Menge von Funktionen return "false", wenn die Funktion fehlschlägt, aber Sie könnten return 0 in einem erfolgreichen Szenario, das ist, warum Sie empfehlen, tun ", wenn (function() !== false)", um Fehler zu vermeiden.

    InformationsquelleAutor der Antwort Christian P.

  12. 3

    Einige 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 den Wert nur, es wird sich nicht die Mühe über die Datentypen

    vs.

    === Vergleicht die Werte und Datentypen

    InformationsquelleAutor der Antwort Mohit Tanwani

  13. 2

    Verwenden Sie === testen, ob eine Funktion oder eine variable falsch ist, anstatt einfach was falsch (null oder ein leerer string).

    $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ückgeben, das wäre gleichzusetzen mit false im test

    if ($pos == false)

    oder

    if (!$pos)

    ist nicht das, was Sie hier wollen.

    InformationsquelleAutor der Antwort Stacey Richards

  14. 2

    Als zum Zeitpunkt der Verwendung eine über der anderen, nehmen Sie zum Beispiel die fwrite() - Funktion in PHP.

    Diese Funktion schreibt Inhalt in eine Datei streamen. Laut PHP, "fwrite() gibt die Anzahl der geschriebenen bytes oder FALSE on error.". Wenn Sie möchten, um zu testen, ob der Funktionsaufruf erfolgreich war, ist diese Methode fehlerhaft:

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

    Kann null zurückgeben (und als erfolgreich betrachtet werden kann), und Ihr Zustand wird immer noch ausgelöst. Der richtige Weg wäre:

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

    InformationsquelleAutor der Antwort Mario

  15. 2

    PHP ist eine schwach typisierte Sprache. Mit der Doppel-gleich-operator können Sie für eine lockere überprüfung einer variable.

    Locker einen Wert überprüfen erlauben würde, für eine ähnliche, aber nicht gleiche Werte gleichsetzen, als die gleiche:

    • "
    • null
    • false
    • 0

    Alle diese Werte ergäben sich als gleich mit dem Doppel-gleich-operator.

    InformationsquelleAutor der Antwort Cory Collier

  16. 1

    Variablen haben einen Typ und einen Wert.

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

    Wenn Sie diese Variablen verwenden (in PHP), manchmal haben Sie nicht die gute Art.
    Zum Beispiel, wenn Sie

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

    PHP zu konvertieren ("casten") $var, integer. In diesem Fall, "$var == 1" wahr ist, weil jede nicht-leere Zeichenfolge wird gegossen, um 1.

    Bei Verwendung von = = = überprüfen Sie, dass der Wert UND TYP gleich sind, also "$var === 1" ist falsch.

    Dies ist zum Beispiel nützlich, wenn Sie haben eine Funktion kann false zurückgeben (auf Fehler) und 0 (Ergebnis) :

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

    Dieser code ist falsch, wie wenn myFunction() gibt 0 zurück, es wird gegossen, auf false, und Sie scheinen zu haben, einen Fehler. Der richtige code lautet :

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

    wegen dem test ist, dass der Rückgabewert "ist ein boolescher Wert, der falsch ist" und nicht "kann werden gegossen auf "false".

    InformationsquelleAutor der Antwort ofaurax

  17. 1

    Den === Betreiber soll vergleichen genaue Inhalt der Geschlechter während der == - Betreiber vergleichen semantische Gleichheit. Sie wird insbesondere die nötigen strings in zahlen.

    Gleichberechtigung ist ein großes Thema. Sehen der Wikipedia-Artikel auf der Gleichheit.

    InformationsquelleAutor der Antwort kmkaplan

  18. 1
    <?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);
?>

    InformationsquelleAutor der Antwort Sathish

  19. -1

    Alle Antworten bisher ignorieren gefährliches problem mit ===. Es wurde festgestellt, dass im Vorbeigehen, aber nicht gestresst sind, dass Sie integer und double sind verschiedene Arten, so dass Sie den folgenden 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 NICHT ein Fall von ein "Rundungsfehler". Die zwei zahlen sind genau gleich, bis auf das Letzte bit, aber Sie haben unterschiedliche Typen.

    Dies ist ein unangenehmes problem, da ein Programm mit === kann ausgeführt werden glücklich für Jahre, wenn alle zahlen sind klein genug (wobei "klein genug" ist, hängt von der hardware und Betriebssystem, das Sie ausgeführt werden). Allerdings, wenn zufällig eine Ganzzahl passiert, groß genug sein, um umgewandelt werden, um eine doppelte, seinen Typ geändert "für immer", obwohl eine nachfolgende operation oder mehrere Operationen, möglicherweise bringen Sie zurück, um einen kleinen integer-Wert. Und, es kommt noch schlimmer. Es können sich ausbreiten - Doppel-ness-Infektion kann vorwärts, um alles, was es berührt, eine Berechnung zu einem Zeitpunkt.

    In der realen Welt, dies ist wahrscheinlich ein problem in den Programmen, die mit Daten jenseits des Jahres 2038, zum Beispiel. Zu dieser Zeit UNIX-Zeitstempel (Anzahl der Sekunden seit 1970-01-01 00:00:00 UTC) erfordert mehr als 32 bits, so Ihre Darstellung, "magisch" - Schalter zu verdoppeln auf einigen Systemen. Also, wenn Sie berechnen die Differenz zwischen zwei Zeiten, die Sie könnten am Ende mit ein paar Sekunden, aber als Doppel -, sondern als die integer-Ergebnis, das Auftritt, im Jahr 2017.

    Ich denke, das ist viel schlimmer als die Konvertierungen zwischen strings und zahlen, denn es ist subtil. Ich finde es einfach zu halten Spur von dem, was ist ein string, was ist eine Zahl, aber den überblick über die Zahl der bits in einer Zahl ist mir schleierhaft.

    So, in der oben genannten Antworten gibt es einige schöne Tische, aber keine Unterscheidung zwischen 1 (als Ganzzahl) und 1 (subtile Doppel) und 1.0 (offensichtlich doppelt). Auch die Beratung, dass Sie sollten verwenden Sie immer === und nie == ist nicht toll, weil === wird manchmal nicht wo == funktioniert einwandfrei. Auch JavaScript ist nicht gleichwertig in dieser Hinsicht, weil es nur eine Zahl geben (intern es können unterschiedliche bit-Weise zusagen, aber es muss nicht zu Problemen führen,===).

    Mein Rat - verwenden Sie weder. Sie müssen schreiben Sie Ihre eigenen Vergleich-Funktion zum beheben dieses Chaos.

    InformationsquelleAutor der Antwort DavidWalley

Schreibe einen Kommentar