it-swarm-eu.dev

Wie geht das? PHP Vergleichsoperatoren für Gleichheit (== double gleich) und Identität (=== dreifach gleich) unterscheiden sich?

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

  • Wie genau funktioniert der lose ==-Vergleich?
  • Wie genau funktioniert der strikte ===-Vergleich? 

Was wären einige nützliche Beispiele?

451
nickf

Unterschied zwischen == und ===

Der Unterschied zwischen dem lose gleichen Operator == und dem strengen identischen Operator === wird im Handbuch genau erklärt:

Vergleichsoperatoren

 ┌──────────┬───────────┬───────────────────── ──────────────────────────────────────┐ 
 │ Beispiel │ Name │ Ergebnis │ 
 ├──────────┼───────────┼──────────────────── ───────────────────────────────────────┤ 
 │ $ a == $ b │ Equal │ TRUE, wenn $ a nach dem Typ Jonglieren gleich $ b ist. │ 
 │ $ a === $ b │ Identisch │ WAHR, wenn $ a gleich $ b ist und sie vom gleichen Typ sind. │ 
 └──────────┴───────────┴──────────────────── ───────────────────────────────────────┘ 

Lose == gleicher Vergleich

Wenn Sie den == -Operator oder einen anderen Vergleichsoperator verwenden, der einen lockeren Vergleich verwendet, z. B. !=, <> oder ==, müssen Sie immer den Kontext , um zu sehen, was, wo und warum etwas konvertiert wird, um zu verstehen, was los ist.

Regeln konvertieren

Vergleichstabelle eingeben

Als Referenz und Beispiel sehen Sie die Vergleichstabelle im Handbuch :

Lose Vergleiche mit ==

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

Strenger === identischer Vergleich

Wenn Sie den Operator === oder einen anderen Vergleichsoperator verwenden, der einen strengen Vergleich verwendet, wie z. B. !== oder ===, können Sie immer sicher sein, dass die Typen nicht magisch ändern, da keine Konvertierung stattfindet. Bei einem strengen Vergleich müssen also Typ und Wert identisch sein, nicht nur der Wert.

Vergleichstabelle eingeben

Als Referenz und Beispiel sehen Sie die Vergleichstabelle im Handbuch :

Strenge Vergleiche mit ===

┌─────────┬───────┬───────┬───────┬───────┬─────── ┬───────┬───────┬───────┬───────┬─────────┬─────── ┬───────┐ 
 │ TRUE │ FALSE │ 1 │ 0 │ -1 │ 1 │ 0 │ -1 │ NULL ULL array () │ php │ "" │ 
 ├─────────┼───────┼───────┼───────┼─────── ┼───────┼───────┼───────┼───────┼───────┼───────── ┼───────┼───────┤ 
 │ WAHR │ WAHR │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ 
 │ FALSCH │ FALSCH │ WAHR │ FALSCH E │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ 
 1 │ FALSCH │ FALSCH │ WAHR │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH FALSCH │ 
 │ 0 │ FALSCH │ FALSCH │ FALSCH │ WAHR │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ 
 │ -1 │ FALSCH │ FALSCH │ │ WAHR │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ 
 │ "1" │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ 
 │ "0" │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ 
 │ "-1" │ FALSE │ FALSE │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ WAHR │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ 
 │ NULL │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ WAHR │ FALSCH │ FALSCH │ FALSCH │ 
 │ Array () │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH WAHR │ FALSCH │ FALSCH │ 
 │ "php" │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ WAHR │ FALSCH │ 
 │ " │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ WAHR │ 
 └─────────┴───────┴─── ────┴───────┴───────┴───────┴───────┴───────┴───── ──┴───────┴─────────┴───────┴───────┘ 
603
nickf

Der Operator == wechselt zwischen zwei verschiedenen Typen, wenn sie unterschiedlich sind, während der Operator === einen typsicheren Vergleich durchführt. Das bedeutet, dass es nur dann true zurückgibt, wenn beide Operanden denselben Typ und denselben 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 derselben Klasse mit entsprechenden Mitgliedern stimmen NICHT mit dem ===-Operator überein. Beispiel:

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

Ein Bild sagt mehr als tausend Worte:

PHP Double Equals == Gleichheitstabelle:

 enter image description here

PHP Triple Equals === Gleichheitstabelle:

 enter image description here

Quellcode zum Erstellen dieser Bilder:

https://github.com/sentientmachine/php_equality_charts

Guru Meditation

