it-swarm-eu.dev

Jak to PHP rovnost (== dvojnásobek rovná) a identita (=== trojnásobek rovná se) se liší operátory?

Jaký je rozdíl mezi == a ===?

  • Jak přesně funguje srovnání volně ==?
  • Jak přesně funguje komparace ===

Jaké by byly nějaké užitečné příklady?

451
nickf

Rozdíl mezi == a ===

Rozdíl mezi volným == rovným operátorem a přísným === identickým operátorem je přesně vysvětlen v manuálu :

Porovnávací operátory

 ┌──────────┬───────────┬───────────────────── ──────────────────────────────────────┐ 
 │ Příklad │ Název │ Výsledek │ 
 ├──────────┼───────────┼──────────────────── ───────────────────────────────────────┤ 
 │ $ a == $ b │ Rovné │ TRUE, pokud $ a je rovno $ b po žonglování typu. │ 
 │ $ a === $ b │ Identické │ TRUE, pokud $ a je rovno $ b a jsou stejného typu. │ 
 └──────────┴───────────┴──────────────────── ───────────────────────────────────────┘ 

Volně == stejné srovnání

Používáte-li operátora == nebo jiného operátora porovnání, který používá volně srovnatelné hodnoty, jako je !=, <> nebo ==, vždy se musíte podívat na kontext, abyste viděli, co, kde a proč se něco přemění, abyste pochopili, co se děje.

Pravidla převodu

Tabulka porovnání typů

Jako referenční a příklad můžete vidět srovnávací tabulku v manuálu :

Volná srovnání s ==

┌─────────┬───────┬───────┬───────┬───────┬─────── ┬───────┬───────┬───────┬───────┬─────────┬─────── ┬───────┐ 
 │ │ TRUE │ FALSE │ 1 │ 0 │ -1 │ "1" │ "0" │ "-1" │ NULL │ pole () │ "php" │ "" │ 
 ├─────────┼───────┼───────┼───────┼─────── ┼───────┼───────┼───────┼───────┼───────┼───────── . 
 │ TRUE UE TRUE │ FALSE UE TRUE │ FALSE UE TRUE │ TRUE │ FALSE UE TRUE │ FALSE │ FALSE │ TRUE │ FALSE │ 
 │ FALSE │ FALSE │ TRUE │ FALS │ TRUE │ FALSE │ FALSE │ TRUE │ FALSE │ TRUE UE TRUE │ FALSE UE TRUE │ 
 │ 1 │ TRUE │ FALSE UE TRUE │ FALSE │ FALSE UE TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ 
 │ 0 │ FALSE UE TRUE │ FALSE UE TRUE │ FALSE │ FALSE │ TRUE │ FALSE UE TRUE │ FALSE UE TRUE UE TRUE │ 
 │ -1 │ TRUE │ FALSE │ FALSE │ FALSE AL FALSE │ FALSE │ FALSE UE TRUE │ FALSE │ FALSE UE TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ 
 │ "1" UE TRUE │ FALSE │ TRUE │ FALSE │ FALSE │ TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE . 
 │ "0" │ FALSE UE TRUE │ FALSE UE TRUE │ FALSE │ FALSE UE TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ 
 │ "-1" │ TRUE │ FALSE │ FALSE │ FALSE UE TRUE │ FALSE │ FALSE UE TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ 
 │ NULL │ FALSE │ TRUE │ FALSE │ TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE │ TRUE │ FALSE UE TRUE │ 
 │ array () │ FALSE │ TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ TRVAL │ TRUE │ FALSE │ FALSE │ 
 │ "php" UE TRUE │ FALSE │ FALSE UE TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE UE TRUE │ FALSE │ 
 │ "" │ FALSE UE TRUE │ FALSE UE TRUE │ FALSE │ FALSE │ FALSE │ FALSE UE TRUE │ FALSE │ FALSE │ TRUE │ 
 └─────────┴───────┴─── ────┴───────┴───────┴───────┴───────┴───────┴───── ──┴───────┴─────────┴───────┴───────┘ 

Přísné === stejné porovnání

Pokud používáte operátora === nebo jiného operátora porovnání, který používá přísné porovnání, jako je !== nebo ===, pak si můžete být vždy jisti, že se typy nezmění magicky, protože nedojde ke konverzi děje. Takže s přísným porovnáním musí být typ a hodnota stejná, nejen hodnota.

Tabulka porovnání typů

Jako referenční a příklad můžete vidět srovnávací tabulku v manuálu :

Přísná srovnání s ===

