Mengenal Jenis-Jenis Operator PHP Part 2

April 30, 2023 Posting Komentar

Belajar jenis-jenis operator PHP Part 2

pada pos sebelumnya kita sudah belajar berbagai jenis operator pada php part 1 (silahkan klik link di samping untuk mempelajari pos sebelumnya untuk melanjutkan pada pos ini)

Basic Assignment

Basic assignment merupakan operator dasar yang sering digunakan pada saat menuliskan kode PHP. Basic assignment menggunakan simbol = dan berfungsi untuk menetapkan nilai pada variabel yang diinginkan. Berikut merupakan contoh penggunaannya.

<?php
  // Menetapkan nilai 10 pada variabel $firstValue
  $firstValue = 10;

  echo $firstValue;
  # Output: 10
?>

Basic assignment juga berfungsi untuk menetapkan nilai suatu variabel dari variabel lainnya. Mari kita lihat contoh penerapannya pada kode berikut.

<?php
  $firstValue = 20;
  
  // Variabel $secondValue menerima nilai dari $firstValue
  $secondValue = $firstValue;

  echo $secondValue;
  # Output: 20
?>

Combined Assignment

Combined assignment merupakan gabungan dari basic assignment (=) dengan operator aritmatika (+, -, *, /, %, dan **) atau bitwise operator. Dengan kata lain, combined assignment bertujuan untuk melakukan operasi dan menetapkan hasil operasi secara singkat.

Dalam PHP, terdapat beberapa jenis operator combined assignment, antara lain:

Plus-Equal

Plus-Equal merupakan singkatan dari penulisan operasi aritmatika penjumlahan dan penetapan nilai hasil operasinya. Operator ini menggunakan simbol +=. Mari kita perhatikan contoh berikut ini.

<?php
  // Inisialisasi $sumNumber dengan nilai 5
  $sumNumber = 5;

  $sumNumber += 10;
  // $sumNumber = $sumNumber + 10

  echo $sumNumber;
  # Output: 15
?>

Minus-Equal

Minus-Equal merupakan cara singkat dalam penulisan operasi aritmatika pengurangan dan penetapan nilai hasil operasi tersebut. Operator ini memanfaatkan simbol -=. Perhatikan contoh penerapannya pada kode berikut.

<?php
  // Inisialisasi $minusNumber dengan nilai 5
  $minusNumber = 5;

  $minusNumber -= 2;
  // $minusNumber = $minusNumber - 2

  echo $minusNumber;
  # Output: 3
?>

Multiply-Equal

Multiply-Equal bertujuan menuliskan operasi aritmatika perkalian dan menetapkan nilai pada variabel. Operator ini menggunakan simbol *=. Untuk penerapannya, mari kita perhatikan kode berikut.

<?php
  // Inisialisasi $multiplyNumber dengan nilai 5
  $multiplyNumber = 5;

  $multiplyNumber *= 2;
  // $multiplyNumber = $multiplyNumber * 2

  echo $multiplyNumber;
  # Output: 10
?>

Divide-Equal

Divide-Equal berfungsi untuk menuliskan operasi aritmatika pembagian dan menetapkan hasil operasi pada suatu variabel. Operator ini menerapkan simbol /=. Mari kita perhatikan contoh kode berikut.

<?php
  // Inisialisasi $divideNumber dengan nilai 5
  $divideNumber = 5;

  $divideNumber /= 5;
  // $divideNumber = $divideNumber / 5

  echo $divideNumber;
  # Output: 1
?>

Modulus-Equal

Modulus-Equal merupakan cara singkat penulisan operasi aritmatika modulo (sisa bagi) dan penetapan nilai hasil operasi tersebut. Operator ini menggunakan simbol %=.

Sisa bagi berbeda dengan hasil bagi. Sebagai contoh: kita melakukan operasi pembagian angka 5 dengan angka 3, hasil baginya adalah 1 dan sisa baginya adalah 2.

Agar lebih mengerti penerapannya, mari kita simak kode berikut.

