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

Lesezeit: 11 Minuten

1647084252 844 Wie unterscheiden sich die PHP Vergleichsoperatoren Gleichheit doppelt gleich und
Nickf

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

  • Wie genau funktioniert das los == Vergleichsarbeit?
  • Wie genau funktioniert das strenge === Vergleichsarbeit?

Was wären nützliche Beispiele?

  • @BenAubin Im Ernst, die von Ihnen vorgenommenen Änderungen haben überhaupt nichts verbessert.

    – klutt

    14. Februar 2021 um 23:43 Uhr

  • @BenAubin Ich verstehe, dass Sie helfen möchten, und das ist gut, aber diese Änderungen haben die Dinge wirklich nicht verbessert. Und jetzt, wenn Sie die Menge an Repräsentanten haben, die Sie haben, werden Ihre Änderungen nicht in eine Überprüfungswarteschlange verschoben, also seien Sie vorsichtig mit Ihren Änderungen.

    – klutt

    14. Februar 2021 um 23:58 Uhr

  • @klutt Meine Änderungen waren beabsichtigt. Das OP hat innerhalb weniger Minuten nach dem ursprünglichen Beitrag, in dem sowohl nach Javascript als auch nach PHP gefragt wurde, eine Änderung vorgenommen, sodass viele der Antworten auf beide Sprachen verweisen. Wie ich in den Bearbeitungsnotizen erwähnt habe, haben meine Bearbeitungen diesen ursprünglichen Kontext wiederhergestellt.

    – Ben Aubin

    4. März 2021 um 3:09 Uhr


1647084252 844 Wie unterscheiden sich die PHP Vergleichsoperatoren Gleichheit doppelt gleich und
Nickf

Unterschied zwischen == und ===

Der Unterschied zwischen dem locker == gleich Operator und die strenge === identischer Operator wird im genau erklärt Handbuch:

Vergleichsoperatoren

┌──────────┬───────────┬───────────────────────────────────────────────────────────┐
│ 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 == gleichen Vergleich

Wenn Sie die verwenden == -Operator oder ein anderer Vergleichsoperator, der lose Vergleiche verwendet, wie z !=, <> oder ==die muss man sich immer anschauen Kontext um zu sehen, was, wo und warum etwas umgewandelt wird, um zu verstehen, was vor sich geht.

Regeln umwandeln

Vergleichstabelle eingeben

Als Referenz und Beispiel sehen Sie die Vergleichstabelle im Handbuch:

Lose 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  │
└─────────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴─────────┴───────┴───────┘

Strikt === identischer Vergleich

Wenn Sie die verwenden === -Operator oder ein anderer Vergleichsoperator, der einen strengen Vergleich verwendet, wie z !== oder ===dann können Sie immer sicher sein, dass die Typen es nicht tun magisch ändern, da keine Konvertierung stattfindet. Beim strengen Vergleich müssen also Typ und Wert gleich 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  │ 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  │
└─────────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴─────────┴───────┴───────┘

  • findet es noch jemand seltsam, dass “000” == “0000” ?

    – Nickf

    17. September 2008 um 13:08 Uhr

  • Was mich immer überrascht, ist, dass false == array() und false == 0 aber array() != 0, also false == array() !=/== 0? das kommt mir komisch vor.

    – Pim Jäger

    17. August 2009 um 11:50 Uhr

  • @Pim …fortgesetzt: Betrachten Sie es so: Bei der Umwandlung in einen BOOL muss jeder Wert nur auf eine von zwei Seiten fallen, true oder false. Das ist einfach zu werfen. Alle anderen Werte haben jedoch für alle praktischen Zwecke praktisch unbegrenzte Kombinationen. Ist "five" == 5? array(0) == 0? array(0,0,0) == 0? 0.0000000000000000000000000000000000000000000000000001 == array()?

    – verzeihen

    17. August 2009 um 12:56 Uhr

  • @Raithlin, vorsichtig mit Array. dreifach gleich gibt false für verschiedene Arrays in Javascript, aber true für PHP, solange ihre Werte sind gleich.

    – Schrittmacher

    2. August 2013 um 10:34 Uhr

  • @Raithlin, viele, viele weitere Fallstricke. In JavaScript: "000" != "00", "000" == null, "000" == false, "0x0" == false, array() == 0, false != null, array() != null, false == "0x0", false == "000". In PHP ist es das entgegengesetzte Verhalten: "000" == "00", "000" != null, "000" != false, "0x0" != false, array() != 0, false == null, array() == null, false != "0x0", false != "000".

    – Schrittmacher

    7. August 2013 um 17:03 Uhr


1647084252 7 Wie unterscheiden sich die PHP Vergleichsoperatoren Gleichheit doppelt gleich und
Patrick Glandien

