it-swarm-id.com

Bagaimana caranya PHP kesetaraan (== sama dengan ganda) dan operator perbandingan identitas (=== sama dengan tiga)?

Apa perbedaan antara == dan ===?

  • Bagaimana tepatnya perbandingan == longgar bekerja?
  • Bagaimana tepatnya cara kerja perbandingan ketat ===

Apa yang akan menjadi contoh yang bermanfaat?

451
nickf

Operator == melakukan cast di antara dua tipe yang berbeda jika berbeda, sedangkan operator === melakukan 'perbandingan yang aman'. Itu berarti bahwa itu hanya akan mengembalikan true jika kedua operan memiliki tipe dan nilai yang sama.

Contoh:

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

Peringatan : dua instance dari kelas yang sama dengan anggota yang setara TIDAK cocok dengan operator ===. Contoh:

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

Sebuah gambar bernilai ribuan kata:

PHP Double Equals == bagan kesetaraan:

 enter image description here

PHP Triple Equals === Bagan kesetaraan:

 enter image description here

Kode sumber untuk membuat gambar-gambar ini:

https://github.com/sentientmachine/php_equality_charts

Meditasi Guru

Mereka yang ingin menjaga kewarasannya, tidak membaca lebih lanjut.

  1. == mengonversi operan kiri dan kanan ke angka jika memungkinkan 123 == "123foo", tetapi "123" != "123foo"
  2. String heksa dalam tanda kutip kadang-kadang mengambang dan akan dilemparkan ke sana melawan kehendak Anda.
  3. == tidak transitif karena "0"== 0, dan 0 == "" tetapi "0" != ""
  4. "6" == " 6", "4.2" == "4.20", dan "133" == "0133" tetapi 133 != 0133, karena 0133 adalah oktal. Tapi "0x10" == "16" dan "1e3" == "1000"
  5. Variabel PHP yang belum dideklarasikan adalah false.

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

  7. Ketika angka cukup besar mereka == Infinity.
  8. NAN tidak == sendiri, tetapi itu Benar.
  9. Kelas baru adalah == hingga 1.
  10. Salah adalah nilai yang paling berbahaya karena False adalah == untuk sebagian besar variabel lain, sebagian besar mengalahkan tujuannya.

Harapan:

Jika Anda menggunakan PHP, jangan gunakan operator sama dengan ganda, selalu gunakan sama dengan tiga.

58
Eric Leschinski

Berkenaan dengan JavaScript:

Operator === bekerja sama dengan operator ==, tetapi mengharuskan operan tidak hanya memiliki nilai yang sama, tetapi juga tipe data yang sama.

Misalnya, sampel di bawah ini akan menampilkan 'x dan y sama', tetapi bukan 'x dan y identik'.

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

Tambahan untuk jawaban lain tentang perbandingan objek:

== membandingkan objek menggunakan nama objek dan nilainya. Jika dua objek memiliki tipe yang sama dan memiliki nilai anggota yang sama, $a == $b menghasilkan true.

=== membandingkan id objek internal objek. Sekalipun anggotanya sama, $a !== $b jika mereka bukan objek yang sama persis.

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

Secara sederhana:

== memeriksa apakah setara (hanya nilai)

=== memeriksa apakah sama (nilai && jenis)


.__ Setara vs Sama: An Analogi

1 + 1 = 2 + 0 (setara)

1 + 1 = 1 + 1 (sama)


Dalam PHP:

true == 1 (true - nilai yang setara)

true === 1 (false - tidak sama dengan nilai && jenis)

  • true adalah boolean
  • 1 adalah int
13
silver

Ini semua tentang tipe data. Ambil BOOL (benar atau salah) misalnya:

true juga sama dengan 1 dan false juga sama dengan 0

== tidak peduli dengan tipe data saat membandingkan: Jadi jika Anda memiliki variabel yaitu 1 (yang juga bisa menjadi true):

$var=1;

Dan kemudian bandingkan dengan ==:

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

