Operator Identitas

Perbandingan longgar == dari chapter sebelumnya fleksibel, tetapi fleksibilitasnya membuka pintu bagi kejutan: "5" dianggap sama dengan 5, dan null dianggap sama dengan false. Ketika perbedaan string dan angka benar-benar penting — misalnya saat mencari nilai dalam data pengguna atau memeriksa hasil sebuah fungsi — kita membutuhkan perbandingan yang menolak kompromi tipe data. Pada chapter ini kita akan mempelajari operator identitas === dan !==, membandingkannya dengan ==, lalu melihat perilaku khususnya pada array dan object.

Operator Identitas #

PHP menyediakan dua operator identitas yang membandingkan nilai dan tipe data sekaligus, tanpa type juggling sama sekali:

Agar === menghasilkan true, kedua operan harus memiliki tipe yang sama dan nilai yang sama. Berikut perbandingan pasangan yang sama persis, dinilai oleh kedua operator:

<?php
var_dump("5" == 5, "5" === 5);
var_dump(5 == 5.0, 5 === 5.0);
var_dump(null == false, null === false);
var_dump(null == "", null === "");
var_dump("1" == "01", "1" === "01");

Output yang Dihasilkan:

bool(true)
bool(false)
bool(true)
bool(false)
bool(true)
bool(false)
bool(true)
bool(false)
bool(true)
bool(false)

Setiap baris membandingkan pasangan yang sama dengan dua operator. Kolom hasil == selalu true karena type juggling menyamakan keduanya lebih dahulu — string "5" menjadi angka, null menjadi false, dan "01" menjadi 1. Kolom === selalu false karena tipe kedua operan berbeda: string lawan integer, integer lawan float, null lawan boolean. Perhatikan kasus 5 === 5.0: nilainya sama secara matematis, tetapi satu bertipe int dan satu bertipe float, sehingga tidak identik.

Kapan Memilih Operator Identitas #

Aturan praktis yang dipegang komunitas PHP: gunakan === secara bawaan, turunannya ke == hanya ketika Anda sengaja ingin fleksibilitas tipe. Alasannya bukan gaya penulisan, melainkan keselamatan: banyak fungsi bawaan PHP mengembalikan nilai yang maknanya bergantung pada tipe. Contoh klasiknya adalah in_array(), fungsi pencari nilai di dalam array yang mengevaluasi kecocokan secara longgar secara bawaan:

<?php
$stokTersedia = [10, 25, 50];

var_dump(in_array("25", $stokTersedia));        // longgar: "25" == 25 -> ketemu
var_dump(in_array("25", $stokTersedia, true));  // ketat : string != integer -> tidak

Output yang Dihasilkan:

bool(true)
bool(false)

Parameter ketiga in_array() mengaktifkan perbandingan ketat. Tanpa parameter tersebut, pencarian "25" (string) menemukan 25 (integer) karena perbandingan longgar menganggapnya sama; dengan parameter true, string dan integer tidak lagi cocok. Situasi nyata seperti ini sering muncul ketika data datang dari formulir web yang selalu berupa string, sementara data pembanding di program bertipe integer.

Identitas pada Array #

Untuk array, operator == dan === memiliki makna yang berbeda secara halus namun penting. Operator == menyatakan dua array sama jika keduanya memiliki himpunan pasangan key-value yang sama — urutan penulisan pasangan boleh berbeda dan setiap nilai dibandingkan secara longgar. Perlu dicermati: pada array berindeks, posisi adalah key-nya, sehingga [1, 2] dan [2, 1] memiliki pasangan key-value yang berbeda (0 => 1 lawan 0 => 2). Operator === jauh lebih menuntut: pasangan key-value harus muncul dalam urutan iterasi yang sama dan setiap nilai harus bertipe sama:

<?php
$a = [1, 2];
$b = [2, 1];
$c = ["a" => 1, "b" => 2];
$d = ["b" => 2, "a" => 1];
$e = [1, "2"];
$f = [1, 2];

var_dump($a == $b, $a === $b);  // array berindeks: key 0 berisi nilai berbeda
var_dump($c == $d, $c === $d);  // pasangan sama, urutan penulisan berbeda
var_dump($e == $f, $e === $f);  // "2" == 2 secara longgar, tapi beda tipe

Output yang Dihasilkan:

bool(false)
bool(false)
bool(true)
bool(false)
bool(true)
bool(false)

