Was ist der Unterschied zwischen ==
und ===
?
- Wie genau funktioniert der lose
==
Vergleich? - Wie genau funktioniert der strenge
===
Vergleich?
Was wären einige nützliche Beispiele?
Was ist der Unterschied zwischen ==
und ===
?
==
Vergleich?===
Vergleich?Was wären einige nützliche Beispiele?
==
und===
Der Unterschied zwischen dem lose ==
gleichen Operator und dem streng ===
identischen Operator wird im Handbuch genau erläutert :
Vergleichsoperatoren
┌────────────────────────────────────────────────── ───────────────────────────────────┐ │ Beispiel │ Name │ Ergebnis │ ├────────────────────────────────────────────────── ───────────────────────────────────┤ │ $ a == $ b │ Gleich │ WAHR, wenn $ a nach dem Jonglieren gleich $ b ist. │ │ $ a === $ b │ Identisch │ WAHR, wenn $ a gleich $ b ist und sie vom gleichen Typ sind. │ └────────────────────────────────────────────────── ───────────────────────────────────┘
==
gleicher VergleichWenn Sie den verwenden ==
Operator oder einen anderen Vergleichsoperator , den losen Vergleich verwendet wie !=
, <>
oder ==
haben Sie immer Blick auf dem Kontext etwas zu sehen, wo und warum umgewandelt etwas wird , zu verstehen , was los ist.
Als Referenz und Beispiel sehen Sie die Vergleichstabelle im Handbuch :
Lose Vergleiche mit
==
┌────────────────────────────────────────────────── ┬────────────────────────────────────────────────── ┬───────┐ │ │ TRUE │ FALSE │ 1 │ 0 │ -1 │ "1" │ "0" │ "-1" │ NULL │ array () │ "php" │ "" │ ├────────────────────────────────────────────────── ┼────────────────────────────────────────────────── ┼───────┤ │ WAHR │ WAHR │ FALSCH │ WAHR │ FALSCH │ WAHR │ WAHR │ FALSCH │ WAHR │ FALSCH │ FALSCH │ WAHR │ FALSCH │ │ FALSE │ FALSE │ TRUE │ FALSE │ TRUE │ FALSE │ FALSE │ TRUE │ FALSE │ TRUE │ TRUE │ FALSE │ TRUE │ │ 1 │ WAHR │ FALSCH │ WAHR │ FALSCH │ FALSCH │ WAHR │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ │ 0 │ FALSE │ TRUE │ FALSE │ TRUE │ FALSE │ FALSE │ TRUE │ FALSE │ TRUE │ FALSE │ TRUE │ TRUE │ │ -1 │ WAHR │ FALSCH │ FALSCH │ FALSCH │ WAHR │ FALSCH │ FALSCH │ WAHR │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ │ "1" │ WAHR │ FALSCH │ WAHR │ FALSCH │ FALSCH │ WAHR │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ │ "0" │ FALSE │ TRUE │ FALSE │ TRUE │ FALSE │ FALSE │ TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ │ "-1" │ WAHR │ FALSCH │ FALSCH │ FALSCH │ WAHR │ FALSCH │ FALSCH │ WAHR │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ │ NULL │ FALSCH │ WAHR │ FALSCH │ WAHR │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ WAHR │ WAHR │ FALSCH │ WAHR │ │ array () │ FALSE │ TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE │ TRUE │ FALSE │ FALSE │ Ph "php" │ WAHR │ FALSCH │ FALSCH │ WAHR │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ WAHR │ FALSCH │ │ "" │ FALSE │ TRUE │ FALSE │ TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE │ FALSE │ FALSE │ TRUE │ └────────────────────────────────────────────────── ┴────────────────────────────────────────────────── ┴───────┘
===
identischer VergleichWenn Sie den ===
Operator oder einen anderen Vergleichsoperator verwenden, der einen strengen Vergleich wie !==
oder verwendet ===
, können Sie immer sicher sein, dass sich die Typen nicht auf magische Weise ändern, da keine Konvertierung stattfindet. Bei einem strengen Vergleich müssen also Typ und Wert gleich sein, nicht nur der Wert.
Als Referenz und Beispiel sehen Sie die Vergleichstabelle im Handbuch :
Strenge Vergleiche mit
===
┌────────────────────────────────────────────────── ┬────────────────────────────────────────────────── ┬───────┐ │ │ TRUE │ FALSE │ 1 │ 0 │ -1 │ "1" │ "0" │ "-1" │ NULL │ array () │ "php" │ "" │ ├────────────────────────────────────────────────── ┼────────────────────────────────────────────────── ┼───────┤ │ WAHR │ WAHR │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ FALSCH │ │ 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 "-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 │ Ph "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 │ └────────────────────────────────────────────────── ┴────────────────────────────────────────────────── ┴───────┘
true
oderfalse
. Das ist einfach zu besetzen. Alle anderen Werte haben jedoch für praktisch alle Zwecke praktisch unbegrenzte Kombinationen. Ist"five" == 5
?array(0) == 0
?array(0,0,0) == 0
?0.0000000000000000000000000000000000000000000000000001 == array()
?false
für verschiedene Arrays in Javascript, abertrue
für PHP, solange ihre Werte gleich sind ."000" != "00"
,"000" == null
,"000" == false
,"0x0" == false
,array() == 0
,false != null
,array() != null
,false == "0x0"
,false == "000"
. In PHP ist es entgegengesetztes Verhalten:"000" == "00"
,"000" != null
,"000" != false
,"0x0" != false
,array() != 0
,false == null
,array() == null
,false != "0x0"
,false != "000"
.Der Operator == wechselt zwischen zwei verschiedenen Typen, wenn sie unterschiedlich sind, während der Operator === einen 'typsicheren Vergleich' durchführt. Dies bedeutet, dass nur dann true zurückgegeben wird, wenn beide Operanden denselben Typ und denselben Wert haben.
Beispiele:
Warnung : Zwei Instanzen derselben Klasse mit gleichwertigen Mitgliedern stimmen NICHT mit dem
===
Operator überein . Beispiel:quelle
Ein Bild sagt mehr als tausend Worte:
PHP Double Equals
==
Gleichheitstabelle:PHP Triple Equals
===
Equality-Diagramm:Quellcode zum Erstellen dieser Bilder:
https://github.com/sentientmachine/php_equality_charts
Guru Meditation
Diejenigen, die ihre geistige Gesundheit bewahren möchten, lesen nicht weiter, weil nichts davon Sinn macht, außer zu sagen, dass das Wahnsinns-Fraktal von PHP so entworfen wurde.
NAN != NAN
aberNAN == true
.==
konvertiert linke und rechte Operanden in Zahlen, wenn links eine Zahl ist. Also123 == "123foo"
, aber"123" != "123foo"
Eine hexadezimale Zeichenfolge in Anführungszeichen ist gelegentlich ein Float und wird überraschend gegen Ihren Willen schweben, was zu einem Laufzeitfehler führt.
==
ist nicht transitiv weil"0"== 0
und0 == ""
aber"0" != ""
==
."6" == " 6"
,,"4.2" == "4.20"
und"133" == "0133"
aber133 != 0133
. Aber"0x10" == "16"
und"1e3" == "1000"
diese Überraschung String - Konvertierung zu Oktal Belichtung tritt sowohl ohne Ihre Anweisung oder Genehmigung, einen Laufzeitfehler verursacht.False == 0
,""
,[]
Und"0"
.Wenn Zahlen groß genug sind, sind sie == Unendlichkeit.
Eine neue Klasse ist == bis 1.
Hoffnung:
Wenn Sie PHP verwenden, sollten Sie den Operator "Double Equals" nicht verwenden. Wenn Sie Triple Equals verwenden, müssen Sie sich nur um NAN und Zahlen sorgen, die so nahe an der Unendlichkeit liegen, dass sie auf "unendlich" gesetzt werden. Mit Double Equals kann alles
==
für irgendetwas überraschend sein oder oder kann gegen Ihren Willen und!=
für etwas, von dem es offensichtlich gleich sein sollte , überrascht werden.Überall, wo Sie
==
in PHP verwenden, riecht es schlecht nach Code, da 85 Fehler darin enthalten sind, die durch implizite Casting-Regeln aufgedeckt werden, die von Millionen von Programmierern entwickelt wurden, die mit Brownian Motion programmieren.quelle
In Bezug auf JavaScript:
Der Operator === funktioniert genauso wie der Operator ==, erfordert jedoch, dass seine Operanden nicht nur denselben Wert, sondern auch denselben Datentyp haben.
Im folgenden Beispiel wird beispielsweise "x und y sind gleich" angezeigt, nicht jedoch "x und y sind identisch".
quelle
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,
$a == $b
ergibt sich true.=== vergleicht die interne Objekt-ID der Objekte. Auch wenn die Mitglieder gleich sind,
$a !== $b
wenn sie nicht genau das gleiche Objekt sind.quelle
In einfachsten Worten:
== prüft ob gleichwertig (nur Wert)
=== prüft, ob das gleiche (Wert && Typ)
Äquivalent gegen Gleiches ist: Eine Analogie
1 + 1 = 2 + 0 (äquivalent)
1 + 1 = 1 + 1 (gleich)
In PHP:
true == 1 (true - äquivalent im Wert)
true === 1 (false - nicht gleich im Wert && Typ)
quelle
Es geht nur um Datentypen. Nehmen Sie
BOOL
zum Beispiel ein (wahr oder falsch):true
auch gleich1
undfalse
auch gleich0
Das
==
kümmert sich beim Vergleich nicht um die Datentypen: Wenn Sie also eine Variable haben, die 1 ist (was auch sein könntetrue
):$var=1;
Und dann vergleiche mit
==
:Aber ist
$var
das eigentlich nicht gleichtrue
, oder? Es hat den int-Wert von1
stattdessen , was 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 täte
Diese Bedingung wäre nicht wahr, wie
$var !== true
es nur ist== 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
array_search()
Funktion 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 im Array nicht gefunden werden konnte, wird false zurückgegeben . Aber was ist, wenn Siearray_search()
einen Wert für einen Wert erstellt haben, der im ersten Element des Arrays gespeichert wurde (das den Array-Schlüssel von haben würde0
)?array_search()
Funktion würde 0 zurückgeben. Dies ist gleich false.Also, wenn du es getan hast:
Sehen Sie also, wie dies jetzt ein Problem sein könnte?
Die meisten Leute verwenden nicht,
== false
wenn sie prüfen, ob eine Funktion false zurückgibt. Stattdessen verwenden sie die!
. Aber eigentlich ist dies genau das gleiche wie bei der Verwendung==false
. Wenn Sie also Folgendes getan haben:Für solche Dinge würden Sie
===
stattdessen das verwenden, damit der Datentyp überprüft wird.quelle
Ein Beispiel ist, dass ein Datenbankattribut null oder "" sein kann:
quelle
php == ist ein Vergleichsoperator, der den Wert der Variablen vergleicht. Aber === vergleicht den Wert und den Datentyp.
Zum Beispiel,
In diesem Fall lautet die Ausgabe "Variablen sind gleich", obwohl ihre Datentypen unterschiedlich sind.
Wenn wir jedoch === anstelle von == verwenden, lautet die Ausgabe 'Variablen sind nicht gleich'. Das PHP vergleicht zuerst den Wert der Variablen und dann den Datentyp. Hier sind die Werte gleich, aber die Datentypen sind unterschiedlich.
quelle
Gegeben
x = 5
1) Operator: == ist "gleich".
x == 8
ist falsch2) Operator: === ist "genau gleich" (Wert und Typ)
x === 5
ist wahr,x === "5"
ist falschquelle
Sei aber vorsichtig. Hier ist ein berüchtigtes Problem.
vs.
quelle
Kurz gesagt, === funktioniert genauso wie == in den meisten anderen Programmiersprachen.
Mit PHP können Sie Vergleiche anstellen, die nicht wirklich sinnvoll sind. Beispiel:
Während dies einige interessante "Verknüpfungen" zulässt, sollten Sie aufpassen, da eine Funktion, die etwas zurückgibt, das sie nicht zurückgeben sollte (wie "Fehler" anstelle einer Zahl), nicht abgefangen wird und Sie sich fragen, was passiert ist.
In PHP vergleicht == Werte und führt bei Bedarf eine Typkonvertierung durch (z. B. wird die Zeichenfolge "12343sdfjskfjds" in einem ganzzahligen Vergleich zu "12343"). === vergleicht den Wert AND type und gibt false zurück, wenn der Typ nicht identisch ist.
Wenn Sie im PHP-Handbuch nachsehen, werden Sie feststellen, dass viele Funktionen "false" zurückgeben, wenn die Funktion fehlschlägt. In einem erfolgreichen Szenario geben sie jedoch möglicherweise 0 zurück. Aus diesem Grund empfehlen sie, "if (function ()! ==" auszuführen false) "um Fehler zu vermeiden.
quelle
Einige Beispiele
PS
vs.
quelle
Sie würden === verwenden, um zu testen, ob eine Funktion oder Variable falsch ist, anstatt nur falsch zu sein (Null oder eine leere Zeichenfolge).
In diesem Fall würde strpos 0 zurückgeben, was im Test false entspricht
oder
das ist nicht was du hier willst.
quelle
Nehmen Sie zum Beispiel die
fwrite()
Funktion in PHP an, wenn Sie eine über die andere verwenden möchten.Diese Funktion schreibt Inhalte in einen Dateistream. Laut PHP "
fwrite()
gibt die Anzahl der geschriebenen Bytes oder FALSE bei einem Fehler zurück." Wenn Sie testen möchten, ob der Funktionsaufruf erfolgreich war, ist diese Methode fehlerhaft:Es kann Null zurückgeben (und wird als erfolgreich angesehen), und Ihr Zustand wird immer noch ausgelöst. Der richtige Weg wäre:
quelle
PHP ist eine lose getippte Sprache. Die Verwendung des Double-Equal-Operators ermöglicht eine lose Überprüfung einer Variablen.
Das lose Überprüfen eines Werts würde es ermöglichen, dass einige ähnliche, aber nicht gleiche Werte gleich sind:
Alle diese Werte würden mit dem Operator double gleich gleich sein.
quelle
Variablen haben einen Typ und einen Wert.
Wenn Sie diese Variablen (in PHP) verwenden, haben Sie manchmal nicht den guten Typ. Zum Beispiel, wenn Sie dies tun
PHP muss $ var in Integer konvertieren ("to cast"). In diesem Fall ist "$ var == 1" wahr, da jede nicht leere Zeichenfolge in 1 umgewandelt wird.
Wenn Sie === verwenden, überprüfen Sie, ob der Wert AND THE TYPE gleich ist, sodass "$ var === 1" falsch ist.
Dies ist beispielsweise nützlich, wenn Sie eine Funktion haben, die false (bei Fehler) und 0 (Ergebnis) zurückgeben kann:
Dieser Code ist falsch, als würde er
myFunction()
0 zurückgeben, er wird in false umgewandelt und Sie scheinen einen Fehler zu haben. Der richtige Code lautet:weil der Test ist, dass der Rückgabewert "ein Boolescher Wert und falsch ist" und nicht "in false umgewandelt werden kann".
quelle
Der
===
Operator soll die exakte Gleichheit der Inhalte vergleichen, während der==
Operator die semantische Gleichheit vergleichen würde. Insbesondere werden Zeichenfolgen zu Zahlen gezwungen.Gleichheit ist ein großes Thema. Siehe den Wikipedia-Artikel zur Gleichstellung .
quelle
quelle
Alle bisherigen Antworten ignorieren ein gefährliches Problem mit ===. Nebenbei wurde angemerkt, aber nicht betont, dass Integer und Double unterschiedliche Typen sind, also der folgende Code:
gibt:
Beachten Sie, dass dies KEIN Fall eines "Rundungsfehlers" ist. Die beiden Zahlen sind bis zum letzten Bit genau gleich, haben jedoch unterschiedliche Typen.
Dies ist ein unangenehmes Problem, da ein Programm mit === 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 eine Ganzzahl zufällig groß genug ist, um in ein Double umgewandelt zu werden, wird ihr Typ "für immer" geändert, obwohl eine nachfolgende Operation oder viele Operationen sie möglicherweise auf eine kleine Ganzzahl zurückführen. Und es wird schlimmer. Es kann sich ausbreiten - Doppelinfektionen können nacheinander auf alles übertragen werden, was es berührt.
In der realen Welt ist dies wahrscheinlich ein Problem bei Programmen, die beispielsweise Daten über das Jahr 2038 hinaus verarbeiten. 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 einigen Systemen "magisch" auf "doppelt" umgeschaltet wird. Wenn Sie also die Differenz zwischen zwei Malen berechnen, erhalten Sie möglicherweise einige Sekunden, jedoch als Doppel und nicht als ganzzahliges Ergebnis, das im Jahr 2017 auftritt.
Ich denke, das ist viel schlimmer als die Umrechnung zwischen Zeichenfolgen und Zahlen, weil es subtil ist. Ich finde es einfach zu verfolgen, was eine Zeichenfolge und was eine Zahl ist, aber die Anzahl der Bits in einer Zahl zu verfolgen, ist mir ein Rätsel.
In den obigen Antworten gibt es also einige nette Tabellen, aber keine Unterscheidung zwischen 1 (als Ganzzahl) und 1 (subtiles Doppel) und 1,0 (offensichtliches Doppel). Außerdem ist der Rat, den Sie immer === und niemals == verwenden sollten, nicht großartig, da === manchmal fehlschlägt, wenn == ordnungsgemäß funktioniert. Auch JavaScript ist in dieser Hinsicht nicht gleichwertig, da es nur einen Zahlentyp hat (intern kann es unterschiedliche bitweise Darstellungen haben, aber es verursacht keine Probleme für ===).
Mein Rat - benutze keine. Sie müssen Ihre eigene Vergleichsfunktion schreiben, um dieses Durcheinander wirklich zu beheben.
quelle
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 Schlüsselsorten
Wenn Sie ein Array mit einer Schlüsselsortierung und ein anderes Array mit einer anderen Schlüsselsortierung haben, sind diese streng unterschiedlich (dh verwenden
===
). Dies kann dazu führen, dass Sie ein Array nach Schlüsseln 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 spezielle Sortierung in das Array zu verschieben. Ein gutes Beispiel wäre ein Array mit Zeichenfolgen als Schlüssel. Nun tief in ein Beispiel:
Jetzt haben wir ein Array mit nicht sortierten Schlüsseln (z. B. "er" kam nach "Ihnen"). Betrachten Sie dasselbe Array, aber wir haben seine Schlüssel alphabetisch sortiert:
Tipp : Sie können ein Array mit der Funktion ksort () nach Schlüsseln sortieren .
Jetzt haben Sie ein anderes Array mit einer anderen Schlüsselsortierung als das erste. Also werden wir sie vergleichen:
Hinweis : Es mag offensichtlich sein, aber der Vergleich zweier verschiedener Arrays mit einem strengen Vergleich führt immer zu Ergebnissen
false
. Zwei beliebige Arrays können jedoch 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
Beachten Sie, dass zwei verschiedene Objekte niemals streng gleich sind . Diese Beispiele würden helfen:
Hinweis : Durch das Zuweisen eines Objekts zu einer anderen Variablen wird keine Kopie erstellt, sondern ein Verweis auf denselben Speicherort wie das Objekt erstellt. Siehe hier .
Hinweis : Ab PHP7 wurden anonyme Klassen hinzugefügt. Aus den Ergebnissen ergibt sich kein Unterschied zwischen
new class {}
undnew stdClass()
in den obigen Tests.quelle