Tetapi $var tidak benar-benar sama dengan true, bukan? Ini memiliki nilai int 1 sebagai gantinya, yang pada gilirannya, sama dengan true.

Dengan ===, tipe data diperiksa untuk memastikan dua variabel/objek/apa pun yang menggunakan tipe yang sama.

Jadi jika saya lakukan

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

kondisi itu tidak akan benar, karena $var !== true hanya == true (jika Anda tahu apa yang saya maksud).

Mengapa Anda membutuhkan ini?

Sederhana - mari kita lihat salah satu fungsi PHP: array_search():

Fungsi array_search() hanya mencari nilai dalam array, dan mengembalikan kunci elemen yang ditemukan nilai. Jika nilainya tidak ditemukan dalam array, ia mengembalikan false . Tapi, bagaimana jika Anda melakukan array_search() pada nilai yang disimpan di elemen pertama array (yang akan memiliki kunci array 0) .... fungsi array_search() akan mengembalikan 0 ... yang merupakan sama dengan false ..

Jadi, jika Anda melakukannya:

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

Jadi, apakah Anda melihat bagaimana ini bisa menjadi masalah sekarang?

Kebanyakan orang tidak menggunakan == false ketika memeriksa apakah suatu fungsi mengembalikan false. Sebagai gantinya, mereka menggunakan !. Tetapi sebenarnya, ini persis sama dengan menggunakan ==false, jadi jika Anda melakukannya:

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

Jadi untuk hal-hal seperti itu, Anda akan menggunakan === sebagai gantinya, sehingga tipe data diperiksa.

8
user849137

Salah satu contoh adalah bahwa atribut database bisa nol atau "":

$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

Diberi x = 5

1) Operator: == sama dengan ". x == 8 salah
2) Operator: === "sama dengan" (nilai dan jenis) x === 5 benar, x === "5" salah

6
Mannusanghi

Beberapa contoh

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.

== Membandingkan nilainya saja, tidak akan mengganggu tentang tipe data

vs.

=== Membandingkan nilai dan tipe data

4
Mohit Tanwani

Singkatnya, === bekerja dengan cara yang sama seperti yang dilakukan== di sebagian besar bahasa pemrograman lainnya.

PHP memungkinkan Anda untuk membuat perbandingan yang tidak terlalu masuk akal. Contoh:

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

Meskipun ini memungkinkan untuk beberapa "jalan pintas" yang menarik Anda harus berhati-hati karena fungsi yang mengembalikan sesuatu yang seharusnya tidak (seperti "kesalahan" bukan angka) tidak akan tertangkap, dan Anda akan bertanya-tanya apa yang terjadi.

Dalam PHP, == membandingkan nilai dan melakukan konversi tipe jika perlu (misalnya, string "12343sdfjskfjds" akan menjadi "12343" dalam perbandingan bilangan bulat). === akan membandingkan nilai DAN tipe dan akan mengembalikan false jika jenisnya tidak sama.

Jika Anda melihat di manual PHP, Anda akan melihat bahwa banyak fungsi mengembalikan "false" jika fungsi gagal, tetapi mereka mungkin mengembalikan 0 dalam skenario yang sukses, itulah sebabnya mereka merekomendasikan melakukan "if (function ( )! == false) "untuk menghindari kesalahan.

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

Berhati-hatilah. Ini masalah yang terkenal.

// '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 adalah bahasa yang diketik secara longgar. Menggunakan operator ganda sama memungkinkan pengecekan variabel yang longgar.

Dengan memeriksa nilai secara longgar akan memungkinkan beberapa nilai yang sama, tetapi tidak sama, untuk disamakan sebagai sama:

  • ''
  • batal
  • false

Semua nilai ini akan sama dengan menggunakan operator sama dengan ganda.

2
Cory Collier

Anda akan menggunakan === untuk menguji apakah suatu fungsi atau variabel salah daripada hanya menyamakan ke false (nol atau string kosong).

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

