Class dan Objek PHP: Property, Method, dan $this

Class PHP dideklarasikan dengan class Name { ... } dan berisi property (variabel) dan method (fungsi). new Name() membuat objek dari class itu, dan -> membaca property atau memanggil method: $user->name, $user->greet().

<?php
class User
{
    public string $name = 'Guest';

    public function greet(): string
    {
        return "Hello, {$this->name}";
    }
}

$user = new User();
echo $user->greet(), "\n";

$user->name = 'Ada';
echo $user->greet(), "\n";

Class adalah cetak birunya, objek adalah satu benda yang dibuat dari cetak biru itu. Kamu bisa membuat objek sebanyak yang kamu butuhkan dari satu class, dan setiap objek punya nilai property-nya sendiri.

Property dan method

Property dideklarasikan dengan kata kunci visibilitas, tipe (opsional), dan nilai bawaan (opsional). Method adalah fungsi di dalam class. Di dalam method, $this adalah objek tempat method itu dipanggil, jadi $this->balance membaca saldo milik objek tersebut.

<?php
class Account
{
    public string $owner = '';
    public float $balance = 0;

    public function deposit(float $amount): void
    {
        $this->balance += $amount;
    }

    public function summary(): string
    {
        return sprintf('%s has %.2f', $this->owner, $this->balance);
    }
}

$a = new Account();
$a->owner = 'Ada';
$a->deposit(50);
$a->deposit(25.5);

$b = new Account();
$b->owner = 'Linus';
$b->deposit(10);

echo $a->summary(), "\n";
echo $b->summary(), "\n";

Setiap objek menyimpan $balance-nya sendiri: menyetor ke $a tidak menyentuh $b. Mengisi property satu per satu setelah new lama-lama merepotkan; constructor menerima nilai awalnya sebagai argumen.

public, private, dan protected

Visibilitas mengatur siapa yang boleh menyentuh property atau memanggil method:

Membuat property menjadi private lalu menyediakan method adalah cara sebuah class melindungi aturannya sendiri. Di sini saldo hanya bisa berubah lewat deposit() dan withdraw(), yang menolak jumlah yang tidak valid:

<?php
class Wallet
{
    private int $cents = 0;

    public function deposit(int $cents): void
    {
        if ($cents <= 0) {
            throw new InvalidArgumentException('Deposit must be positive');
        }
        $this->cents += $cents;
    }

    public function withdraw(int $cents): bool
    {
        if ($cents > $this->cents) {
            return false;
        }
        $this->cents -= $cents;
        return true;
    }

    public function balance(): int
    {
        return $this->cents;
    }
}

$w = new Wallet();
$w->deposit(500);
var_dump($w->withdraw(800));
var_dump($w->withdraw(200));
echo $w->balance(), "\n";

Membaca property private dari luar class bukan sekadar warning, melainkan Error:

<?php
// This throws an Error on purpose: $cents is private
class Wallet
{
    private int $cents = 500;
}

$w = new Wallet();
echo $w->cents;

Property bertipe dan nilai yang belum diinisialisasi

Property bertipe tanpa nilai bawaan dimulai dalam keadaan belum diinisialisasi (uninitialized), yang berbeda dari null. Membacanya sebelum diisi apa pun akan melempar Error. Beri nilai bawaan, isi di constructor, atau buat nullable dengan ?Type dan = null.

<?php
class Product
{
    public string $name;           // no default: uninitialized
    public ?string $sku = null;    // nullable with a default
    public int $stock = 0;
}

$p = new Product();
var_dump($p->sku, $p->stock);

try {
    echo $p->name;
} catch (Error $e) {
    echo $e->getMessage(), "\n";
}

$p->name = 'Keyboard';
echo $p->name, "\n";

Tipe ditegakkan saat pengisian. Dengan mode bawaan (non-strict), $p->stock = '7' mengonversi string numerik itu menjadi 7, sedangkan $p->stock = 'many' melempar TypeError.

Property readonly

Property readonly (PHP 8.1) bisa ditulis satu kali, dari dalam class, lalu tidak bisa ditulis lagi. Ini cara yang biasa untuk membuat value object seperti jumlah uang atau ID. PHP 8.2 menambahkan readonly class, yang membuat setiap property menjadi readonly.

<?php
class Order
{
    public readonly string $id;

    public function __construct(string $id)
    {
        $this->id = $id;
    }
}

$order = new Order('A-1001');
echo $order->id, "\n";

try {
    $order->id = 'B-2002';
} catch (Error $e) {
    echo $e->getMessage(), "\n";
}

Property readonly wajib punya tipe, dan tidak boleh punya nilai bawaan. Kalau kamu butuh salinan yang sudah diubah, buat objek baru (new Order('B-2002')) alih-alih mengedit yang lama.

Mencetak objek dengan __toString

echo $object hanya bekerja kalau class-nya mendefinisikan __toString(). Method ini mengembalikan string yang dipakai PHP setiap kali objek diperlakukan sebagai teks: di echo, dalam penggabungan string, di "{$object}".

<?php
class Money
{
    public function __construct(
        private int $cents,
        private string $currency = 'EUR',
    ) {}

    public function __toString(): string
    {
        return number_format($this->cents / 100, 2) . ' ' . $this->currency;
    }
}

$price = new Money(129900);
echo $price, "\n";
echo 'Total: ' . $price . "\n";
echo "Shipping: " . new Money(450, 'USD') . "\n";

// For debugging, print_r and var_dump show the properties
print_r(new Money(5));

Tanpa __toString, echo $object melempar Error ("Object of class Money could not be converted to string"). Untuk debugging, print_r() dan var_dump() bisa dipakai pada objek apa pun dan juga menampilkan property private; lihat var_dump dan print_r.

Menyimpan objek ke variabel lain tidak menyalinnya

Inilah kesalahan yang paling sering menjebak orang yang terbiasa dengan array. Menyimpan array ke variabel lain akan menyalinnya. Menyimpan objek hanya menyalin penunjuknya: kedua variabel lalu menunjuk ke objek yang sama.

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

$a = new Point();
$b = $a;          // same object
$b->x = 10;
echo "a->x = {$a->x}\n";

$c = clone $a;    // independent copy
$c->x = 99;
echo "a->x = {$a->x}, c->x = {$c->x}\n";

var_dump($a === $b, $a === $c, $a == $c);
var_dump($a instanceof Point);
echo get_class($c), "\n";

clone membuat salinan dangkal: kalau sebuah property berisi objek lain, kedua salinan tetap berbagi objek di dalamnya itu. === bernilai true hanya untuk objek yang sama, sedangkan == membandingkan nilai property dari dua objek dengan class yang sama. Mengirim objek ke fungsi bekerja sama seperti pengisian variabel, jadi sebuah fungsi bisa mengubah objek yang diterimanya.