it-swarm-tr.com

Nasıl PHP eşitlik (== çift eşit) ve kimlik (=== üçlü eşit) karşılaştırma operatörleri farklı mıdır?

== ve === arasındaki fark nedir?

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

Yararlı örnekler neler olabilir?

451
nickf

== ve === arasındaki fark

Gevşek == eşit operatör ile katı === aynı operatör arasındaki fark manual içinde tam olarak açıklanmıştır:

Karşılaştırma Operatörleri

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

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

== operatörünü veya !=, <> veya == gibi gevşek bir karşılaştırma kullanan başka bir karşılaştırma operatörü kullanıyorsanız, daima - bağlam neler olup bittiğini anlamak için bir şeyin ne, nerede ve neden dönüştürüldüğünü görmek için.

Kuralları dönüştürme

Karşılaştırma tablosu yazın

Referans ve örnek olarak, karşılaştırma tablosunu kılavuz içinde görebilirsiniz:

== ile 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 │ YANLIŞ │ DOĞRU │ DOĞRU │ YANLIŞ │ DOĞRU │ YANLIŞ │ YANLIŞ │ DOĞRU │ YANLIŞ │ 
 │ YANLIŞ │ YANLIŞ │ DOĞRU │ YANLIŞ E │ DOĞRU UE YANLIŞ │ YANLIŞ │ DOĞRU │ YANLIŞ │ YANLIŞ UE YANLIŞ │ YANLIŞ │ YANLIŞ .__ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ .__ YANLIŞ YANLIŞ │ 
 │ 0 │ YANLIŞ │ DOĞRU │ YANLIŞ │ DOĞRU │ YANLIŞ │ YANLIŞ │ YANLIŞ UE YANLIŞ │ YANLIŞ │ YANLIŞ AL YANLIŞ │ DOĞRU │ YANLIŞ AL YANLIŞ AL YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ 1 YANLIŞ 1 YANLIŞ 1 YANLIŞ UE YANLIŞ │ YANLIŞ │ 
 │ "0" │ YANLIŞ │ DOĞRU │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ AL YANLIŞ │ YANLIĞ │ YANLIŞ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ .__ YANLIŞ │ YANLIŞ │ YANLIŞ │ DOĞRU │ YANLIŞ │ DOĞRU │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ UE YANLIŞ UE YANLIŞ SE YANLIŞ .__ YANLIŞ .__ YANLIŞ │ YANLIŞ .__ YANLIŞ .__ YANLIŞ DOĞRU │ YANLIŞ │ YANLIŞ │ 
 │ "php" │ DOĞRU AL YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ SE YANLIŞ │ YANLIŞ │ YANLIŞ │ │ DOĞRU │ YANLIŞ │ DOĞRU │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ UE YANLIŞ AL YANLIŞ │ YANLIŞ │ YANLIŞ │ 
 └─────────┴───────┴─── ────┴───────┴───────┴───────┴───────┴───────┴───── ──┴───────┴─────────┴───────┴───────┘ 

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

=== operatörünü veya !== veya === gibi sıkı bir karşılaştırma kullanan başka bir karşılaştırma operatörünü kullanıyorsanız, türlerin her zaman sihirli bir şekilde değişir, çünkü devam eden bir dönüşüm olmayacak. Bu nedenle, sıkı bir karşılaştırma yapıldığında, tür ve değer yalnızca değer değil, aynı olmak zorundadır.

Karşılaştırma tablosu yazın

Referans ve örnek olarak, karşılaştırma tablosunu kılavuz içinde görebilirsiniz:

=== ile sıkı karşılaştırmalar