┌─────────┬───────┬───────┬───────┬───────┬─────── ┬───────┬───────┬───────┬───────┬─────────┬─────── ┬───────┐ 
 │ │ TRUE │ FALSE │ 1 │ 0 │ -1 │ "1" │ "0" │ "-1" │ NULL │ pole () │ "php" │ "" │ 
 ├─────────┼───────┼───────┼───────┼─────── ┼───────┼───────┼───────┼───────┼───────┼───────── . 
 │ TRUE UE TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ 
 │ FALSE │ FALSE │ TRUE │ FALS │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ 
 │ 1 │ FALSE │ FALSE UE TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ 
 │ 0 │ FALSE │ FALSE │ FALSE UE TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ 
 │ -1 │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE UE TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ 
 │ "1" │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE UE TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE . 
 │ "0" │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE UE TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ 
 │ "-1" │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE UE TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ 
 │ NULL │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE UE TRUE │ FALSE │ FALSE │ FALSE │ 
 │ array () │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE │ FALSE │ FALSE │ 
 │ "php" AL FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE UE TRUE │ FALSE │ 
 │ "" │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE │ 
 └─────────┴───────┴─── ────┴───────┴───────┴───────┴───────┴───────┴───── ──┴───────┴─────────┴───────┴───────┘ 
583
nickf

Operátor == vrhá mezi dvěma různými typy, pokud se liší, zatímco operátor operátoru === provádí „bezpečné porovnání“. To znamená, že se vrátí pouze v případě, že oba operandy mají stejný typ a stejnou hodnotu.

Příklady:

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

Varování : dvě instance stejné třídy s ekvivalentními členy se neshodují s operátorem ===. Příklad:

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

Obrázek stojí za tisíc slov:

Dvojitá rovnice PHP == graf rovnosti:

 enter image description here

PHP Triple Equals === Graf rovnosti:

 enter image description here

Zdrojový kód pro vytvoření těchto obrázků:

https://github.com/sentientmachine/php_equality_charts

Guru meditace

Ti, kteří si chtějí zachovat zdravý rozum, nečtou dál.

  1. == převádí levé a pravé operandy na čísla, pokud je to možné 123 == "123foo", ale "123" != "123foo"
  2. Šestihranný řetězec v uvozovkách je občas float a bude na něj uvalen proti vaší vůli.
  3. == není tranzitivní, protože "0"== 0 a 0 == "" ale "0" != ""
  4. "6" == " 6", "4.2" == "4.20" a "133" == "0133" ale 133 != 0133, protože 0133 je osmičkové. "0x10" == "16" a "1e3" == "1000"
  5. Proměnné PHP, které ještě nebyly deklarovány, jsou nepravdivé.

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

  7. Když jsou čísla dostatečně velká, jsou == Nekonečno.
  8. NAN = = sám, ale je to pravda.
  9. Nová třída je == až 1.
  10. Falešná je nejnebezpečnější hodnota, protože False je == k většině ostatních proměnných, většinou porážejících účel.

Naděje:

Pokud používáte PHP, nepoužijete operátora double equals, vždy použijte trojnásobek rovná se.

58
Eric Leschinski

Pokud jde o JavaScript:

Operátor === pracuje stejně jako operátor ==, ale vyžaduje, aby jeho operandy neměly pouze stejnou hodnotu, ale také stejný datový typ.

Například vzorek níže zobrazí 'x a y jsou stejné', ale ne 'x a y jsou identické'.

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

Doplnění dalších odpovědí týkajících se porovnání objektů:

== porovnává objekty pomocí názvu objektu a jejich hodnot. Jsou-li dva objekty stejného typu a mají stejné hodnoty členů, $a == $b získá hodnotu true.

=== porovnává interní ID objektu objektů. I když jsou členové rovni, $a !== $b pokud nejsou přesně stejný 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
22
soulmerge

V nejjednodušších termínech:

= kontroluje, zda ekvivalent (pouze hodnota)

= zkontroluje, zda stejný (hodnota && typ)


Ekvivalent vs.

1 + 1 = 2 + 0 (ekvivalent)

1 + 1 = 1 + 1 (stejné)


V PHP:

true == 1 (true - ekvivalent v hodnotě)

true === 1 (false - není to stejné v hodnotě && type)

  • true je boolean
  • 1 je int
13
silver

Je to všechno o datových typech. Vezměte BOOL (true nebo false) například:

true také se rovná 1 a false také se rovná 0

== se nestará o datové typy při porovnávání: Takže pokud jste měli proměnnou, která je 1 (což může být také true):

$var=1;

A pak porovnejte s ==:

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

Ale $var ve skutečnosti nesouhlasí s true, že? Namísto toho má hodnotu int 1, což je rovna true.

S === jsou zkontrolovány datové typy, aby se ujistily, že dvě proměnné/objekty/cokoliv používá stejný typ.

Takže jestli jsem to udělal

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

tato podmínka by nebyla pravdivá, protože $var !== true pouze == true (pokud víte, co tím myslím).

Proč bys to potřeboval?

Jednoduché - podívejme se na jednu z funkcí PHP: array_search():

