Operator = = rzuca między dwoma różnymi typami, jeśli są różne, podczas gdy operator = = = wykonuje "porównanie typów". Oznacza to, że zwróci true tylko wtedy, gdy oba operandy mają ten sam typ i tę samą wartość.

Przykłady:

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

Ostrzeżenie: dwie instancje tej samej klasy z równoważnymi członami nie pasują do operatora ===. Przykład:

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

Obraz jest wart tysiąca słów:

PHP Double Equals == equality chart:

PHP Triple Equals === Equality chart:

Kod źródłowy do tworzenia tych obrazów:

Https://github.com/sentientmachine/php_equality_charts

Guru Meditation

1. ' = = ' konwertuje lewe i prawe operandy na liczby, gdy jest to możliwe (123 = = "123foo", ale "123"!= "123foo"
2. ciąg szesnastkowy w cudzysłowach jest czasami float i będzie rzucany do niego wbrew twojej woli.
3. = = nie jest przechodnia, ponieważ ("0" jest = = do 0, a 0 jest = = do "" Ale "0"!= "")
4. "6" == "6", "4.2" == "4.20", i "133" = = "0133". Ale 133 != 0133, ponieważ 0133 jest ósemką. Ale "0x10" = = " 16 "i" 1e3 " = = "1000"

5. Zmienne PHP, które nie zostały jeszcze zadeklarowane, są fałszywe.

6. False jest równe 0, blankstring i empty array oraz "0".

7. gdy liczby są wystarczająco duże, to są = = nieskończoność.

8. NAN nie = = siebie, ale to prawda.

9. Świeża Klasa to = = do 1.

10. False jest najniebezpieczniejszą wartością, ponieważ False jest = = dla większości innych zmiennych, głównie pokonując jej cel.

Nadzieja:

Jeśli używasz PHP, nie używaj operatora double equals, Zawsze używaj Triple equals.

W odniesieniu do JavaScript:

Operator = = = działa tak samo jak operator==, ale wymaga, aby jego operandy miały nie tylko tę samą wartość, ale także ten sam typ danych.

Na przykład poniższa próbka wyświetli "X i y są równe", ale nie "x I y są identyczne".

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

Dodatek do innych odpowiedzi dotyczących porównywania obiektów:

= = porównuje obiekty używając nazwy obiektu i ich wartości. Jeśli dwa obiekty są tego samego typu i mają te same wartości, $a == $b daje true.

= = porównuje wewnętrzny ID obiektu obiektów. Nawet jeśli członkowie są równi, $a !== $b jeśli nie są dokładnie tym samym obiektem.

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

W najprostszych słowach:

== sprawdza, czy odpowiednik (tylko wartość)

=== sprawdza czy to samo (wartość && typ)


Odpowiednik VS. ten sam: analogia

1 + 1 = 2 + 0 (odpowiednik)

1 + 1 = 1 + 1 (to samo)


W PHP:

True = = 1 (True-odpowiednik wartości)

Prawda === 1 (false - not the same in value & & type)

• prawda jest boolean
• 1 jest int

Chodzi o typy danych. Weźmy na przykład BOOL (prawda lub FAŁSZ):

true również równa się 1 i false również równa się 0

== nie dba o typy danych podczas porównywania: Więc jeśli masz zmienną, która jest 1 (która również może być true):

$var=1;

A następnie porównaj z ==:

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

Ale $var nie równa się true, prawda? Zamiast tego ma wartość int 1, która z kolei jest równa prawda.

Z ===, typy danych są sprawdzane, aby upewnić się, że dwie zmienne / obiekty / cokolwiek używają tego samego typu.

So if I did

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

Ten warunek nie byłby prawdziwy, ponieważ $var !== true to tylko == true (jeśli wiesz, co mam na myśli).

Proste-przyjrzyjmy się jednej z funkcji PHP: array_search():

Funkcja array_search() po prostu wyszukuje wartość w tablicy i zwraca klucz elementu, którego wartość była Znalezione w. Jeśli nie można znaleźć wartości w tablicy, zwraca ona false . Ale, co by było, gdybyś zrobił array_search() na wartości, która była przechowywana w pierwszy element tablicy (który miałby klucz tablicy 0)....funkcja array_search() zwróci 0...co jest równe false..

Więc jeśli tak:

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

Większość ludzi nie używa == false podczas sprawdzania, czy funkcja zwraca false. Zamiast tego używają !. Ale w rzeczywistości jest to dokładnie to samo, co użycie ==false, więc jeśli to zrobiłeś:

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

Więc dla takich rzeczy, można użyć === zamiast, tak, że typ danych jest sprawdzany.

Przykład: atrybut bazy danych może być null lub"":

$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

x = 5

1) Operator: = = jest "równy". x == 8 is false
2) Operator: = = = is "exactly equal to" (value and type) x === 5 is true, x === "5" is false