┌─────────┬───────┬───────┬───────┬───────┬─────── ┬───────┬───────┬───────┬───────┬─────────┬─────── ┬───────┐ 
 │ │ DOĞRU │ YANLIŞ │ 1 │ 0 │ -1 │ "1" │ "0" │ "-1" │ NULL │ dizi () │ "php" │ "" │ 
 ├─────────┼───────┼───────┼───────┼─────── ┼───────┼───────┼───────┼───────┼───────┼───────── ┼───────┼───────┤ 
 UE DOĞRU │ DOĞRU │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ .____.] │ YANLIŞ │ YANLIŞ │ DOĞRU │ YANLIŞ │ YAN Y │ YAN Y │ Y │ Y │ Y │ Y │ Y │ Y │ Y │ Y │ Y │ Y │ Y │ Y │ Y │ Y │ Y │ Y │ Y │ Y │ Y │ Y │ Y │ Y │ │ YANLIŞ │ 
 │ 0 │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ AL YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIĞ AL YANLIŞ .__ YANLIŞ .__ UE DOĞAN │ YAN │ YAN │ YAN │ YAN │ YAN │ YAN │ YAN Y │ YAN Y │ YAN Y │ Y AL Y │ Y │ Y │ Y │ Y │ Y │ Y │ Y │ Y │ Y │ Y │ Y │ Y │ Y │ Y │ Y │ Y │ Y │ 
 │ "0" │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ UE YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ AL YANLIŞ │ YANLIŞ │ YANLIŞ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ UE YANLIŞ │ YANLIŞ │ YANLIŞ .__ YANLIŞ .__ YANLIŞ .__ YANLIŞ │ YANLIŞ DOĞRU │ YANLIŞ │ YANLIŞ │ 
 │ "php" │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ SE YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ AL YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ │ YANLIŞ .__ 
 └─────────┴───────┴─── ────┴───────┴───────┴───────┴───────┴───────┴───── ──┴───────┴─────────┴───────┴───────┘ 
603
nickf

Operatör ==, farklıysa iki farklı tip arasında geçiş yaparken, === operatörü 'typesafe karşılaştırma' gerçekleştirir. Bu, yalnızca her iki işlenen de aynı türde ve aynı değerde olduğunda bunun gerçek olacağı 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şleciyle eşleşmiyor. Örnek:

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

Bir resim bin kelime değerinde bir olup:

PHP Çift Eşittir == eşitlik tablosu:

 enter image description here

PHP Üçlü Eşittir === Eşitlik tablosu:

 enter image description here

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 okuma.

  1. == mümkün olduğunda sol ve sağ işlenenleri sayılara dönüştürür 123 == "123foo", ancak "123" != "123foo"
  2. Tırnak içindeki altıgen bir dize, zaman zaman kayan yazıdır ve kendi isteğinize karşı atılır.
  3. == geçişli değildir çünkü "0"== 0 ve 0 == "" ancak "0" != ""
  4. "6" == " 6", "4.2" == "4.20" ve "133" == "0133" ancak 133 != 0133, çünkü 0133 sekizliktir. Ama "0x10" == "16" ve "1e3" == "1000"
  5. Henüz bildirilmemiş PHP Değişkenleri yanlıştır.

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

  7. Sayılar yeterince büyük olduğunda, == Sonsuzluktur.
  8. NAN == kendisi yapmaz, ancak bu doğrudur.
  9. Yeni bir sınıf == ila 1'dir.
  10. False en tehlikeli değerdir, çünkü False diğer değişkenlerin çoğu için ==, çoğunlukla amacını yitirir.

Umut:

Eğer PHP kullanıyorsanız, çift eşittir operatörünü kullanmayacaksınız, her zaman üçlü eşittir kullanın.

58
Eric Leschinski

JavaScript ile ilgili olarak:

=== işleci == işleci ile aynı şekilde çalışır, ancak işleçlerinin yalnızca aynı değerde değil, aynı veri türünde olmasını da gerektirir.

Örneğin, aşağıdaki örnek 'x ve y eşittir', ancak 'x ve y aynı' göstermeyecektir.

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

Nesne karşılaştırmasına ilişkin 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 == $b gerçek olur.

=== Nesnelerin iç nesne kimliğini karşılaştırır. Üyeler eşit olsalar bile, tam olarak aynı nesneler değilse $a !== $b.

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

En basit ifadeyle:

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

=== same (değer ve& tipi) .__ olup olmadığını kontrol eder.


Eşdeğer vs Aynı: Bir Analoji

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

1 + 1 = 1 + 1 (aynı)


PHP’de:

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

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

  • true boolean
  • 1 int
13
silver

Her şey veri türleriyle ilgili. Örneğin bir BOOL (doğru veya yanlış) atın:

true ayrıca 1 eşittir _ ve false ayrıca 0 eşittir

==, karşılaştırırken veri türlerini umursamıyor: Öyleyse, 1 olan bir değişkeniniz varsa (ki, true):

$var=1;

Ve sonra == ile karşılaştırın:

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

Ancak $var aslında true ile eşit değil, değil mi? Bunun yerine 1 öğesinin int değerine sahiptir, bunun yerine doğru olur.

=== ile, iki türün/nesnenin/aynı türü ne kullanıyorsanız kullanılmasını sağlamak için veri tipleri kontrol edilir.

Öyleyse yapsaydım

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

bu koşul doğru olmaz, çünkü $var !== true _ sadece == true (ne demek istediğimi anlıyorsan).

Neden buna ihtiyacınız var?