<?php
  // Inisialisasi $modulusNumber dengan nilai 5
  $modulusNumber = 5;

  $modulusNumber %= 3;
  // $modulusNumber = $modulusNumber % 3

  echo $modulusNumber;
  # Output: 2
?>

Exponent-Equal

Exponent-Equal merupakan singkatan dari penulisan operasi aritmatika pemangkatan dan penetapan nilai hasil operasinya. Operator ini menggunakan simbol **=. ** memiliki fungsi yang sama dengan pangkat pada dunia Matematika. Sebagai contoh, 5 ** 3 memiliki arti yang sama dengan 5 dipangkat 3. Mari kita perhatikan contoh berikut ini.

<?php
  // Inisialisasi $expoNumber dengan nilai 5
  $expoNumber = 5;

  $expoNumber **= 3;
  // $expoNumber = $expoNumber ** 3

  echo $expoNumber;
  # Output: 125
?>

AND-Equal

AND-Equal merupakan penulisan singkat operasi bitwise AND dan penetapan hasil operasi tersebut pada suatu variabel. Operator ini ditandai dengan simbol &=.

AND-equal mencocokkan kedua bilangan biner. Apabila terdapat angka 1 pada kedua bilangan pada urutan yang sama, bitwise AND akan mengembalikan nilai 1 untuk urutan tersebut. Sebaliknya, nilai 0 akan dikembalikan. Pencocokan tersebut dilakukan untuk setiap urutan pada bilangan biner yang dibandingkan. Mari kita perhatikan contoh penerapan operator ini.

<?php
  // Inisialisasi $bitwiseAndNumber dengan bilangan desimal 6
  $bitwiseAndNumber = 6;

  $bitwiseAndNumber &= 2;
  // $bitwiseAndNumber = $bitwiseAndNumber & 2

  echo $bitwiseAndNumber; 
  # Output: 2
?>

Bilangan biner dari 6 adalah 00000110 dan bilangan biner dari 2 adalah 00000010. Dari kedua bilangan biner tersebut, terdapat angka 1 yang sama pada urutan kedua dari kanan. Hasil operasi tersebut adalah 00000010, yaitu bilangan desimal 2.

00000110
00000010
-------- &
00000010

OR-Equal

OR-Equal merupakan singkatan dalam menuliskan operasi bitwise OR dan menetapkan nilai hasil proses tersebut. Operator ini menerapkan simbol |=.

OR-equal akan mengembalikan nilai 0 jika tidak terdapat angka 1 pada urutan tertentu dari kedua bilangan biner yang diproses. Agar lebih mengerti, mari kita perhatikan contoh berikut.

<?php
  // Inisialisasi $bitwiseOrNumber dengan bilangan desimal 3
  $bitwiseOrNumber = 3;

  $bitwiseOrNumber |= 8;
  // $bitwiseOrNumber = $bitwiseOrNumber | 8

  echo $bitwiseOrNumber;
  # Output: 11
?>

Bilangan biner dari 3 adalah 00000011 dan bilangan biner dari 8 adalah 00001000. Dari kedua bilangan biner tersebut, terdapat tiga angka 1 pada urutan pertama, kedua, dan keempat dari kanan. Oleh karena itu, hasil proses bitwise OR adalah 00001011 yang kita kenal sebagai bilangan desimal 11.

00000011
00001000
-------- |
00001011

XOR-Equal

XOR-Equal merupakan penulisan singkat operasi bitwise XOR dan penetapan nilai hasil proses ke suatu variabel. Operator ini ditandai dengan simbol ^=.

XOR-equal akan mengembalikan nilai 1 jika hanya terdapat angka 1 pada salah satu bilangan biner yang dibandingkan untuk urutan yang sama. Mari kita perhatikan contoh penerapan operator ini.

<?php
  // Inisialisasi $bitwiseXorNumber dengan nilai bilangan desimal 51
  $bitwiseXorNumber = 51;

  $bitwiseXorNumber ^= 5;
  // $bitwiseXorNumber = $bitwiseXorNumber ^ 5
  
  echo $bitwiseXorNumber;
  # Output: 54
