Arasındaki fark nedir ==ve ===?

• Gevşek ==karşılaştırma tam olarak nasıl çalışır?
• Katı ===karşılaştırma tam olarak nasıl çalışır?

Yararlı örnekler neler olabilir?

Fark arasında ==ve===

Gevşek ==eşit operatör ve katı ===özdeş operatör arasındaki fark kılavuzda tam olarak açıklanmıştır :

Karşılaştırma Operatörleri

┌──────────┬───────────┬────────────────────────── ─────────────────────────────────┐
│ Örnek │ İsim │ Sonuç │
├──────────┼───────────┼────────────────────────── ─────────────────────────────────┤
│ $ a == $ b │ Eşit │ Eğer $ a tür hokkabazlıktan sonra $ b'ye eşitse DOĞRU. │
│ $ a === $ b │ Aynı │ $ a $ b'ye eşitse ve aynı türdeyse DOĞRU. │
└──────────┴───────────┴────────────────────────── ─────────────────────────────────┘

Gevşek ==eşit karşılaştırma

Eğer kullanıyorsanız ==operatörü veya gevşek karşılaştırma kullanan başka karşılaştırma operatörü gibi !=, <>ya ==, her zaman bakmak zorunda bağlamda şey ne olup bittiğini anlamak için dönüştürülmüş olur neden ve ne görmek için.

Dönüştürme kuralları

• Boole'ye dönüştürme
• Tamsayıya dönüştürme
• Şamandıraya dönüştürme
• Dizeye dönüştürülüyor
• Diziye dönüştürme
• Nesneye dönüştürme
• Kaynağa dönüştürme
• NULL değerine dönüştürülüyor

Tip karşılaştırma tablosu

Referans ve örnek olarak kılavuzda karşılaştırma tablosunu görebilirsiniz :

İle gevşek karşılaştırmalar ==

┌─────────┬───────┬───────┬───────┬───────┬─────── ┬───────┬───────┬───────┬───────┬─────────┬─────── ┬───────┐
│ │ DOĞRU │ YANLIŞ │ 1 │ 0 │ -1 │ "1" │ "0" │ "-1" │ NULL │ dizi () │ "php" │ "" │
├─────────┼───────┼───────┼───────┼───────┼─────── ┼───────┼───────┼───────┼───────┼─────────┼─────── ┼───────┤
│ DOĞRU │ DOĞRU │ YANLIŞ │ DOĞRU AL YANLIŞ │ DOĞRU UE DOĞRU AL YANLIŞ UE DOĞRU AL YANLIŞ AL YANLIŞ │ DOĞRU AL YANLIŞ │
│ YANLIŞ │ YANLIŞ │ DOĞRU │ YANLIŞ UE DOĞRU AL YANLIŞ AL YANLIŞ UE DOĞRU AL YANLIŞ UE DOĞRU UE DOĞRU AL YANLIŞ UE DOĞRU │
│ 1 │ DOĞRU │ YANLIŞ │ DOĞRU │ YANLIŞ │ YANLIŞ │ DOĞRU │ YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ │
│ 0 │ YANLIŞ │ DOĞRU │ YANLIŞ │ DOĞRU │ YANLIŞ AL YANLIŞ UE DOĞRU AL YANLIŞ UE DOĞRU AL YANLIŞ UE DOĞRU │ DOĞRU │
│ -1 │ DOĞRU │ YANLIŞ │ YANLIŞ │ YANLIŞ UE DOĞRU AL YANLIŞ AL YANLIŞ UE DOĞRU AL YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ │
│ "1" │ DOĞRU │ YANLIŞ │ DOĞRU AL YANLIŞ │ YANLIŞ UE DOĞRU │ YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ │
│ "0" │ YANLIŞ │ DOĞRU │ YANLIŞ │ DOĞRU AL YANLIŞ AL YANLIŞ UE DOĞRU AL YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ │
│ "-1" │ DOĞRU │ YANLIŞ │ YANLIŞ │ YANLIŞ UE DOĞRU │ YANLIŞ AL YANLIŞ UE DOĞRU AL YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ │
│ BOŞ │ YANLIŞ │ DOĞRU │ YANLIŞ │ DOĞRU AL YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ UE DOĞRU UE DOĞRU AL YANLIŞ │ DOĞRU │
│ dizi () │ YANLIŞ │ DOĞRU │ YANLIŞ │ YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ UE DOĞRU UE DOĞRU AL YANLIŞ AL YANLIŞ │
│ "php" │ DOĞRU │ YANLIŞ │ YANLIŞ │ DOĞRU │ YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ UE DOĞRU │ YANLIŞ │
│ "" │ YANLIŞ │ DOĞRU │ YANLIŞ │ DOĞRU AL YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ UE DOĞRU AL YANLIŞ AL YANLIŞ │ DOĞRU │
└─────────┴───────┴───────┴───────┴───────┴─────── ┴───────┴───────┴───────┴───────┴─────────┴─────── ┴───────┘