Funkce array_search() jednoduše vyhledá hodnotu v poli a vrátí klíč elementu, ve kterém byla hodnota nalezena. Pokud hodnota nemohla být nalezena v poli, vrátí false . Ale co když jste udělali array_search() na hodnotu, která byla uložena v prvním prvku pole (který by měl klíč klíče 0) .... funkce array_search() by se vrátila 0 ... což je rovná falešnému ..

Takže pokud jste:

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

Vidíte, jak by to mohlo být teď problém?

Většina lidí nepoužívá == false při kontrole, zda funkce vrací hodnotu false. Místo toho používají !. Ve skutečnosti je to však totéž jako použití ==false, takže pokud jste udělali:

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

Takže pro podobné věci byste místo toho použili ===, aby byl typ dat zaškrtnut.

8
user849137

Jedním z příkladů je, že atribut databáze může být null nebo "":

$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

Dané x = 5

1) Operátor: == je "rovno". x == 8 je false
2) Operátor: === je "přesně roven" (hodnota a typ) x === 5 je true, x === "5" je false

6
Mannusanghi

Několik příkladů

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.

== Porovná pouze hodnotu, nebude se starat o datové typy

vs.

=== Porovná hodnoty a typy dat

4
Mohit Tanwani

Stručně řečeno, === funguje stejným způsobem, jako == ve většině ostatních programovacích jazyků.

PHP vám umožňuje provádět srovnání, která nedávají smysl. Příklad:

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

I když to umožňuje některé zajímavé "zkratky", měli byste si být vědomi, protože funkce, která vrací něco, co by neměla (jako "chyba" namísto čísla) nebude chytit, a budete se divil, co se stalo.

V PHP == porovnává hodnoty a v případě potřeby provádí konverzi typu (například řetězec "12343sdfjskfjds" se v celočíselném srovnání stane "12343"). === porovná hodnotu typu AND a vrátí false, pokud typ není stejný.

Pokud se podíváte do příručky PHP, uvidíte, že mnoho funkcí vrátí "false", pokud funkce selže, ale v úspěšném scénáři se mohou vrátit 0, proto doporučují "pokud (funkce ( )! == false) "aby se zabránilo chybám.".

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

Buďte opatrní. Zde je známý problém.

// '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 je volně psaný jazyk. Použití dvojitého ekvivalentního operátora umožňuje volnou kontrolu proměnné.

Volná kontrola hodnoty by umožnila, aby některé podobné, ale nikoliv rovnocenné hodnoty byly shodné:

  • ''
  • nula
  • false

Všechny tyto hodnoty by se rovnaly jako rovnocenné pomocí dvojitého operátoru.

2
Cory Collier

Použili byste === k otestování, zda je funkce nebo proměnná falešná, spíše než rovnost false (nula nebo prázdný řetězec).

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

V tomto případě by strpos vrátil hodnotu 0, která by v testu odpovídala false

if ($pos == false)

nebo

if (!$pos)

což není to, co chcete.

2
Stacey Richards

Pokud jde o to, kdy použít jeden přes druhého, vezměte si například funkci fwrite() v PHP.

Tato funkce zapíše obsah do souboru. Podle PHP, "fwrite() vrací počet zapsaných bytů, nebo FALSE při chybě.". Pokud chcete otestovat, zda bylo volání funkce úspěšné, je tato metoda chybná:

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

Může se vrátit na nulu (a je považován za úspěšný) a váš stav se stále spustí. Správná cesta by byla:

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

php == je porovnávací operátor, který porovnává hodnotu proměnných. Ale === porovnává hodnotu a typ dat.

Například,

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

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

V tomto případě bude výstup „Proměnné jsou stejné“, i když jsou jejich datové typy odlišné.

Ale pokud použijeme === místo ==, bude výstup „Proměnné nejsou stejné“. PHP nejprve porovná hodnotu proměnné a pak typ dat. Zde jsou hodnoty stejné, ale datové typy se liší.

1
2rahulsk

Všechny odpovědi zatím ignorují nebezpečný problém s ===. To bylo zaznamenáno v předávání, ale ne zdůraznil, že celé číslo a dvojité jsou různé typy, takže následující kód:

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

dává:

 equal
 not equal

Všimněte si, že to není případ "chyby zaokrouhlení". Tato dvě čísla jsou přesně stejná jako poslední bit, ale mají různé typy.

To je ošklivý problém, protože program používající === může běžet šťastně po celá léta, pokud všechna čísla jsou dostatečně malá (kde "dostatečně malý" závisí na hardwaru a operačním systému, na kterém běží). Pokud se však náhodou stane, že celé číslo bude dostatečně velké, aby mohlo být převedeno na dvojnásobek, jeho typ se změní "navždy", i když následná operace, nebo mnoho operací, ji může přivést zpět na malé celé číslo v hodnotě. A to je ještě horší. Může se šířit - infekce může být přenesena na cokoliv, čeho se dotýká, jeden výpočet najednou. 