?>

Bilangan biner dari 51 adalah 00110011 dan bilangan biner dari 5 adalah 00000101. Terdapat tiga angka 1 di salah satu sisi bilangan biner, yaitu pada urutan pertama, ketiga, dan keempat dari kanan. Sehingga, hasil operasinya adalah 00110110 (bilangan desimal 54).

00110011
00000101
-------- ^
00110110

Shift-Equal

Shift-Equal merupakan singkatan dalam menulis operator Bitwise Shift dan menetapkan nilai hasil operasi tersebut pada suatu variabel, ditandai dengan <<= atau >>=. Bitwise Shift merupakan operator yang berfungsi untuk menggeser bit dari bilangan biner. Dalam pergeseran terdapat dua arah, yaitu kanan dan kiri. Begitu pula pada Bitwise Shift, terdapat Bitwise Shift Left (pergeseran ke kiri) yang ditandai dengan << dan Bitwise Shift Right (pergeseran ke kanan) yang ditandai dengan >>.

Operator Bitwise Shift memerlukan masing-masing satu nilai di kedua sisinya, nilai di sebelah kiri operator berupa bilangan biner yang akan digeser bit-nya, sedangkan nilai di sebelah kanan merupakan penentu pergeseran sejauh berapa bit. Misalnya 2 << 3, berarti angka 2 dengan bilangan biner 00000010 akan mengalami manipulasi letak sejauh 3 bit ke arah kiri, sehingga 2 << 3 akan menghasilkan bilangan biner 00010000 atau bilangan desimal 16.

Mari kita lihat contoh penerapan operator ini.

<?php
  # Shift-Left-Equal
  $desimal16 = 16;
  $desimal16 <<= 2;
  // $desimal16 = $desimal16 << 2

  echo $desimal16;
  # Output: 64
?>

Bilangan biner dari 16 adalah 00010000. Bilangan ini mendapatkan pergeseran ke kiri sejauh 2 bit dan menghasilkan angka desimal berupa 64.

00010000
-------- << 2
01000000

<?php
  # Shift-Right-Equal
  $desimal13 = 13;
  $desimal13 >>= 1;
  // $desimal13 = $desimal13 >> 1

  echo $desimal13;
  # Output: 6
?>

Bilangan biner dari 13 adalah 00001101. Bilangan ini mendapatkan pergeseran ke kanan sejauh 1 bit dan menghasilkan angka desimal berupa 6.

00001101
-------- >> 1
00000110

Altering Operator Precedence

Altering Operator Precedence merupakan salah satu operator yang paling sering digunakan, terutama saat proses perhitungan. Operator ini diwakili oleh tanda kurung lengkung ().

Fungsi dari operator ini sama persis dengan fungsi tanda kurung yang ada pada mata pelajaran Matematika, yaitu memprioritaskan bagian yang diberi tanda kurung untuk dikerjakan terlebih dahulu.

Dalam Matematika, operasi perkalian dan pembagian memiliki tingkat prioritas yang lebih utama dibandingkan dengan operasi penjumlahan dan pengurangan. Kita dapat memberikan tanda kurung jika kita ingin memproses operasi penjumlahan dan pengurangan lebih dulu. Agar lebih paham, mari kita perhatikan contoh berikut.

<?php
  $firstMathOperation = 2 * (10 + 2);

  echo $firstMathOperation;
  // Output: 24
?>

Seharusnya 2 * 10 diproses terlebih dahulu. Akan tetapi, karena kita memasukkan 10 + 2 dalam operator ini, operasi penjumlahan tersebut yang menjadi prioritas utama dalam pemrosesan.

Association

Association menyatakan kedudukan prioritas pada operasi. Misalnya, perkalian dan pembagian memiliki tingkat prioritas yang sama, sehingga perhitungan akan dimulai dari bagian paling kiri (jika tidak ada tanda kurung).