$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

// '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...
}

W skrócie, = = = działa w ten sam sposób, co == w większości innych języków programowania.

PHP pozwala na dokonywanie porównań, które nie mają sensu. Przykład:

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

Chociaż pozwala to na kilka interesujących "skrótów", powinieneś uważać, ponieważ funkcja, która zwraca coś, czego nie powinna (jak "błąd" zamiast liczby), nie zostanie złapana, a Ty będziesz się zastanawiać, co się stało.

W PHP, = = porównuje wartości i wykonuje konwersję typu jeśli konieczne (na przykład ciąg znaków "12343sdfjskfjds" stanie się "12343" w porównaniu liczby całkowitej). = = = porównuje wartość i typ i zwróci false, jeśli Typ nie jest taki sam.

Jeśli zajrzysz do podręcznika PHP, zobaczysz, że wiele funkcji zwraca "false", jeśli Funkcja się nie powiedzie, ale mogą one zwrócić 0 w udanym scenariuszu, dlatego zalecają wykonanie " if (function ()!= = false) " aby uniknąć błędów.

Kilka przykładów

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.

= = porównuje tylko wartość, nie będzie kłopotać się typami danych

Vs.

= = = porównuje wartości i typy danych

Użyłbyś = = = do sprawdzenia, czy funkcja lub zmienna jest false, a nie po prostu równa się false(zero lub pusty łańcuch).

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

W tym przypadku strpos zwróci 0, co równałoby się false W teście

if ($pos == false)

Lub

if (!$pos)

Jeśli chodzi o to, kiedy używać jednego nad drugim, Weźmy na przykład funkcję fwrite() w PHP.

Ta funkcja zapisuje zawartość do strumienia plików. Zgodnie z PHP, " fwrite() Zwraca liczbę zapisanych bajtów lub FALSE w przypadku błędu.". Jeśli chcesz sprawdzić, czy wywołanie funkcji powiodło się, ta metoda jest błędna:

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

Może zwrócić zero (i jest uważany za udany) , a twój stan nadal zostanie wyzwalany. Właściwą drogą byłoby:

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

PHP jest językiem luźno pisanym. Użycie operatora double equal pozwala na swobodne sprawdzenie zmiennej.

Luźne sprawdzanie wartości pozwoli, aby niektóre podobne, ale nie równe, wartości były równe jako takie same:

• ''
• null
• false
• 0

Wszystkie te wartości będą równe za pomocą operatora double equal.

Zmienne mają typ i wartość.

• $var = "test" jest łańcuchem zawierającym "test"
• $var2 = 24 jest liczbą całkowitą vhose wartość jest 24.

Kiedy używasz tych zmiennych (w PHP), czasami nie masz dobrego typu. Na przykład, jeśli robisz

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

PHP musi przekonwertować ("do cast") $var na liczbę całkowitą. W tym przypadku, "$var == 1" jest prawdziwe, ponieważ każdy niepusty łańcuch jest rzutowany na 1.

Podczas używania ===, sprawdzasz, czy wartość i typ są równe, więc "$ var = = = 1 " jest false.

Jest to przydatne, na przykład, gdy masz funkcję, która może zwracać false (W przypadku błędu) i 0 (wynik):

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

Ten kod jest błędny, tak jakby myFunction() zwrócił 0, jest on zamieniony na false i wydaje się, że masz błąd. Prawidłowy kod to:

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

Ponieważ test polega na tym, że wartość zwracana "jest wartością logiczną i jest false", a nie "może być rzucona na false".

Operator === mA porównywać dokładną równość treści, podczas gdy operator== porównuje równość semantyczną. W szczególności będzie zmuszać ciągi do liczb.

<?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);
?>

Wszystkie odpowiedzi do tej pory ignorują niebezpieczny problem z===. Zauważono przelotnie, ale nie podkreślono, że liczba całkowita i liczba Podwójna są różnymi typami, więc następujący kod:

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

Daje:

 equal
 not equal

Zauważ, że nie jest to przypadek "błędu zaokrąglania". Dwie liczby są dokładnie równe do ostatniego bitu, ale mają różne typy.