Sıkı ===özdeş karşılaştırma

Eğer kullanıyorsanız ===gibi sıkı bir karşılaştırma kullanan operatöre veya başka bir karşılaştırma operatörü !==veya ===, o zaman her zaman emin tipleri olmaz olabilir sihirli değiştirmek, hiçbir dönüştürme oluyor olacağı için. Bu yüzden katı bir karşılaştırma ile, tür ve değer sadece değer değil, aynı olmak zorundadır.

Tip karşılaştırma tablosu

Referans ve örnek olarak kılavuzda karşılaştırma tablosunu görebilirsiniz :

İle sıkı karşılaştırmalar ===

┌─────────┬───────┬───────┬───────┬───────┬─────── ┬───────┬───────┬───────┬───────┬─────────┬─────── ┬───────┐
│ │ DOĞRU │ YANLIŞ │ 1 │ 0 │ -1 │ "1" │ "0" │ "-1" │ NULL │ dizi () │ "php" │ "" │
├─────────┼───────┼───────┼───────┼───────┼─────── ┼───────┼───────┼───────┼───────┼─────────┼─────── ┼───────┤
│ DOĞRU │ DOĞRU │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ │ YANLIŞ │
│ YANLIŞ │ YANLIŞ │ DOĞRU │ YANLIŞ │ YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ AL YANLIŞ │
│ 1 │ YANLIŞ │ YANLIŞ │ DOĞRU │ YANLIŞ │ YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ │ YANLIŞ │
│ 0 │ YANLIŞ │ YANLIŞ │ YANLIŞ │ DOĞRU AL YANLIŞ │ YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ │ YANLIŞ │
│ -1 │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ UE DOĞRU │ YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ │
│ "1" │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ UE DOĞRU AL YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ │
│ "0" │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ AL YANLIŞ UE DOĞRU AL YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ │
│ "-1" │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ AL YANLIŞ AL YANLIŞ UE DOĞRU AL YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ │
│ NULL │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ UE DOĞRU AL YANLIŞ AL YANLIŞ │ YANLIŞ │
│ dizi () │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ UE DOĞRU AL YANLIŞ AL YANLIŞ │
│ "php" │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ UE DOĞRU │ YANLIŞ │
│ "" │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ AL YANLIŞ AL YANLIŞ │ YANLIŞ AL YANLIŞ AL YANLIŞ AL YANLIŞ │ DOĞRU │
└─────────┴───────┴───────┴───────┴───────┴─────── ┴───────┴───────┴───────┴───────┴─────────┴─────── ┴───────┘

== işleci, farklıysa iki farklı tür arasında yayın yaparken, === işleci 'tipik bir karşılaştırma' gerçekleştirir. Bu, yalnızca her iki işlenen de aynı türde ve aynı değere sahipse true döndüreceği anlamına gelir.

Örnekler:

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