Association terdiri dari 2 jenis, yaitu left association dan right association.

Left Association

Seperti namanya, operasi memprioritaskan dari bagian paling kiri. Left association biasa terjadi karena urutan prioritas yang sama pada operator. Berikut terdapat beberapa contoh penerapannya pada operator aritmatika.

<?php
  $leftAssoc1 = 5 + 2 - 3;
  $leftAssoc2 = 4 / 2 * 5 % 2;

  echo $leftAssoc1;     // Output: 4
  echo $leftAssoc2;     // Output: 0
?>

Operator + dan - memiliki kedudukan prioritas yang sama, sehingga operasi tersebut dimulai dari kiri (+). Begitu juga dengan operator *, /, dan % memiliki kedudukan prioritas yang sama sehingga proses berlangsung dari kiri ke kanan.

Right Association

Right association merupakan kebalikan dari left association. Jika left association memulai operasi dari kiri ke kanan, right association akan memulai dari kanan ke kiri. Agar kita lebih paham, mari kita simak contoh berikut!

<?php
  $rightAssoc1 = 11 + 22 * 3;

  echo $rightAssoc1;    // Output: 77
?>

Operator + dan * memiliki kedudukan prioritas yang berbeda. Operator * memiliki kedudukan prioritas yang lebih tinggi dibanding operator +, sehingga operasi berjalan dari arah kanan ke kiri.

Mari kita lihat lagi contoh penerapannya pada kode berikut.

<?php
  $rightAssoc2 = 2;
  $rightAssoc3 = 3;
  $rightAssoc2 -= $rightAssoc3 += 10;

  echo $rightAssoc3;    // Output: 13
  echo $rightAssoc2;    // Output: -11
?>

Hasil dari penjumlahan $rightAssoc3 dengan 10 ($rightAssoc3 += 10) akan di-assign ke $rightAssoc3 terlebih dahulu. Setelah itu, proses operasi dilanjutkan pengurangan $rightAssoc2 dengan $rightAssoc3 ($rightAssoc2 += $rightAssoc3). Nilai dari proses ini nantinya akan di-assign ke variabel $rightAssoc2. Oleh karena itu, statement memanfaatkan right association karena operasi terjadi dari arah kanan ke kiri.

Bagaimana kita tahu arah association operator, mana yang memiliki prioritas lebih tinggi? Berikut tabel berupa daftar operator-operator beserta arah association-nya.

Asosiatif	Operator	Tipe Operator
non-associative	`clone`, `new`	clone and new
left	`[]`	array
right	`**`	arithmetic
right	`++`, `--`, `~`, `(int)`, `(float)`, `(string)`, `(array)`, `(object)`, `(bool)`, `@`	types and increment/decrement
left	`instanceof`	types
right	`!`	logical
left	`*`, `/`, `%`	arithmetic
left	`+`, `-`, `.`	arithmetic and string
left	`<<`, `>>`	bitwise
non-associative	`<`, `<=`, `>`, `>=`	comparison
non-associative	`==`, `!=`, `===`, `!==`, `<>`, `<=>`	comparison
left	`&`	bitwise and references
left	`^`	bitwise
left	`\|`	bitwise
left	`&&`	logical
left	`\|\|`	logical
right	`??`	null coalescing
left	`?:`	ternary
right	`=`, `+=`, `-=`, `=`, `*=`, `/=`, `.=`, `%=`, `&=`, `\|=`, `^=`, `<<=`, `>>=`	assignment
left	`and` atau `AND`	logical
left	`xor` atau `XOR`	logical
left	`or` atau `OR`	logical

Comparison Operators

Operator Pembanding (Comparison Operators) berfungsi untuk membandingkan dua nilai. Secara umum, operator-operator ini mengembalikan nilai berupa boolean, yaitu true dan false. Operator pembanding terdiri dari beberapa jenis. Penjelasan singkat mengenai jenis operator pembanding dapat dilihat melalui tabel berikut ini.