Basit - PHP'nin fonksiyonlarından birine bakalım: array_search():

array_search() işlevi yalnızca bir dizideki değeri arar ve değerin bulunduğu öğenin anahtarını döndürür. Değer dizide bulunamazsa, false değerini döndürür. Ancak, dizinin ilk elemanı içinde saklanan bir değere array_search() yaptıysanız == (0 dizisinin anahtarına sahip olurdu) .... array_search() işlevi 0 döndür ... yanlış olan eşittir ..

Yani yaptıysanız:

$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?

Bir işlevin false döndürüp döndürmediğini kontrol ederken çoğu insan == false kullanmaz. Bunun yerine ! kullanıyorlar. Fakat aslında, bu tamamen ==false ile aynıdır, öyleyse:

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

Böylece, bunun gibi şeyler için, bunun yerine === kullanır, böylece veri tipi kontrol edilir.

8
user849137

Bir örnek, bir veritabanı özelliğinin boş 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
8
fico7489

Verilen x = 5

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

6
Mannusanghi

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.

Not;.

== 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

4
Mohit Tanwani

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

PHP gerçekten mantıklı olmayan karşılaştırmalar yapmanızı sağlar. Örnek:

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

Bu, bazı ilginç "kısayollara" izin verirken, dikkat etmemesi gereken bir şey döndüren bir işlev (sayı yerine "hata" gibi) yakalanmayacağından ve ne olduğunu merak edeceğiniz için dikkatli olmalısınız.

PHP'de == değerleri karşılaştırır ve gerekirse tür dönüştürmesi gerçekleştirir (örneğin, "12343sdfjskfjds" dizgisi bir tamsayı karşılaştırmasında "12343" olur). ===, AND türünü karşılaştıracak ve tür aynı değilse, false döndürecektir.

PHP kılavuzuna bakarsanız, bir çok fonksiyonun başarısız olması durumunda "yanlış" döndüğünü görürsünüz, ancak başarılı bir senaryoda 0 değerini döndürebilirler, bu yüzden "yapmaları önerilir" eğer (işlev ( )! == yanlış) "hataları önlemek için.

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

Yine de dikkatli ol. İşte meşhur bir problem.

// '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 gevşek yazılmış bir dildir. İkili eşit operatörün kullanılması, bir değişkenin gevşek kontrolünü sağlar.

Bir değeri gevşek bir şekilde kontrol etmek, bazılarının benzer, ancak eşit olmayan değerlerin aynı olarak eşitlenmesine izin verir:

  • ''
  • boş
  • false

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

2
Cory Collier

Bir işlev veya değişkenin yanlış olup olmadığını sınamak için === kullanırsınız (sıfır veya boş bir dize).

$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 eşit olacak şekilde 0 değerini döndürür.

if ($pos == false)

veya

if (!$pos)

istediğin şey bu değil.

2
Stacey Richards

Birinin diğerini ne zaman kullanacağına gelince, örneğin PHP'deki fwrite() işlevini alın.

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ı sınamak istiyorsanız, bu yöntem hatalı:

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

Sıfır döndürür (ve başarılı kabul edilir) ve durumunuz hala tetiklenir. Doğru yol şöyle olurdu:

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

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 tipleri farklı olsa bile çıktı 'Değişkenler eşit' olacaktır.

Ancak == yerine === kullanırsak, çıktı 'Değişkenler eşit değildir' olacaktır. Php önce değişkenin değerini, ardından veri tipini karşılaştırır. Burada değerler aynı, ancak veri tipleri farklı.

1
2rahulsk

Şimdiye kadarki cevapların tümü === ile tehlikeli bir sorunu göz ardı ediyor. Tamsayı ve çiftin farklı tipler olduğu, ancak aşağıdaki kodun geçerken, ancak vurgulanmadığı belirtilmiştir:

$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 olmadığını unutmayın. İki sayı tam olarak son bite eşittir, ancak farklı türleri vardır.

Bu çok kötü bir sorundur çünkü === kullanan bir program, tüm sayılar yeterince küçükse, yıllarca mutlu çalışabilir (burada "yeterince küçük", çalıştırdığınız donanıma ve işletim sistemine bağlıdır). Ancak, eğer şans eseri bir tamsayı çifte dönüştürülecek kadar büyük olursa, bir sonraki işlem veya birçok işlem onu ​​değerindeki küçük bir tamsayıya geri getirse de, türü "sonsuza kadar" değişmiştir. Ve daha da kötüleşiyor. Yayılabilir - çifte enfeksiyon enfeksiyonu dokunduğu her şeye tek seferde bir dokunuşla aktarılabilir. 