Jest to paskudny problem, ponieważ program używający = = = może działać szczęśliwie przez lata, jeśli wszystkie liczby są wystarczająco małe (gdzie "wystarczająco mały" zależy od sprzętu i systemu operacyjnego, na którym pracujesz). Jednakże, jeśli przez przypadek, liczba całkowita stanie się wystarczająco duża, aby zostać przekonwertowana na podwójną, jej typ jest zmieniany "na zawsze", nawet jeśli kolejna operacja lub wiele operacji może przywrócić ją do małej liczby całkowitej w wartości. I jest jeszcze gorzej. Może się rozprzestrzeniać-infekcja może być przenoszona na wszystko, czego dotknie, po jednym obliczeniu na raz.

W realnym świecie jest to prawdopodobnie problem w na przykład programy obsługujące daty po roku 2038. W tej chwili znaczniki czasu Uniksa (liczba sekund od 1970-01-01 00:00:00 UTC) będą wymagały więcej niż 32-bitów, więc ich reprezentacja" magicznie " zmieni się na podwójne w niektórych systemach. Dlatego, jeśli obliczysz różnicę między dwoma razy, możesz skończyć z kilkoma sekundami, ale jako podwójnie, a nie wynikiem całkowitym, który występuje w roku 2017.

Myślę, że jest to znacznie gorsze niż konwersje między ciągi i liczby, ponieważ jest subtelny. Uważam, że łatwo jest śledzić, co jest ciągiem, a co liczbą, ale śledzenie liczby bitów w liczbie jest poza mną.

Tak więc, w powyższych odpowiedziach jest kilka ładnych tabel, ale nie ma rozróżnienia między 1 (jako liczba całkowita) i 1 (subtelne podwójne) i 1.0 (oczywiste podwójne). Ponadto, rada, że należy zawsze używać = = = i nigdy = = nie jest wielka, ponieważ = = = czasami nie będzie tam, gdzie = = działa poprawnie. Również JavaScript nie jest odpowiednikiem pod tym względem, ponieważ ma tylko jeden typ liczbowy (wewnętrznie może mieć różne reprezentacje bitowe, ale nie powoduje problemów dla ===).

Istnieją dwie różnice między == i === w tablicach i obiektach PHP, o których myślę, że tu nie wspomniałem; dwie tablice z różnymi rodzajami kluczy i Obiekty.

Dwie tablice z różnymi rodzajami kluczy

Jeśli masz tablicę z sortowaniem kluczy i inną tablicę z innym sortowaniem kluczy, są one ściśle różne(np. używając ===). Może to spowodować, że jeśli posortujesz tablicę za pomocą klucza, spróbujesz porównać posortowaną tablicę z oryginalną.

Na przykład, rozważmy pusta tablica. Najpierw staramy się wypchnąć kilka nowych indeksów do tablicy bez specjalnego sortowania. Dobrym przykładem może być tablica z łańcuchami jako kluczami. Teraz głęboko w przykładzie:

// Define an array
$arr = [];

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

Teraz mamy nie sortowaną tablicę kluczy(np. 'he' przyszedł po'you'). Rozważmy tę samą tablicę, ale posortowaliśmy jej klucze Alfabetycznie:

// Declare array
$alphabetArr = [];

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

Wskazówka : możesz sortować tablicę według klucza za pomocą funkcji ksort().

Teraz masz inną tablicę z innym sortowaniem kluczy od pierwszy. Więc porównamy je:

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

Uwaga: Może to być oczywiste, ale porównywanie dwóch różnych tablic przy użyciu ścisłego porównania zawsze daje wyniki false. Jednak dwie dowolne tablice mogą być równe za pomocą === lub nie.

Powiedziałbyś: "ta różnica jest znikoma". Wtedy mówię, że to różnica i powinno być brane pod uwagę i może się zdarzyć w każdej chwili. Jak wspomniano powyżej, sortowanie kluczy w tablicy jest dobrym przykładem to.

Obiekty

Należy pamiętać, dwa różne obiekty nigdy nie są ściśle równe . Te przykłady pomogłyby:

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

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

Notatka: przypisanie obiektu do innej zmiennej nie tworzy kopii-raczej tworzy odniesienie do tego samego miejsca pamięci, co obiekt. zobacz tutaj .

Uwaga: od PHP7 dodano klasy anonimowe . Z wyników wynika, że nie ma różnicy między new class {} i new stdClass() w testy powyżej.