Operator	Nama	Contoh	Hasil Kembalian
`==`	Equal	`$a == $b`	Mengembalikan `true` jika nilai `$a` sama dengan nilai `$b`
`===`	Identical	`$a === $b`	Mengembalikan `true` jika nilai `$a` sama dengan nilai `$b` dan memiliki tipe data yang sama
`!=`	Not Equal	`$a != $b`	Mengembalikan `true` jika nilai `$a` tidak sama dengan nilai `$b`
`<>`	Not Equal	`$a <> $b`	Mengembalikan `true` jika nilai `$a` tidak sama dengan nilai `$b`
`!==`	Not Identical	`$a !== $b`	Mengembalikan `true` jika nilai `$a` tidak sama dengan nilai `$b` atau keduanya tidak memiliki tipe data yang sama.
`>`	Greater Than	`$a > $b`	Mengembalikan `true` jika nilai `$a` lebih besar daripada nilai `$b`
`<`	Less Than	`$a < $b`	Mengembalikan `true` jika nilai `$a` lebih kecil daripada nilai `$b`
`>=`	Greater Than or Equal To	`$a >= $b`	Mengembalikan `true` jika nilai `$a` lebih besar daripada atau sama dengan nilai `$b`
`<=`	Less Than or Equal To	`$a <= $b`	Mengembalikan `true` jika nilai `$a` lebih kecil daripada atau sama dengan nilai `$b`
`<=>`	Spaceship	`$a <=> $b`	Mengembalikan nilai berupa `-1`, `0`, dan `1` bergantung pada nilai `$a` dan nilai `$b` yang dibandingkan.

Agar kita lebih mengerti tentang operator pembanding, mari perhatikan contoh penerapannya pada kode berikut.

<?php
  $integerThreeHundreds = 300;
  $integerFiveHundreds = 500;
  $stringFiveHundreds = "500";

  // Equal
  var_dump($integerFiveHundreds == $integerThreeHundreds);  // Output: bool(false)
  var_dump($integerFiveHundreds == $stringFiveHundreds);    // Output: bool(true)

  // Identical
  var_dump($integerFiveHundreds == $integerThreeHundreds);  // Output: bool(false)
  var_dump($integerFiveHundreds === $stringFiveHundreds);   // Output: bool(false)

  // Not Equal
  var_dump($integerThreeHundreds != $integerFiveHundreds);  // Output: bool(true)
  var_dump($integerFiveHundreds != $stringFiveHundreds);    // Output: bool(false)
  var_dump($integerFiveHundreds <> $stringFiveHundreds);    // Output: bool(false)

  // Not Identical
  var_dump($integerFiveHundreds !== $stringFiveHundreds);   // Output: bool(true)
  var_dump($integerFiveHundreds !== $integerThreeHundreds); // Output: bool(true)

  // Greater Than
  var_dump($integerThreeHundreds > $integerFiveHundreds);   // Output: bool(false)

  // Less Than
  var_dump($integerThreeHundreds < $integerFiveHundreds);   // Output: bool(true)

  // Greater Than or Equal To
  var_dump($integerThreeHundreds >= $integerFiveHundreds);  // Output: bool(false)
  var_dump($integerFiveHundreds >= $integerFiveHundreds);   // Output: bool(true)
  var_dump($stringFiveHundreds >= $integerFiveHundreds);    // Output: bool(true)

  // Less Than or Equal To
  var_dump($integerThreeHundreds <= $integerFiveHundreds);  // Output: bool(true)
  var_dump($integerFiveHundreds <= $integerFiveHundreds);   // Output: bool(true)
  var_dump($stringFiveHundreds <= $integerFiveHundreds);    // Output: bool(true)
?>