Gerçek dünyada, bunun, örneğin 2038 yılının ötesindeki tarihleri ​​işleyen programlarda bir sorun olması muhtemeldir. Şu anda, UNIX zaman damgaları (1970-01-01 00:00:00 UTC’den bu yana geçen saniye sayısı) 32 bitten fazlasını gerektirecektir; Bu nedenle, iki kez arasındaki farkı hesaplarsanız, 2017 yılında meydana gelen tam sayı sonucundan ziyade birkaç saniye ile bitebilir, ancak bunun iki katı olabilir.

Bence bu, karakter dizileri ve sayılar arasındaki dönüşümden çok daha kötü çünkü ince. Bir dize nedir ve sayı nedir takip etmeyi kolay buluyorum, ancak bir sayıdaki bit sayısını takip etmek benden öteye gidiyor.

Öyleyse, yukarıdaki cevaplarda bazı Nice masaları var, ancak 1 (tamsayı olarak) ve 1 (ince çift) ve 1.0 (açık iki katı) arasında bir ayrım yok. Ayrıca, her zaman === kullanmanız ve hiçbir zaman == kullanmamanız tavsiye edilmez çünkü === bazen == düzgün çalıştığında başarısız olur. Ayrıca, JavaScript bu konuda eşdeğer değildir, çünkü yalnızca bir sayı türüne sahiptir (dahili olarak farklı bit şeklinde gösterimler olabilir, ancak === için sorunlara neden olmaz).

Tavsiyem - ikisini de kullanmayın. Bu karışıklığı düzeltmek için kendi karşılaştırma fonksiyonunuzu yazmanız gerekir.

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

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

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

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

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

PHP'nin ("cast") dönüştürmesi gerekiyor, $ tam sayıya var. Bu durumda, "$ var == 1" boş olur, çünkü boş olmayan herhangi bir dize 1'e verilir.

=== kullanırken, AND AND TYPE değerinin eşit olduğunu kontrol edersiniz, yani "$ var === 1" yanlıştır.

Bu, örneğin yanlış (hata durumunda) ve 0 (sonuç) olarak dönebilen bir işleviniz olduğunda yararlıdır:

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

Bu kod, eğer myFunction(), 0 döndürürse, yanlış sayılır ve bir hata yapmış gibi görünür. Doğru kod:

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

çünkü test, dönüş değerinin "bir boole olduğunu ve yanlış olduğunu" ve "yanlış olarak kullanılamaz" dır.

1
ofaurax

=== operatörünün exact içerik eşitliğini karşılaştırması beklenirken, == operatörünün semantik eşitliği karşılaştırması gerekir. Özellikle dizeleri sayılara zorlayacaktır.

Eşitlik engin bir konudur. Eşitlik hakkındaki Wikipedia makalesi 'e bakınız.

1
kmkaplan

PHP dizilerinde == ve === arasında ve burada bahsetmediğimi düşündüğüm nesnelerde iki fark var; farklı anahtar türlerine ve nesnelere sahip iki dizi.

Farklı anahtar türlerine sahip iki dizi

Bir anahtar sıralama içeren bir diziniz ve farklı bir anahtar sıralama içeren başka bir diziniz varsa, bunlar kesinlikle farklıdır (örneğin, === kullanarak). Bunun nedeni, bir diziyi anahtar sıralamanız ve sıralanan diziyi orijinal olanla karşılaştırmayı denemenize neden olabilir.

Örneğin, boş bir dizi düşünün. Öncelikle, herhangi bir özel sıralama olmadan bazı yeni dizinleri diziye itmeye çalışıyoruz. İyi bir örnek, anahtar olarak dizeleri olan bir dizi olacaktır. Şimdi bir örneğe derin:

// Define an array
$arr = [];

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

Şimdi, sıralanmamış bir anahtar dizisine sahibiz (örneğin, 'siz' 'sizden sonra geldi). Aynı diziyi göz önünde bulundurun, ancak tuşları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ıralama ile başka bir dizi var. Yani, onları karşılaştıracağız:

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

Not: Belli olabilir, ancak kesin karşılaştırma kullanarak iki farklı diziyi karşılaştırmak her zaman false sonucunu verir. Bununla birlikte, iki rastgele dizi === kullanarak veya değil kullanılarak eşit olabilir.

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

Nesneler

Unutmayın, iki farklı nesne asla tam olarak 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: Bir nesneyi başka bir değişkene atamak, kopya oluşturmaz, bunun yerine nesne ile aynı hafıza konumuna referans oluşturur. Buraya bakın .

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

0
MAChitgarha