Der Operator == konvertiert zwischen zwei verschiedenen Typen, wenn sie unterschiedlich sind, während der Operator === einen „typsicheren Vergleich“ durchführt. Das bedeutet, dass nur dann true zurückgegeben wird, 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 gleichwertigen Mitgliedern stimmen NICHT überein === Operator. Beispiel:

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

  • Nitpick: === gibt nur wahr zurück, wenn beide Operanden vom gleichen Typ sind und die Werte sind gleich =)

    – Gnud

    26. Februar 2009 um 9:16 Uhr

  • @gnud Genau das hat er im Beispiel gezeigt. Wenn es nur um den Vergleich der Typen ginge, würde man es einfach als “Typenvergleich” bezeichnen, oder?

    – Rob Stevenson-Leggett

    26. Februar 2009 um 9:34 Uhr

  • Nachdem ich PHP 8 Jahre lang verwendet habe, geriet ich gestern zum ersten Mal in eine Situation, in der ich === hätte verwenden sollen

    uuɐɯǝʃǝs

    13. April 2009 um 13:21 Uhr

  • === wahr, wenn sie gleich sind und denselben Typ haben. == wahr, wenn sie gleich sind. != wahr, wenn sie nicht gleich sind. !== wahr, wenn sie entweder nicht gleich sind oder gleich, aber nicht vom gleichen Typ sind.

    – Jeremy C

    22. Oktober 2012 um 23:55 Uhr


  • Außerdem ist die Verwendung von === etwas schneller als ==, da der Wert nicht konvertiert werden muss, bevor überprüft wird, ob er gleich ist.

    – clausiere

    18. März 2014 um 20:04 Uhr

1647084252 789 Wie unterscheiden sich die PHP Vergleichsoperatoren Gleichheit doppelt gleich und
Erich Leschinski

Ein Bild sagt mehr als tausend Worte:

PHP Double Equals == Gleichheitstabelle:

Geben Sie hier die Bildbeschreibung ein

PHP dreifach gleich === Gleichheitstabelle:

Geben Sie hier die Bildbeschreibung ein

Quellcode zum Erstellen dieser Bilder:

https://github.com/sentientmachine/php_equality_charts

Guru Meditation

Diejenigen, die bei Verstand bleiben wollen, lesen nicht weiter, denn nichts davon ergibt einen Sinn, außer zu sagen, dass das Wahnsinns-Fraktal von PHP so entworfen wurde.

  1. NAN != NAN aber NAN == true.

  2. == wandelt linke und rechte Operanden in Zahlen um, wenn left eine Zahl ist. Damit 123 == "123foo"aber "123" != "123foo"

  3. Eine Hex-Zeichenfolge in Anführungszeichen ist gelegentlich ein Float und wird überraschenderweise gegen Ihren Willen in Float umgewandelt, was einen Laufzeitfehler verursacht.

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

  5. PHP-Variablen, die noch nicht deklariert wurden, sind falsch, obwohl PHP eine Möglichkeit hat, undefinierte Variablen darzustellen, mit der diese Funktion deaktiviert ist ==.

  6. "6" == " 6", "4.2" == "4.20"und "133" == "0133" aber 133 != 0133. Aber "0x10" == "16" und "1e3" == "1000" Die Offenlegung dieser überraschenden Zeichenfolgenkonvertierung in Oktal erfolgt ohne Ihre Anweisung oder Zustimmung und verursacht einen Laufzeitfehler.

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

  8. Wenn Sie 1 zur Zahl hinzufügen und sie bereits ihren Maximalwert halten, werden sie nicht umgebrochen, sondern zu ihnen gecastet infinity.

  9. Eine neue Klasse ist == bis 1.

  10. False ist der gefährlichste Wert, da False für die meisten anderen Variablen == ist, was meistens seinen Zweck verfehlt.

Hoffen:

Wenn Sie PHP verwenden, sollten Sie den Double-Equals-Operator nicht verwenden, denn wenn Sie Triple-Equals verwenden, sind die einzigen Grenzfälle, um die Sie sich Sorgen machen müssen, NAN und Zahlen, die so nahe am Maximalwert ihres Datentyps liegen, dass sie ins Unendliche umgewandelt werden. Mit Double Equals kann alles überraschend sein == zu irgendetwas oder, oder kann gegen Ihren Willen und Überraschung geworfen werden != zu etwas, von dem es offensichtlich gleich sein sollte.