<?php
  # Spaceship operator

  // Integer
  echo 1 <=> 1;                         // Output:  0
  echo 1 <=> 2;                         // Output: -1
  echo 2 <=> 1;                         // Output:  1

  // Float
  echo 1.5 <=> 1.5;                     // Output:  0
  echo 1.5 <=> 2.5;                     // Output: -1
  echo 2.5 <=> 1.5;                     // Output:  1

  // String
  echo "a" <=> "a";                     // Output:  0
  echo "a" <=> "b";                     // Output: -1
  echo "b" <=> "a";                     // Output:  1
  echo "a" <=> "aa";                    // Output: -1
  echo "zz" <=> "aa";                   // Output:  1

  // Array
  echo [] <=> [];                       // Output:  0
  echo [1, 2, 3] <=> [1, 2, 3];         // Output:  0
  echo [1, 2, 3] <=> [];                // Output:  1
  echo [1, 2, 3] <=> [1, 2, 1];         // Output:  1
  echo [1, 2, 3] <=> [1, 2, 4];         // Output: -1

  // Object
  $object1 = (object) ["a" => "b"];
  $object2 = (object) ["a" => "b"];
  $object3 = (object) ["a" => "c"];

  echo $object1 <=> $object2;           // Output:  0
  echo $object1 <=> $object3;           // Output: -1
  echo $object3 <=> $object2;           // Output:  1

  $a = (object) ["a" => "b"];
  $b = (object) ["b" => "b"];
  echo $a <=> $b;                       // Output: 1

  # Keys kedua object harus bersesuaian agar operator dapat membandingkan nilai dari keduanya. Jika tidak, operator akan membandingkan berdasarkan jumlah item objek. Jika jumlah item sama namun keys tidak bersesuaian, hasil yang dikembalikan adalah 1.
?>

instanceof

Operator instanceof dapat digunakan sejak PHP versi 5. Operator ini berfungsi untuk memeriksa apakah suatu object adalah bagian dari suatu class tertentu.

Sintaks operator instanceof
<?php
  $objectName instanceof $className;
?>
Parameter $objectName adalah object yang akan diidentifikasi. Jika variabel ini bukanlah sebuah object, instanceof selalu mengembalikan false. Jika terdapat ekspresi konstan yang digunakan, sebuah error akan ditampilkan.
Parameter $className adalah class yang akan dibandingkan. Class ini dapat diwakili oleh nama class itu sendiri, sebuah variabel string yang mengandung nama class tersebut (bukan string konstan), ataupun sebuah object dari class tersebut.

Mari kita perhatikan contoh penerapannya pada kode berikut.

<?php
  class MyFirstClass {

  }

  $firstObject = new MyFirstClass();
  $secondObject = new MyFirstClass();

  $name = "MyFirstClass";
  $notAnObject = "Not An Obj";

  var_dump($firstObject instanceof MyFirstClass);     // Output: bool(true)
  var_dump($firstObject instanceof $name);            // Output: bool(true)
  var_dump($firstObject instanceof $secondObject);    // Output: bool(true)

  var_dump(true instanceof MyFirstClass);             // Output: bool(false)
  var_dump($notAnObject instanceof MyFirstClass);     // Output: bool(false)

  // Ekspresi berupa string konstan ("MyFirstClass") tidak diizinkan.
  var_dump($firstObject instanceof "MyFirstClass");
  # Output: Parse error: syntax error, unexpected '"MyFirstClass"' (T_CONSTANT_ENCAPSED_STRING)
?>

instanceof juga dapat digunakan untuk memeriksa apakah sebuah object merupakan bagian dari class tertentu yang diturunkan dari class lainnya atau mengimplementasi beberapa interface.

<?php
  interface MyFirstInterface {

  }

  class MyFirstSuperClass implements MyFirstInterface {

  }

  class MyFirstSubClass extends MyFirstSuperClass {

  }

  $myObject = new MyFirstSubClass();
  $notObject = 1;

  var_dump($myObject instanceof MyFirstInterface);    // Output: bool(true)
  var_dump($myObject instanceof MyFirstSuperClass);   // Output: bool(true)
  var_dump($myObject instanceof MyFirstSubClass);     // Output: bool(true)
  var_dump($notObject instanceof MyFirstSubClass);    // Output: bool(false)

  // Kita juga dapat memeriksa apakah sebuah variabel bukan merupakan object dari suatu class dengan memanfaatkan operator NOT (!).
  var_dump(!($notObject instanceof MyFirstSubClass)); // Output: bool(true)
  var_dump(!$notObject instanceof MyFirstSubClass);   // Output: bool(true)