Uyarı : eşdeğer üyelerle aynı sınıfın iki örneği işleçle ===eşleşmiyor. Misal:

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

Bir resim bin kelime değerinde bir olup:

PHP Double ==Eşitlik tablosu:

PHP Triple Equals ===Eşitlik tablosu:

Bu görüntüleri oluşturmak için kaynak kodu:

https://github.com/sentientmachine/php_equality_charts

Guru Meditasyonu

Akıl sağlığını korumak isteyenler, daha fazla okumazlar çünkü bunların hiçbiri mantıklı olmaz, PHP'nin delilik-fraktalının böyle tasarlandığını söylemek dışında.

1. NAN != NANama NAN == true.
2. ==sol bir sayı ise, sol ve sağ işlenenleri sayılara dönüştürür. Yani 123 == "123foo", ama"123" != "123foo"

3. Tırnak içindeki bir hex dizesi bazen bir şamandıradır ve iradesine karşı yüzmek için sürpriz bir oyuncu olur ve çalışma zamanı hatasına neden olur.

4. ==geçişli değil çünkü "0"== 0, 0 == ""ama"0" != ""

5. Henüz tanımlanmamış PHP Değişkenleri yanlıştır, ancak PHP tanımsız değişkenleri temsil etmenin bir yoluna sahip olsa da, bu özellik == .

6. "6" == " 6",, "4.2" == "4.20"ve "133" == "0133"ancak 133 != 0133. Ancak "0x10" == "16"ve "1e3" == "1000"bu sürpriz dize dönüşümünü sekizlik olarak açığa çıkarmak, hem talimatınız hem de rızanız olmadan gerçekleşir ve bir çalışma zamanı hatasına neden olur.

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

8. Sayılar yeterince büyük olduğunda == Sonsuzdur.

9. Yeni bir sınıf == to 1'dir.

10. False en tehlikeli değerdir, çünkü False diğer değişkenlerin çoğuna == olur, çoğunlukla amacını yener.

Umut:

PHP kullanıyorsanız, çift eşittir operatörünü kullanmazsınız çünkü üçlü eşitler kullanırsanız, endişelenmeniz gereken tek kenar durum NAN ve sonsuza yakın olan sayılardır. Çifte eşittir, her şey herhangi bir şeye sürpriz olabilir ==ya da iradenize ve !=açıkça eşit olması gereken bir şeye karşı sürpriz olabilir .

==PHP'de kullandığınız herhangi bir yer, içindeki 85 hata, brownian hareketi ile programlanan milyonlarca programcı tarafından tasarlanan örtülü döküm kurallarından dolayı kötü bir kod kokusudur.

JavaScript ile ilgili olarak:

=== İşleci == işleciyle aynı şekilde çalışır, ancak işlenenlerinin yalnızca aynı değere değil aynı zamanda aynı veri türüne sahip olmasını gerektirir.

Örneğin, aşağıdaki örnekte 'x ve y eşittir' görüntülenir, ancak 'x ve y aynı değildir' görüntüler.

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

Nesne karşılaştırmasıyla ilgili diğer cevaplara ek olarak:

== nesneleri, nesnenin adını ve değerlerini kullanarak karşılaştırır. İki nesne aynı türdeyse ve aynı üye değerlerine sahipse, $a == $btrue değerini verir.

=== nesnelerin dahili nesne kimliğini karşılaştırır. Üyeler eşit olsa bile, $a !== $btam olarak aynı nesne değilse.

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

En basit ifadeyle:

== eşdeğer olup olmadığını kontrol eder (yalnızca değer)

=== Aynı (değer && tipi)


Eşdeğeri mi Aynı mı: Bir Analoji

1 + 1 = 2 + 0 (eşdeğer)

1 + 1 = 1 + 1 (aynı)


PHP'de:

true == 1 (true - değer eşdeğeri)

true === 1 (false - değer && türünde aynı değil)

• doğru boolean
• 1 int

Her şey veri türleri ile ilgilidir. Örneğin BOOL(doğru veya yanlış) alın :