Dalam hal ini strpos akan mengembalikan 0 yang akan sama dengan false dalam tes

if ($pos == false)

atau

if (!$pos)

yang bukan apa yang Anda inginkan di sini.

2
Stacey Richards

Adapun kapan harus menggunakan satu di atas yang lain, ambil contoh fungsi fwrite() dalam PHP.

Fungsi ini menulis konten ke aliran file. Menurut PHP, "fwrite() mengembalikan jumlah byte yang ditulis, atau FALSE pada kesalahan.". Jika Anda ingin menguji apakah pemanggilan fungsi berhasil, metode ini cacat:

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

Ini dapat mengembalikan nol (dan dianggap berhasil), dan kondisi Anda masih terpicu. Cara yang benar adalah:

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

php == adalah operator perbandingan yang membandingkan nilai variabel. Tapi === membandingkan nilai dan tipe data.

Sebagai contoh,

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

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

Dalam hal ini output akan menjadi 'Variabel sama', meskipun tipe datanya berbeda.

Tetapi jika kita menggunakan === daripada ==, hasilnya adalah 'Variabel tidak sama'. Php pertama membandingkan nilai variabel dan kemudian tipe data. Di sini nilainya sama, tetapi tipe data berbeda.

1
2rahulsk

Semua jawaban sejauh ini mengabaikan masalah berbahaya dengan ===. Telah dicatat secara sepintas, tetapi tidak ditekankan, bahwa integer dan double adalah tipe yang berbeda, jadi kode berikut:

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

memberi:

 equal
 not equal

Perhatikan bahwa ini BUKAN merupakan kasus "kesalahan pembulatan". Kedua angka tersebut persis sama hingga ke bit terakhir, tetapi mereka memiliki tipe yang berbeda.

Ini adalah masalah buruk karena program menggunakan === dapat berjalan dengan bahagia selama bertahun-tahun jika semua jumlahnya cukup kecil (di mana "cukup kecil" tergantung pada perangkat keras dan OS yang Anda jalankan). Namun, jika secara kebetulan, bilangan bulat kebetulan cukup besar untuk dikonversi menjadi dobel, tipenya diubah "selamanya" meskipun operasi berikutnya, atau banyak operasi, mungkin membawanya kembali ke nilai integer kecil. Dan, semakin buruk. Ia dapat menyebar - infeksi dua kali lipat dapat diteruskan ke apa pun yang disentuhnya, satu perhitungan pada satu waktu. 

Di dunia nyata, ini mungkin menjadi masalah dalam program yang menangani tanggal di luar tahun 2038, misalnya. Pada saat ini, cap waktu UNIX (jumlah detik sejak 1970-01-01 00:00:00 UTC) akan membutuhkan lebih dari 32-bit, sehingga perwakilan mereka akan "secara ajaib" beralih untuk menggandakan pada beberapa sistem. Karena itu, jika Anda menghitung perbedaan antara dua kali Anda mungkin berakhir dengan beberapa detik, tetapi sebagai ganda, bukan hasil bilangan bulat yang terjadi pada tahun 2017.

Saya pikir ini jauh lebih buruk daripada konversi antara string dan angka karena itu halus. Saya merasa mudah untuk melacak apa yang merupakan string dan apa itu angka, tetapi melacak jumlah bit dalam angka berada di luar jangkauan saya.

Jadi, dalam jawaban di atas ada beberapa tabel Nice, tetapi tidak ada perbedaan antara 1 (sebagai bilangan bulat) dan 1 (ganda halus) dan 1.0 (ganda jelas). Juga, saran yang harus selalu Anda gunakan === dan jangan pernah == tidak bagus karena === terkadang gagal di mana == berfungsi dengan baik. Juga, JavaScript tidak setara dalam hal ini karena hanya memiliki satu tipe angka (secara internal mungkin memiliki representasi bit-wise yang berbeda, tetapi tidak menyebabkan masalah untuk ===).