?>

Perhatikan bahwa tanda kurung di sekitar $notObject instanceof MyFirstSubClass tidak diperlukan karena instanceof memiliki precedence/prioritas yang lebih tinggi dibanding operator NOT (!). Namun, kita dapat menerapkan tanda kurung agar kode dapat terbaca dengan lebih mudah.

Dalam bahasa pemrograman PHP, terdapat satu built-in function yang memiliki fungsi yang sama juga dengan instanceof, yaitu is_a().

Sintaks function is_a()
<?php
  is_a($objectName, $className, $allowString);
?>
Parameter $objectName adalah object yang akan diidentifikasi. Jika variabel ini bukanlah sebuah object, is_a() selalu mengembalikan false.
Parameter $className adalah class yang akan dibandingkan. Class ini dapat diwakili oleh sebuah variabel string yang mengandung nama class tersebut, string konstan, maupun string literal.
Parameter $allowString adalah berupa boolean, yaitu: true atau false. Parameter ini berfungsi untuk memberikan izin perbandingan nama class dari string. Secara default, parameter ketiga ini akan bernilai false.

Berikut merupakan contoh dari penggunaan is_a().

<?php>
  class SecondClass {  

  }  

  $firstObject = new SecondClass();  
 
  if (is_a($firstObject, 'SecondClass')) {  
    echo "TRUE!";  
  }  
  // Output: TRUE!
<?>

Meskipun is_a() dan instanceof memiliki fungsi yang sama. Namun, keduanya juga memiliki beberapa perbedaan, yaitu:

Parameter kedua dari is_a() hanya bisa menerima string, sedangkan parameter kedua pada instanceof dapat diwakili oleh nama class itu sendiri, sebuah variabel string yang mengandung nama class tersebut (bukan string konstan), ataupun sebuah object dari class tersebut.
Kecepatan pemrosesan dari is_a() akan lebih lambat daripada menggunakan instanceof.
instanceof bukan merupakan sebuah function, sehingga tidak dapat menggunakan callback function, sedangkan is_a() dapat melakukan callback function karena merupakan built-in function.

Object and Class Operators

Untuk mengakses atribut/property hingga fungsi/method dari object sebuah class, kita dapat menggunakan object operator. Operator ini diwakili dengan tanda ->.

Kita juga dapat mengakses atribut/property ataupun fungsi/method langsung dari sebuah class (jika atribut yang akan diakses memang memiliki jenis akses terbuka/memanfaatkan keyword static) dengan memanfaatkan class operator, yang menggunakan tanda ::.

Mari kita simak contoh penerapan berikut ini!

<?php
  class MyClass {
    public $firstProperty = 1;

    public function firstFunction() {
      return "This is a function inside a class.";
    }

    // Karena menerapkan keyword static, property dan method ini dapat diakses tanpa perlu membentuk object dari sebuah class
    public static $firstStaticProperty = "Hi!";
    
    public static function firstStaticFunction() {
      return "This is a static function";
    }

    // Konstanta juga dapat diakses langsung layaknya menerapkan keyword static
    const INTEGER_THREE = 3;
  }

  $newObject = new MyClass();

  // Mengakses property dan method static hingga konstanta dengan class operator melalui nama class-nya langsung
  var_dump(MyClass::$firstStaticProperty);
  # Output: string(3) "Hi!"
  var_dump(MyClass::firstStaticFunction());
  # Output: string(25) "This is a static function"
  var_dump(MyClass::INTEGER_THREE);
  # Output: int(3)

  // Property secara umum diakses dengan object operator, properti diakses tanpa menggunakan tanda $
  var_dump($newObject->firstProperty);
  # Output: int(1)

  // Konstanta ataupun atribut yang telah menerapkan keyword static hanya dapat diakses dengan menggunakan class operator meski diakses melalui object class-nya
  var_dump($newObject::INTEGER_THREE);
  # Output: int(3)
  var_dump($newObject::$firstStaticProperty);
  # Output: string(3) "Hi!"

  // Fungsi atau method baik static maupun tidak, dapat diakses dengan kedua operator
  var_dump($newObject::firstFunction());
  # Output: string(34) "This is a function inside a class."
  var_dump($newObject->firstFunction());
  # Output: string(34) "This is a function inside a class."
  var_dump($newObject::firstStaticFunction());
  # Output: string(25) "This is a static function"
  var_dump($newObject->firstStaticFunction());
  # Output: string(25) "This is a static function"