trueayrıca eşittir 1ve falseaynı zamanda eşittir0

Karşılaştırma ==yaparken veri türlerini umursamıyor: Yani 1 olan bir değişkeniniz varsa (bu da olabilir true):

$var=1;

Ve sonra aşağıdakilerle karşılaştırın ==:

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

Ama $varaslında eşit değil true, değil mi? Bunun 1yerine int değeri vardır , bu da doğruya eşittir.

İle ===, iki değişkenin / nesnenin / aynı türü kullanan her şeyin olduğundan emin olmak için veri türleri kontrol edilir.

Eğer öyleysem

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

bu durum doğru olmaz, $var !== truesadece olduğu gibi == true(ne demek istediğimi biliyorsanız).

Neden buna ihtiyacın var?

Basit - PHP'nin işlevlerinden birine bakalım array_search():

array_search()Fonksiyonu bir dizi değer ve dönüş değeri bulundu elemanının kilit için sadece arar. Değeri dizide bulunamadı, bu döner yanlış . Ama, bir dizi yaptıysanız (dizi anahtarını olurdu) array_search()bir değerde bir değer yaptıysanız .... işlevi 0 döndürür ... hangi false eşittir ..0array_search()

Eğer öyleyse:

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

Şimdi bunun nasıl bir sorun olabileceğini görüyor musunuz?

Çoğu kişi == falsebir işlevin yanlış döndürüp döndürmediğini kontrol ederken kullanmaz . Bunun yerine !,. Ama aslında, bu tamamen kullanmakla aynı ==false, bu yüzden eğer yaptıysanız:

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

Bunun gibi şeyler ===için veri türünün kontrol edilmesi için bunun yerine kullanılır .

Bir örnek, bir veritabanı özniteliğinin null veya "" olabileceğidir:

$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

php == değişkenlerin değerini karşılaştıran bir karşılaştırma operatörüdür. Ancak === değeri ve veri türünü karşılaştırır.

Örneğin,

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

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

Bu durumda, veri türleri farklı olsa da çıktı 'Değişkenler eşittir' olacaktır.

Ancak == yerine === kullanırsak, çıktı 'Değişkenler eşit değildir' olacaktır. Php önce değişkenin değerini ve sonra veri türünü karşılaştırır. Burada değerler aynıdır, ancak veri türleri farklıdır.

verilmiş x = 5

1) Operatör: == "eşittir". x == 8is false)
2) Operatör: === "tam eşittir" (değer ve tür) x === 5doğru, x === "5"yanlış

$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

Yine de dikkatli olun. İşte kötü şöhretli bir sorun.

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

Kısacası, === == diğer programlama dillerinde olduğu gibi çalışır.

PHP gerçekten mantıklı olmayan karşılaştırmalar yapmanıza izin verir. Misal:

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

Bazı ilginç "kısayollar" için izin verirken, bir şey döndüren bir işlev (bir sayı yerine "hata" gibi) yakalanmayacak beri dikkat etmelisiniz ve ne olduğunu merak edeceksiniz.

PHP'de == değerleri karşılaştırır ve gerekirse tür dönüşümü gerçekleştirir (örneğin, tam sayı karşılaştırmasında "12343sdfjskfjds" dizesi "12343" olur). === AND türünü karşılaştırır ve tür aynı değilse false değerini döndürür.

PHP kılavuzuna bakarsanız, işlev başarısız olursa birçok işlevin "false" döndürdüğünü görürsünüz, ancak başarılı bir senaryoda 0 döndürebilirler, bu yüzden "if (function ()! == false) "hatalarından kaçınmak için.

Birkaç örnek

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.

PS

== Yalnızca değeri karşılaştırır, veri türleri hakkında rahatsız olmaz

vs.

=== Değerleri ve veri türlerini karşılaştırır

Bir işlevin veya değişkenin yalnızca false (sıfır veya boş bir dize) ile eşitlemek yerine yanlış olup olmadığını test etmek için === kullanırsınız.

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