Saran saya - jangan gunakan keduanya. Anda harus menulis fungsi perbandingan sendiri untuk benar-benar memperbaiki kekacauan ini.

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

Variabel memiliki tipe dan nilai.

  • $ var = "test" adalah string yang berisi "test"
  • $ var2 = 24 adalah nilai integer vhose adalah 24.

Ketika Anda menggunakan variabel-variabel ini (dalam PHP), kadang-kadang Anda tidak memiliki tipe yang baik . Misalnya, jika Anda melakukannya

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

PHP harus mengonversi ("untuk membuang") $ var ke integer. Dalam kasus ini, "$ var == 1" benar karena setiap string yang tidak kosong dilemparkan ke 1.

Saat menggunakan ===, Anda memeriksa bahwa nilai DAN JENIS THE sama, jadi "$ var === 1" salah.

Ini berguna, misalnya, ketika Anda memiliki fungsi yang dapat mengembalikan false (kesalahan) dan 0 (hasil):

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

Kode ini salah seperti jika myFunction() mengembalikan 0, ini dilemparkan ke false dan Anda tampaknya memiliki kesalahan. Kode yang benar adalah:

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

karena tesnya adalah bahwa nilai balik "adalah boolean dan salah" dan bukan "dapat dicor salah".

1
ofaurax

Operator === seharusnya membandingkan tepat persamaan konten sementara operator == akan membandingkan persamaan semantik. Khususnya itu akan memaksa string ke angka.

Kesetaraan adalah subjek yang luas. Lihat artikel Wikipedia tentang kesetaraan .

1
kmkaplan

Ada dua perbedaan antara == dan === dalam array PHP dan objek yang saya pikir tidak disebutkan di sini; dua array dengan jenis kunci yang berbeda, dan objek.

Dua array dengan jenis kunci yang berbeda

Jika Anda memiliki larik dengan jenis kunci dan larik lain dengan jenis kunci yang berbeda, mereka sangat berbeda (yaitu menggunakan ===). Itu dapat menyebabkan jika Anda mengurutkan array, dan mencoba membandingkan array yang diurutkan dengan yang asli.

Misalnya, pertimbangkan array kosong. Pertama, kami mencoba untuk Mendorong beberapa indeks baru ke array tanpa jenis khusus. Contoh yang baik adalah array dengan string sebagai kunci. Sekarang jauh ke dalam contoh:

// Define an array
$arr = [];

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

Sekarang, kami memiliki larik tidak-diurutkan-kunci (mis., 'Dia' datang setelah 'Anda'). Pertimbangkan array yang sama, tetapi kami mengurutkan kuncinya secara alfabet:

// Declare array
$alphabetArr = [];

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

Tip: Anda dapat mengurutkan array dengan kunci menggunakan ksort () function.

Sekarang Anda memiliki array lain dengan jenis kunci berbeda dari yang pertama. Jadi, kita akan membandingkannya:

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

Catatan: Mungkin jelas, tetapi membandingkan dua array berbeda menggunakan perbandingan ketat selalu menghasilkan false. Namun, dua array sewenang-wenang mungkin sama dengan menggunakan === atau tidak.

Anda akan berkata: "Perbedaan ini dapat diabaikan". Lalu saya katakan itu perbedaan dan harus dipertimbangkan dan dapat terjadi kapan saja. Seperti disebutkan di atas, pengurutan kunci dalam array adalah contoh yang bagus.

Benda

Perlu diingat, dua objek berbeda tidak pernah sama ketatnya. Contoh-contoh ini akan membantu:

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

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

Catatan: Menetapkan objek ke variabel lain tidak membuat salinan - melainkan membuat referensi ke lokasi memori yang sama dengan objek. Lihat disini .

Note: Pada PHP7, kelas anonim telah ditambahkan. Dari hasil, tidak ada perbedaan antara new class {} dan new stdClass() dalam tes di atas.

0
MAChitgarha