?>

Kita juga dapat mereferensikan nama class dalam bentuk string. Akan tetapi, kita hanya dapat melakukan akses dengan class operator.

Simak contoh penerapan berikut ini!

<?php
  class MySecondClass {
    private $myProperty = 2;

    public function firstFunction() {
      return "This is the first function.";
    }

    public function secondFunction() {
      return "This is the second function.";
    }

    public function lastFunction() {
      return $this->myProperty;
    }
  }

  $classname = "MySecondClass";

  var_dump($classname::firstFunction());
  // Output: string(27) "This is the first function."
  var_dump($classname::secondFunction());
  // Output: string(28) "This is the second function."

  var_dump($classname::$myProperty);
  // Output: Fatal error: Uncaught Error: Cannot access private property
  var_dump($classname::lastFunction());
  // Output: Fatal error: Uncaught Error: Using $this when not in object context
?>

Terdapat error pada contoh tersebut karena kita berusaha mengakses atribut yang memiliki hak akses private dan kita juga berusaha mengakses method yang di dalamnya menerapkan keyword $this sebagai rujukan terhadap atribut dalam kelas tanpa membentuk object terlebih dahulu.

Pengayaan

Selain beberapa operator yang telah kita bahas di atas, sebenarnya masih terdapat operator aritmatika dan operator bitwise. Kedua operator ini tidak kita bahas secara terpisah, tetapi digabung dalam pembahasan combined assignment.

Pada operator bitwise secara khusus, juga terdapat operator Bitwise NOT yang ditandai dengan ~. Operator ini bertujuan untuk melakukan negasi (membalikkan) nilai bit pada suatu bilangan biner. Bit 1 akan dinegasikan menjadi 0 dan bit 0 dinegasikan menjadi 1. Misalnya, bilangan biner 00000110 akan dinegasikan sebagai 11111001. Biasanya, operator ini dikolaborasikan dengan operator bitwise lainnya. Mari kita perhatikan contoh berikut ini.

<?php
  $desimal17 = 17;    // Memiliki bilangan biner berupa 00010001
  $desimal32 = 32;    // Memiliki bilangan biner berupa 00100000

  echo(~ $desimal17 & $desimal32);
  # Output: 32

  echo(~ $desimal17 ^ ~ $desimal32);
  # Output: 49

  echo(~ $desimal17 | ~ $desimal32);
  # Output: -1
?>

~ 00010001 -> 11101110
  00100000 -> 00100000
              -------- &
              00100000
              Desimal: 32

~ 00010001 -> 11101110
~ 00100000 -> 11011111
              -------- ^
              00110001
              Desimal: 49

~ 00010001 -> 11101110
~ 00100000 -> 11011111
              -------- |
              11111111
              Desimal: 255 -> -1

Operator Bitwise menghasilkan bilangan biner yang memiliki base unsigned (memiliki rentang 0 sampai 255), sedangkan dalam PHP bilangan desimal direpresentasikan sebagai base signed (memiliki rentang -128 sampai 127). Oleh karena itu, nilai desimal 255 direpresentasikan sebagai -1 (255 - 256).

Seputar Dunia Informatika