Array $a dan $b sama-sama berisi angka 1 dan 2, tetapi keduanya tidak sama menurut == sekalipun: pada indeks 0, array pertama bernilai 1 sementara array kedua bernilai 2 — posisi adalah bagian dari identitas pasangan key-value. Array asosiatif $c dan $d memperlihatkan sisi sebaliknya: pasangan "a" => 1 dan "b" => 2 sama persis hanya urutan penulisannya yang dibalik, sehingga == menghasilkan true sementara === menolaknya karena urutan iterasi berbeda. Kasus $e dan $f menunjukkan sisi ketat lainnya: elemen kedua "2" (string) dan 2 (integer) dianggap sama oleh ==, tetapi ditolak oleh === karena tipenya berbeda. Jika Anda perlu membandingkan array asosiatif tanpa memedulikan urutan penulisan, == adalah alat yang tepat; jika urutan juga bermakna — misalnya langkah-langkah resep atau urutan prioritas — gunakan ===.

Perbandingan Object #

Object menambahkan satu lapis makna lagi. Operator == menyatakan dua object sama jika berasal dari class yang sama dan seluruh propertinya bernilai sama. Operator === hanya menghasilkan true jika kedua variabel menunjuk ke object yang sama persis (instance yang sama di memori):

<?php
class Titik {
    public int $x = 0;
    public int $y = 0;
}

$a = new Titik();
$a->x = 3;
$a->y = 4;

$b = new Titik();
$b->x = 3;
$b->y = 4;

$c = $a; // $c dan $a menunjuk object yang sama

var_dump($a == $b);   // class sama, nilai properti sama
var_dump($a === $b);  // dua object berbeda di memori
var_dump($a === $c);  // satu object yang sama

Output yang Dihasilkan:

bool(true)
bool(false)
bool(true)

Variabel $a dan $b masing-masing membuat object Titik sendiri dengan isi properti yang sama persis, sehingga == menghasilkan true tetapi === menghasilkan false. Penugasan $c = $a tidak menyalin object; keduanya menjadi nama untuk object yang sama, sehingga $a === $c bernilai true. Pembahasan lebih dalam tentang identitas object, cloning, dan perbandingannya ada di chapter Object Comparison pada Section OOP.

Berkas contoh.php pada bagian bawah halaman merangkum seluruh contoh chapter ini dalam satu program yang bisa dijalankan langsung.

Referensi #

• Operator Perbandingan — Manual PHP
• Fungsi in_array() — Manual PHP
• Perbandingan Array — Manual PHP

Ringkasan #

Operator identitas === dan !== membandingkan tipe dan nilai sekaligus tanpa type juggling: "5" tidak identik dengan 5, null tidak identik dengan false, dan 5 tidak identik dengan 5.0. Pada array, === menuntut urutan dan tipe elemen yang sama; pada object, === berarti instance yang sama. Dengan dua gaya perbandingan ini di tangan, kita siap menggabungkan beberapa kondisi sekaligus — tugas operator logika pada chapter berikutnya.

<?php
// contoh.php — rangkuman Operator Identitas
// Jalankan dengan: php contoh.php

echo "== == vs === pada pasangan yang sama ==\n";
var_dump("5" == 5, "5" === 5);
var_dump(5 == 5.0, 5 === 5.0);
var_dump(null == false, null === false);
var_dump(null == "", null === "");
var_dump("1" == "01", "1" === "01");

echo "\n== Pencarian ketat dengan in_array ==\n";
$stokTersedia = [10, 25, 50];
var_dump(in_array("25", $stokTersedia));
var_dump(in_array("25", $stokTersedia, true));

echo "\n== Identitas array: urutan dan tipe ==\n";
$a = [1, 2];
$b = [2, 1];
$c = ["a" => 1, "b" => 2];
$d = ["b" => 2, "a" => 1];
$e = [1, "2"];
$f = [1, 2];

var_dump($a == $b, $a === $b);  // array berindeks: key 0 berisi nilai berbeda
var_dump($c == $d, $c === $d);  // pasangan sama, urutan penulisan berbeda
var_dump($e == $f, $e === $f);  // "2" == 2 secara longgar, tapi beda tipe

echo "\n== Perbandingan object ==\n";
class Titik {
    public int $x = 0;
    public int $y = 0;
}

$a = new Titik();
$a->x = 3;
$a->y = 4;

$b = new Titik();
$b->x = 3;
$b->y = 4;

$c = $a;

var_dump($a == $b);
var_dump($a === $b);
var_dump($a === $c);