Diejenigen, die ihren Verstand behalten wollen, lesen nicht weiter.

  1. == konvertiert linke und rechte Operanden nach Möglichkeit in Zahlen 123 == "123foo", aber "123" != "123foo"
  2. Eine hexadezimale Zeichenfolge in Anführungszeichen ist gelegentlich ein Float und wird gegen Ihren Willen in diese umgewandelt.
  3. == ist nicht transitiv, da "0"== 0 und 0 == "" aber "0" != ""
  4. "6" == " 6", "4.2" == "4.20" und "133" == "0133", aber 133 != 0133, da 0133 oktal ist. Aber "0x10" == "16" und "1e3" == "1000"
  5. Noch nicht deklarierte PHP-Variablen sind false.

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

  7. Wenn die Zahlen groß genug sind, sind sie unendlich.
  8. NAN == selbst nicht, aber es ist wahr.
  9. Eine frische Klasse ist == bis 1.
  10. False ist der gefährlichste Wert, da False == für die meisten anderen Variablen ist, meistens den Zweck abwertend.

Hoffen:

Wenn Sie PHP verwenden, dürfen Sie den double-equals-Operator nicht verwenden. Verwenden Sie immer Triple-Equals.

58
Eric Leschinski

In Bezug auf JavaScript:

Der Operator === arbeitet genauso wie der Operator ==, setzt jedoch voraus, dass seine Operanden nicht nur denselben Wert, sondern auch denselben Datentyp haben.

Im Beispiel unten wird beispielsweise 'x und y sind gleich' angezeigt, nicht jedoch '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');
}
38
user1684

Eine Ergänzung zu den anderen Antworten zum Objektvergleich:

== vergleicht Objekte anhand des Objektnamens und ihrer Werte. Wenn zwei Objekte vom gleichen Typ sind und dieselben Elementwerte haben, ergibt $a == $b den Wert true.

=== vergleicht die interne Objekt-ID der Objekte. Selbst wenn die Mitglieder gleich sind, $a !== $b, wenn sie nicht genau das gleiche Objekt 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
22
soulmerge

In einfachsten Worten:

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

=== prüft ob gleich (Wert && type)


Äquivalent vs. Same: Eine Analogie

1 + 1 = 2 + 0 (Äquivalent)

1 + 1 = 1 + 1 (gleich)


In PHP:

true == 1 (true - Äquivalent im Wert)

true === 1 (falsch - nicht dasselbe in Wert && type)

  • wahr ist boolean
  • 1 ist int
13
silver

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

true entspricht auch 1 und false entspricht auch 0

Der == kümmert sich nicht um die Datentypen beim Vergleich: Wenn Sie also eine Variable hätten, die 1 ist (was auch true sein könnte):

$var=1;

Und dann mit dem == vergleichen:

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

Aber $var ist nicht wirklich gleich true, oder? Es hat stattdessen den int-Wert von 1, der wiederum gleich true ist.

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

Also wenn ich es tat

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

diese Bedingung wäre nicht wahr, da $var !== true nur == true (wenn Sie wissen, was ich meine).

Warum brauchst du das?

Einfach - werfen wir einen Blick auf eine der Funktionen von PHP: array_search():

Die Funktion array_search() sucht einfach nach einem Wert in einem Array und gibt den Schlüssel des Elements zurück, in dem der Wert gefunden wurde. Wenn der Wert nicht im Array gefunden werden konnte, wird false zurückgegeben. Was aber, wenn Sie eine array_search() mit einem Wert machen würden, der im ersten Element des Arrays gespeichert ist (der den Array-Schlüssel von 0 hätte) ... würde die array_search()-Funktion 0 ... zurückgeben, was ist gleich falsch ..

Wenn du es getan hast:

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

Sehen Sie, wie dies jetzt ein Problem sein könnte?

Die meisten Leute verwenden == false nicht, wenn sie prüfen, ob eine Funktion false zurückgibt. Stattdessen verwenden sie den !. Tatsächlich ist dies jedoch genau das Gleiche wie bei Verwendung von ==false.

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

Für solche Dinge würden Sie stattdessen === verwenden, damit der Datentyp geprüft wird.

8
user849137

Ein Beispiel ist, dass ein Datenbankattribut null oder "" sein kann:

$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
fico7489

Gegebener x = 5

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

6
Mannusanghi

Einige 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 den Wert und kümmert sich nicht um die Datentypen

vs.

=== Vergleicht die Werte und Datentypen

4
Mohit Tanwani

Kurz gesagt, === funktioniert auf die gleiche Weise wie in den meisten anderen Programmiersprachen.

Mit PHP können Sie Vergleiche anstellen, die nicht wirklich sinnvoll sind. Beispiel:

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

Während dies einige interessante "Abkürzungen" ermöglicht, sollten Sie aufpassen, da eine Funktion, die etwas zurückgibt (wie "error" anstelle einer Zahl), nicht gefangen wird und Sie sich fragen, was passiert ist.