Bu durumda strpos testte false değerine eşit olan 0 değerini döndürür

if ($pos == false)

veya

if (!$pos)

burada istediğin şey bu değil.

Birini diğerinin ne zaman kullanacağına gelince, örneğin fwrite()PHP'deki işlevi ele alalım .

Bu işlev, içeriği bir dosya akışına yazar. PHP'ye göre, " fwrite()yazılan bayt sayısını veya hata durumunda FALSE değerini döndürür." İşlev çağrısının başarılı olup olmadığını test etmek istiyorsanız, bu yöntem kusurludur:

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

Sıfır verebilir (ve başarılı kabul edilir) ve durumunuz hala tetiklenir. Doğru yol:

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

PHP gevşek yazılan bir dildir. Çift eşit operatörün kullanılması bir değişkenin gevşek bir şekilde kontrol edilmesini sağlar.

Bir değerin gevşek bir şekilde kontrol edilmesi, benzer ancak eşit olmayan bazı değerlerin aynı şekilde eşit olmasına izin verir:

• ''
• boş
• yanlış
• 0

Bu değerlerin tümü, çift eşit operatör kullanılarak eşit olarak eşitlenir.

Değişkenlerin bir türü ve değeri vardır.

• $ var = "test", "test" içeren bir dizedir
• $ var2 = 24 tamsayı vhose değeri 24'tür.