V reálném světě to bude pravděpodobně problém například v programech, které se týkají roku 2038. V této době bude UNIX timestamps (počet sekund od roku 1970-01-01 00:00:00 UTC) vyžadovat více než 32 bitů, takže jejich reprezentace bude v některých systémech "magicky" přepínat na dvojnásobek. Proto pokud vypočítáte rozdíl mezi dvakrát můžete skončit s několika sekund, ale jako dvojnásobek, spíše než celočíselný výsledek, který nastane v roce 2017.

Myslím, že je to mnohem horší než konverze mezi řetězci a čísly, protože je to jemné. Je pro mě snadné sledovat, co je řetězec a co je číslo, ale sledování počtu bitů v čísle je mimo mě.

Ve výše uvedených odpovědích jsou tedy některé tabulky Nice, ale žádný rozdíl mezi 1 (jako celé číslo) a 1 (jemným dvojitým) a 1,0 (zřejmým dvojitým). Také rady, které byste měli vždy používat === a nikdy == není skvělé, protože === někdy selžou, když == funguje správně. Také JavaScript není v tomto ohledu ekvivalentní, protože má pouze jeden typ čísla (interně může mít různá bitová zobrazení, ale nezpůsobuje problémy ===).

Moje rada - nepoužívejte. Musíte napsat svou vlastní srovnávací funkci, abyste tento nepořádek opravili.

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

Proměnné mají typ a hodnotu.

  • $ var = "test" je řetězec, který obsahuje "test"
  • $ var2 = 24 je hodnota celého čísla 24.

Když použijete tyto proměnné (v PHP), někdy nemáte dobrý typ. Například pokud ano

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

PHP musí konvertovat ("na obsazení") $ var na celé číslo. V tomto případě platí, že hodnota "$ var == 1" je platná, protože libovolný neprázdný řetězec je převeden na hodnotu 1.

Pokud používáte ===, zkontrolujte, že hodnota A TYP jsou stejné, takže "$ var === 1" je false.

To je užitečné například tehdy, když máte funkci, která může vrátit hodnotu false (při chybě) a 0 (výsledek):

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

Tento kód je špatný, jako kdyby myFunction() vrací 0, je odhozen na false a zdá se, že má chybu. Správný kód je:

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

protože test je, že návratová hodnota "je boolean a je falešná" a ne "může být obsazena na false".

1
ofaurax

Operátor === má porovnávat přesnou rovnost obsahu, zatímco operátor == by porovnával sémantickou rovnost. Zejména bude nutit řetězce k číslům.

Rovnost je obrovský předmět. Viz článek Wikipedie o rovnosti .

1
kmkaplan

Existují dva rozdíly mezi == a === v polích PHP a objektech, o kterých si myslím, že se zde nezmiňují; dvě pole s různými druhy klíčů a objekty.

Dvě pole s různými druhy klíčů

Máte-li pole s tříděním klíčů a jiným polem s jiným uspořádáním klíčů, jsou striktně odlišné (tj. Pomocí ===). To může způsobit, pokud klíč-třídit pole, a pokusit se porovnat seřazené pole s původní.

Zvažte například prázdné pole. Nejprve se snažíme posunout některé nové indexy do pole bez jakéhokoliv zvláštního druhu. Dobrým příkladem by bylo pole s řetězci jako klíči. Nyní hluboko v příkladu:

// Define an array
$arr = [];

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

Nyní máme pole, které není seřazeno podle klíčů (např. „On“ přišel po „vy“). Uvažujme o stejném poli, ale klíče jsme třídili abecedně:

// Declare array
$alphabetArr = [];

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

Tip: Pole můžete třídit pomocí klávesy ksort () function.

Nyní máte další pole s jiným klíčem od prvního. Budeme je porovnávat:

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

Poznámka: Může to být zřejmé, ale porovnání dvou různých polí za použití přísného porovnání vždy znamená false. Dvě libovolná pole však mohou být rovná === nebo ne.

Řekli byste: "Tento rozdíl je zanedbatelný". Pak říkám, že je to rozdíl a mělo by být zváženo a může se stát kdykoliv. Jak je uvedeno výše, třídění klíčů v poli je toho dobrým příkladem.

Objekty

Mějte na paměti, že dva různé objekty nejsou nikdy přísné. Tyto příklady by pomohly:

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

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

Poznámka: Přiřazení objektu jiné proměnné nevytváří kopii - spíše vytvoří odkaz na stejné umístění paměti jako objekt. Viz zde .

Poznámka: Jako PHP7 byly přidány anonymní třídy . Z výše uvedených výsledků není žádný rozdíl mezi new class {} a new stdClass() ve výše uvedených testech.

0
MAChitgarha