In PHP vergleicht == Werte und führt bei Bedarf eine Typumwandlung durch (beispielsweise wird die Zeichenfolge "12343sdfjskfjds" in einem Ganzzahlvergleich zu "12343"). === vergleicht den Wert AND-Typ und gibt false zurück, wenn der Typ nicht derselbe ist.

Wenn Sie im Handbuch PHP nachschauen, werden Sie feststellen, dass viele Funktionen "false" zurückgeben, wenn die Funktion fehlschlägt. In einem erfolgreichen Szenario können sie jedoch 0 zurückgeben. Daher empfehlen sie "if (function ( )! == false) "um Fehler zu vermeiden.

3
Christian P.
$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

Sei 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...
}
3
Seph

PHP ist eine locker getippte Sprache. Die Verwendung des Double-Equal-Operators ermöglicht das lose Prüfen einer Variablen.

Durch das lose Prüfen eines Werts würden einige ähnliche, aber nicht gleiche Werte gleichgesetzt:

  • ''
  • null
  • false

Alle diese Werte würden unter Verwendung des Double-Equal-Operators als gleich gelten.

2
Cory Collier

Sie würden === verwenden, um zu testen, ob eine Funktion oder Variable falsch ist, und nicht einfach gleich falsch (null oder eine leere Zeichenfolge).

$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 würde strpos 0 zurückgeben, was im Test falsch wäre

if ($pos == false)

oder

if (!$pos)

was Sie hier nicht wollen.

2
Stacey Richards

Wenn Sie eine über der anderen verwenden möchten, nehmen Sie zum Beispiel die Funktion fwrite() in PHP.

Diese Funktion schreibt den Inhalt in einen Dateistream. Laut PHP gibt "fwrite() die Anzahl der geschriebenen Bytes zurück oder im Fehlerfall FALSE". Wenn Sie testen möchten, ob der Funktionsaufruf erfolgreich war, ist diese Methode fehlerhaft:

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

Es kann Null zurückgeben (und gilt als erfolgreich), und Ihre Bedingung wird immer noch ausgelöst. Der richtige Weg wäre:

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

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

Zum Beispiel,

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

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

In diesem Fall lautet die Ausgabe "Variablen sind gleich", auch wenn sich die Datentypen unterscheiden.

Wenn wir jedoch === anstelle von == verwenden, lautet die Ausgabe "Variablen sind nicht gleich". Php vergleicht zuerst den Wert der Variablen und dann den Datentyp. Hier sind die Werte gleich, aber die Datentypen unterscheiden sich.

1
2rahulsk

Alle Antworten ignorieren bisher ein gefährliches Problem mit ===. Es wurde nebenbei bemerkt, aber nicht betont, dass Integer und Double verschiedene Typen sind, daher 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 NICHT ein "Rundungsfehler" ist. Die beiden Zahlen sind bis auf das letzte Bit genau gleich, aber sie haben unterschiedliche Typen.

Dies ist ein unangenehmes Problem, da ein Programm, das === verwendet, jahrelang problemlos ausgeführt werden kann, wenn alle Zahlen klein genug sind (wobei "klein genug" von der Hardware und dem Betriebssystem abhängt, auf dem Sie ausgeführt werden). Wenn jedoch zufällig eine ganze Zahl groß genug ist, um in ein Double umgewandelt zu werden, wird ihr Typ "für immer" geändert, auch wenn eine nachfolgende Operation oder viele Operationen sie auf eine kleine ganze Zahl zurückführen können. Und es wird schlimmer. Es kann sich ausbreiten - eine Infektion mit zwei verschiedenen Dingen kann an alles, was es berührt, weitergegeben werden - eine Berechnung nach der anderen. 

In der realen Welt ist dies wahrscheinlich ein Problem bei Programmen, die zum Beispiel mit Daten nach dem Jahr 2038 umgehen. Zu diesem Zeitpunkt benötigen UNIX-Zeitstempel (Anzahl der Sekunden seit 1970-01-01 00:00:00 UTC) mehr als 32 Bit, sodass ihre Darstellung auf manchen Systemen "magisch" wechselt. Wenn Sie also die Differenz zwischen zwei Zeitpunkten berechnen, erhalten Sie möglicherweise ein paar Sekunden, aber doppelt so viel als das ganzzahlige Ergebnis, das im Jahr 2017 auftritt.

Ich denke, das ist viel schlimmer als Konvertierungen zwischen Zeichenketten und Zahlen, weil es subtil ist. Ich kann leicht nachverfolgen, was eine Zeichenfolge und eine Zahl ist, aber die Anzahl der Bits in einer Zahl zu verfolgen, ist mir unklar.