Bu değişkenleri (PHP'de) kullandığınızda, bazen iyi bir tipiniz olmaz. Örneğin,

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

PHP $ var tamsayı ("to cast") dönüştürmek zorunda. Bu durumda, "$ var == 1" doğrudur, çünkü boş olmayan herhangi bir dize 1'e dökülür.

=== kullanırken, VE TÜR değerinin eşit olup olmadığını denetlediğinizden "$ var === 1" yanlıştır.

Bu, örneğin false (hatada) ve 0 (sonuç) döndürebilen bir işleviniz olduğunda kullanışlıdır:

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

Bu kod myFunction()0 döndürür gibi yanlıştır , false değerine çevrilir ve bir hata varmış gibi görünür. Doğru kod:

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

çünkü test, dönüş değerinin "bir boolean ve false" olmasıdır ve "false değerine çevrilemez" dir.

===Operatör karşılaştırmak gerekiyordu kesin iken içeriği eşitliğini ==operatörü anlamsal eşitliği karşılaştırmak olacaktır. Özellikle dizeleri sayılara zorlar.

Eşitlik çok geniş bir konudur. Eşitlik hakkındaki Wikipedia makalesine bakın .

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

Şimdiye kadarki tüm cevaplar === ile ilgili tehlikeli bir sorunu görmezden geliyor. Tamsayı ve çiftin farklı tipler olduğu, ancak vurgulanmadığı belirtildi, bu nedenle aşağıdaki kod:

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

verir:

 equal
 not equal

Bunun bir "yuvarlama hatası" durumu OLMADIĞINI unutmayın. İki sayı tam olarak son bite eşittir, ancak farklı türleri vardır.

Bu kötü bir sorundur çünkü === kullanan bir program, tüm sayılar yeterince küçükse ("yeterince küçük" çalıştığınız donanıma ve işletim sistemine bağlı olarak) yıllarca mutlu bir şekilde çalışabilir. Ancak, tesadüfen, bir tamsayı bir çifte dönüştürülecek kadar büyük olursa, sonraki bir işlem veya birçok işlem, değeri küçük bir tamsayıya geri getirmesine rağmen, türü "sonsuza kadar" değiştirilir. Ve daha da kötüleşiyor. Yayılabilir - çifte enfeksiyon, dokunduğu her şeye, her seferinde bir hesaplamaya geçirilebilir.

Gerçek dünyada, örneğin 2038 yılı ötesinde tarihleri ​​işleyen programlarda bu bir sorun olabilir. Şu anda, UNIX zaman damgaları (1970-01-01 00:00:00 UTC'den bu yana geçen saniye sayısı) 32 bitten daha fazlasını gerektirecektir, bu nedenle gösterimleri bazı sistemlerde "sihirli bir şekilde" iki katına çıkacaktır. Bu nedenle, iki kez arasındaki farkı hesaplarsanız, 2017 yılında meydana gelen tam sayı sonucundan ziyade birkaç saniye, ancak çift olarak sonuçlanabilir.

Bence bu, dize ve sayılar arasındaki dönüşümlerden çok daha kötü çünkü ince. Ben bir dize ve bir sayı nedir takip etmek kolay buluyorum, ama bir sayıdaki bit sayısını takip etmek benim ötesinde.

Yani, yukarıdaki cevaplarda bazı güzel tablolar var, ancak 1 (tamsayı olarak) ve 1 (ince çift) ve 1.0 (bariz çift) arasında bir fark yok. Ayrıca, === ve asla == kullanmamanız tavsiye edilmez, çünkü === bazen == düzgün çalışıyorsa başarısız olur. Ayrıca, JavaScript bu bağlamda eşdeğer değildir, çünkü yalnızca bir sayı türüne sahiptir (dahili olarak farklı bit-bilge temsillerine sahip olabilir, ancak === için sorunlara neden olmaz).

Benim tavsiyem - ikisini de kullanmayın. Bu karışıklığı gerçekten düzeltmek için kendi karşılaştırma işlevinizi yazmanız gerekir.

Arasında iki fark vardır ==ve ===PHP diziler ve burada söz etmedi düşünüyorum nesnelerde; farklı anahtar türlerine ve nesnelere sahip iki dizi.

Farklı anahtar türlerine sahip iki dizi

Bir anahtar sıralaması olan bir diziniz ve farklı bir anahtar sıralaması olan başka bir diziniz varsa, bunlar kesinlikle farklıdır (yani ===). Bu, bir diziyi anahtar olarak sıralarsanız ve sıralanan diziyi orijinal diziyle karşılaştırmaya çalışırsanız neden olabilir.

Örneğin, boş bir dizi düşünün. İlk olarak, bazı yeni dizinleri özel bir sıralama olmadan diziye aktarmaya çalışıyoruz. Bunun iyi bir örneği, anahtar olarak dizeleri olan bir dizi olabilir. Şimdi derin bir örnek:

// Define an array
$arr = [];

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

Şimdi, sıralanmamış bir anahtar dizimiz var (örneğin, 'o' 'sizden' sonra geldi). Aynı diziyi düşünün, ancak anahtarlarını alfabetik olarak sıraladık:

// Declare array
$alphabetArr = [];

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

İpucu : Bir diziyi ksort () işlevini kullanarak tuşa göre sıralayabilirsiniz .

Şimdi birinciden farklı bir anahtar sıralamasına sahip başka bir diziniz var. Yani, bunları karşılaştıracağız:

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

Not : Açık olabilir, ancak iki farklı diziyi katı karşılaştırma kullanarak karşılaştırmak her zaman sonuç verir false. Ancak, iki rastgele dizi eşit ===veya eşit olabilir .

"Bu fark ihmal edilebilir" diyeceksiniz. O zaman bunun bir fark olduğunu ve dikkate alınması gerektiğini ve her zaman olabileceğini söylüyorum. Yukarıda belirtildiği gibi, bir dizideki anahtarları sıralamak buna iyi bir örnektir.

Nesneler

Unutmayın, iki farklı nesne asla katı bir şekilde eşit değildir . Bu örnekler yardımcı olacaktır:

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

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

Not : Nesneyi başka bir değişkene atamak bir kopya oluşturmaz; bunun yerine, nesne ile aynı bellek konumuna bir başvuru oluşturur. Buraya bakın .

Not : PHP7'den itibaren anonim sınıflar eklendi. Sonuçlardan, arasında hiçbir fark yoktur new class {}ve new stdClass()yukarıdaki testlerde.