Überall, wo Sie es verwenden == in PHP riecht nach schlechtem Code, weil 85 Fehler darin enthalten sind, die durch implizite Casting-Regeln aufgedeckt werden, die anscheinend von Millionen von Programmierern entwickelt wurden, die mit Brownian Motion programmieren.

  • Ist es wirklich eine gute Idee (auch sicher), immer Triple Equals zu verwenden?

    – Chazy Chaz

    16. Januar 2017 um 22:42 Uhr

  • Ja, die transitive Eigenschaft von Triple Equals macht es sicherer und webfähiger.

    – Eric Leschinski

    16. Januar 2017 um 23:55 Uhr

  • Wie kann eine Zahl nahe unendlich sein? [exploding brain gif]

    – Tim

    16. Januar 2020 um 9:55 Uhr

  • Vor allem 1.0 !== 1 das kann ein bisschen ein gotcha sein, zB floor(4 / 3) === 1 ? 'works as might be expected' : 'what?'

    – Jake

    14. November 2020 um 0:33 Uhr

  • @EricLeschinski floor(4/3) === 1 wird nicht als wahr ausgewertet, weil floor gibt a zurück float (Obwohl der Rückgabewert notwendigerweise eine Ganzzahl ist, ist er nicht vom Typ) – daher der Grund, auf diesen Fallstrick hinzuweisen. JavaScript hat dieses Problem nicht, weil es nur einen numerischen Typ gibt (obwohl es deswegen andere Probleme wie das Runden von Ganzzahlen hat).

    – Jake

    14. November 2020 um 23:59 Uhr


In Bezug auf JavaScript:

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

Das folgende Beispiel zeigt beispielsweise „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');
}

1647084253 599 Wie unterscheiden sich die PHP Vergleichsoperatoren Gleichheit doppelt gleich und
Seelenverschmelzung

Eine Ergänzung zu den anderen Antworten zum Objektvergleich:

== vergleicht Objekte anhand des Namens des Objekts und seiner Werte. Wenn zwei Objekte vom gleichen Typ sind und die gleichen Mitgliedswerte haben, $a == $b ergibt wahr.

=== vergleicht die interne Objekt-ID der Objekte. Auch wenn die Mitglieder gleich sind, $a !== $b wenn es sich nicht genau um dasselbe Objekt handelt.

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

1647084254 298 Wie unterscheiden sich die PHP Vergleichsoperatoren Gleichheit doppelt gleich und
Peter Mortensen

Es dreht sich alles um Datentypen. Nimm ein BOOL (wahr oder falsch) zum Beispiel:

true auch gleich 1 und
false auch gleich 0

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

$var=1;

Und dann mit dem vergleichen ==:

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

Aber $var ist eigentlich nicht gleich true, macht es? Es hat den int-Wert von 1 stattdessen, was wiederum gleich wahr ist.

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

Also wenn ich es täte

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

diese Bedingung wäre nicht wahr, wie $var !== true es nur == true (wenn du weißt, was ich meine).

Warum sollten Sie das brauchen?

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

Die array_search() Die 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 nicht im Array gefunden werden konnte, kehrt sie zurück falsch. Aber was wäre, wenn Sie eine array_search() auf einen Wert, der in gespeichert wurde erstes Element des Arrays (was den Array-Schlüssel von haben würde 0)….der array_search() Die Funktion würde 0 zurückgeben … was gleich falsch ist.

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

Siehst du also, wie das jetzt ein Problem sein könnte?

Die meisten Leute verwenden nicht == false beim Prüfen, ob eine Funktion falsch zurückgibt. Stattdessen verwenden sie die !. Aber eigentlich ist dies genau dasselbe wie die Verwendung ==falsealso wenn du es getan hast:

$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 also die verwenden === stattdessen, damit der Datentyp überprüft wird.

1647084254 152 Wie unterscheiden sich die PHP Vergleichsoperatoren Gleichheit doppelt gleich und
Thomas

PHP Double Equals == :

In den meisten Programmiersprachen prüft der Vergleichsoperator (==) einerseits den Datentyp und andererseits den Inhalt der Variablen auf Gleichheit. Der Standard-Vergleichsoperator (==) in PHP verhält sich anders. Diese versucht vor dem Vergleich beide Variablen in den gleichen Datentyp zu konvertieren und prüft erst dann, ob der Inhalt dieser Variablen gleich ist. Folgende Ergebnisse werden erhalten:

<?php
    var_dump( 1 == 1 );     // true
    var_dump( 1 == '1' );   // true
    var_dump( 1 == 2 );     // false
    var_dump( 1 == '2' );   // false
    var_dump( 1 == true );  // true
    var_dump( 1 == false ); // false
?>

PHP dreifach gleich === :

Dieser Operator prüft auch den Datentyp der Variablen und gibt nur dann (bool)true zurück, wenn beide Variablen den gleichen Inhalt und den gleichen Datentyp haben. Richtig wäre also:

<?php
    var_dump( 1 === 1 );     // true
    var_dump( 1 === '1' );   // false
    var_dump( 1 === 2 );     // false
    var_dump( 1 === '2' );   // false
    var_dump( 1 === true );  // false
    var_dump( 1 === false ); // false
?>

Lesen Sie mehr in Was ist der Unterschied zwischen == und === in PHP

993490cookie-checkWie unterscheiden sich die PHP-Vergleichsoperatoren Gleichheit (== doppelt gleich) und Identität (=== dreifach gleich)?

This website is using cookies to improve the user-friendliness. You agree by using the website further.

Privacy policy