In den obigen Antworten gibt es also einige Nice-Tabellen, aber keine Unterscheidung zwischen 1 (als Ganzzahl) und 1 (subtiles Double) und 1.0 (offensichtliches Double). Auch der Hinweis, dass Sie immer === und nie == verwenden sollten, ist nicht großartig, da === manchmal fehlschlägt, wenn == ordnungsgemäß funktioniert. Außerdem ist JavaScript in dieser Hinsicht nicht gleichwertig, da es nur einen Zahlentyp hat (intern kann es andere bitweise Darstellungen geben, es verursacht jedoch keine Probleme für ===).

Mein Rat - verwende keinen. Sie müssen Ihre eigene Vergleichsfunktion schreiben, um dieses Durcheinander wirklich zu beheben.

1
DavidWalley
<?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);
?>
1
Sathish

Variablen haben einen Typ und einen Wert.

  • $ var = "test" ist eine Zeichenfolge, die "test" enthält.
  • $ var2 = 24 ist ein ganzzahliger vhose-Wert ist 24.

Wenn Sie diese Variablen verwenden (in PHP), haben Sie manchmal nicht den richtigen Typ . Zum Beispiel, wenn Sie dies tun

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

PHP muss $ var in eine Ganzzahl konvertieren ("umwandeln"). In diesem Fall ist "$ var == 1" wahr, da eine nicht leere Zeichenfolge in 1 umgewandelt wird.

Wenn Sie === verwenden, überprüfen Sie, ob der Wert AND THE TYPE gleich ist. "$ Var === 1" ist also falsch.

Dies ist beispielsweise nützlich, wenn Sie über eine Funktion verfügen, die false (bei Fehler) und 0 (Ergebnis) zurückgeben kann:

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

Dieser Code ist falsch, da myFunction() 0 zurückgibt, in false umgewandelt wird und ein Fehler vorliegt. Der korrekte Code lautet:

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

weil der Test ist, dass der Rückgabewert "ein boolescher Wert ist und falsch ist" und nicht "kann in falsch umgewandelt werden".

1
ofaurax

Der ===-Operator soll die exact - Inhaltsgleichheit vergleichen, während der ==-Operator die semantische Gleichheit vergleicht. Insbesondere werden Strings zu Zahlen gezwungen.

Gleichheit ist ein riesiges Thema. Siehe den Wikipedia-Artikel zur Gleichstellung .

1
kmkaplan

Es gibt zwei Unterschiede zwischen == und === in PHP Arrays und Objekten, die ich hier nicht erwähnt habe. zwei Arrays mit unterschiedlichen Schlüsselsorten und Objekten.

Zwei Arrays mit unterschiedlichen Key-Sorten

Wenn Sie ein Array mit einer Schlüsselsortierung und ein anderes Array mit einer anderen Schlüsselsortierung haben, unterscheiden sich diese streng (d. H. Mit ===). Dies kann dazu führen, dass Sie ein Array mit einem Schlüssel sortieren und versuchen, das sortierte Array mit dem ursprünglichen Array zu vergleichen.

Betrachten Sie beispielsweise ein leeres Array. Zunächst versuchen wir, einige neue Indizes ohne besondere Sortierung in das Array zu pushen. 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 ein Array mit nicht sortierten Schlüsseln (z. B. "er" kam nach "Sie"). Betrachten Sie dasselbe Array, aber wir haben die Schlüssel alphabetisch sortiert:

// Declare array
$alphabetArr = [];

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

Tip: Sie können ein Array nach Schlüssel sortieren, indem Sie die Funktion ksort () verwenden.

Jetzt haben Sie ein anderes Array mit einer anderen Schlüsselsortierung als der ersten. Also werden wir sie vergleichen:

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

Note: Es mag offensichtlich sein, aber der Vergleich zweier verschiedener Arrays mit strengen Vergleichen ergibt immer false. Zwei willkürliche Arrays können jedoch mit === gleich sein oder nicht.

Sie würden sagen: "Dieser Unterschied ist vernachlässigbar". Dann sage ich, es ist ein Unterschied und sollte in Betracht gezogen werden und kann jederzeit passieren. Wie oben erwähnt, ist das Sortieren von Schlüsseln in einem Array ein gutes Beispiel dafür.

Objekte

Denken Sie daran, zwei verschiedene Objekte sind niemals streng gleich. Diese Beispiele würden helfen:

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

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

Note: Durch die Zuweisung eines Objekts zu einer anderen Variablen wird keine Kopie erstellt, sondern es wird eine Referenz auf denselben Speicherort des Objekts erstellt. Siehe hier .

Note: Ab PHP7 wurden anonyme Klassen hinzugefügt. Aufgrund der Ergebnisse besteht in den obigen Tests kein Unterschied zwischen new class {} und new stdClass().

0
MAChitgarha