PHP static: Static Method, Static Property, self vs static

Method atau property static milik class itu sendiri, bukan milik objek mana pun. Kamu memanggil static method dengan ClassName::method() dan membaca static property dengan ClassName::$property, tanpa membuat objek terlebih dahulu. Di dalam class, self:: merujuk ke member yang sama.

<?php
class Temperature
{
    public static int $conversions = 0;

    public static function toFahrenheit(float $c): float
    {
        self::$conversions++;
        return $c * 9 / 5 + 32;
    }
}

echo Temperature::toFahrenheit(20), "\n";
echo Temperature::toFahrenheit(37.5), "\n";
echo 'Conversions so far: ', Temperature::$conversions, "\n";

Tidak ada new Temperature() di mana pun. Member static berguna untuk fungsi pembantu yang tidak butuh state objek (konversi, factory, validasi) dan untuk data yang dimiliki class secara keseluruhan, seperti sebuah penghitung.

Static property dipakai bersama oleh semua objek

Property biasa punya satu nilai per objek. Static property punya satu nilai untuk seluruh class, jadi setiap objek melihat nilai yang sama. Di sini setiap User baru menaikkan penghitung bersama dan menerima ID berikutnya:

<?php
class User
{
    private static int $nextId = 1;
    public readonly int $id;

    public function __construct(public string $name)
    {
        $this->id = self::$nextId++;
    }

    public static function created(): int
    {
        return self::$nextId - 1;
    }
}

$a = new User('Ada');
$b = new User('Grace');
$c = new User('Linus');

echo "{$a->name} #{$a->id}, {$b->name} #{$b->id}, {$c->name} #{$c->id}\n";
echo User::created(), " users created\n";

Perhatikan tanda $ di self::$nextId: static property tetap memakainya setelah ::, sedangkan konstanta (self::MAX) tidak. Static property hanya hidup selama satu request PHP. Di website biasa (PHP-FPM atau Apache), nilainya mulai dari awal setiap kali halaman dimuat, jadi ini bukan tempat untuk menyimpan data antarpengunjung.

Static method tidak punya $this

Static method berjalan tanpa objek, jadi $this tidak ada di dalamnya. Static method bisa memanggil static method lain dengan self::, tetapi tidak bisa membaca property biasa. Memanggil method biasa secara static juga gagal:

<?php
class Slug
{
    private string $separator = '-';

    public static function make(string $text): string
    {
        $text = strtolower(trim($text));
        return trim(preg_replace('/[^a-z0-9]+/', '-', $text), '-');
    }

    public function withSeparator(string $text): string
    {
        return str_replace('-', $this->separator, self::make($text));
    }
}

echo Slug::make('  Hello, Static World! '), "\n";
echo (new Slug())->withSeparator('Objects can call static methods'), "\n";

try {
    echo Slug::withSeparator('no object here');
} catch (Error $e) {
    echo get_class($e), ': ', $e->getMessage(), "\n";
}

Arah sebaliknya tidak masalah: method biasa boleh memanggil static method, seperti yang dilakukan withSeparator() dengan self::make().

self vs static: late static binding

self:: menunjuk ke class tempat kode itu ditulis. static:: menunjuk ke class tempat method itu dipanggil saat runtime. Perbedaannya hanya terlihat pada inheritance, dan paling penting untuk factory method:

<?php
class Model
{
    public static function createWithSelf(): Model
    {
        return new self();
    }

    public static function createWithStatic(): static
    {
        return new static();
    }

    public static function table(): string
    {
        return strtolower(static::class) . 's';
    }

    public static function tableWithSelf(): string
    {
        return strtolower(self::class) . 's';
    }
}

class Post extends Model {}
class Comment extends Model {}

echo get_class(Post::createWithSelf()), "\n";    // Model
echo get_class(Post::createWithStatic()), "\n";  // Post
echo Post::table(), ', ', Comment::table(), "\n";
echo Post::tableWithSelf(), "\n";

Post::createWithSelf() mengembalikan sebuah Model, yang hampir tidak pernah diinginkan pemanggilnya. static merujuk ke Post karena itulah class yang disebut dalam pemanggilan; PHP menyebut ini late static binding. Pakai static:: dan new static() di method yang memang dimaksudkan untuk diwariskan, dan self:: kalau kamu benar-benar memaksudkan class yang persis itu. Aturan yang sama berlaku untuk konstanta: static::TABLE mengambil TABLE milik child itu sendiri, sedangkan self::TABLE selalu membaca konstanta di class tempat kode itu ditulis.

Static property warisan dipakai bersama

Child class memakai bersama static property milik parent-nya, kecuali child itu mendeklarasikan property-nya sendiri. Inilah kejutan klasik static: dua subclass menghitung ke dalam satu angka yang sama.

<?php
class Counter
{
    public static int $count = 0;

    public static function increment(): void
    {
        static::$count++;
    }
}

class Apples extends Counter {}

class Pears extends Counter
{
    public static int $count = 0;   // its own copy
}

Apples::increment();
Apples::increment();
Pears::increment();

echo 'Counter: ', Counter::$count, "\n";
echo 'Apples: ', Apples::$count, "\n";
echo 'Pears: ', Pears::$count, "\n";

Apples tidak punya $count sendiri, jadi Apples::$count adalah Counter::$count, dan keduanya mencetak 2. Pears mendeklarasikan ulang property itu dan menghitung sendiri. Static property yang dideklarasikan di sebuah trait berperilaku berbeda: setiap class yang memakai trait itu mendapat salinannya sendiri.

Variabel static di dalam fungsi

static punya arti kedua di dalam badan fungsi: variabel static menyimpan nilainya di antara pemanggilan. Nilai awalnya hanya diberikan saat fungsi pertama kali dijalankan:

<?php
function nextTicket(): string
{
    static $number = 0;
    $number++;
    return sprintf('T-%04d', $number);
}

echo nextTicket(), "\n";
echo nextTicket(), "\n";
echo nextTicket(), "\n";

// A simple cache: computed once, reused afterwards
function slowSquare(int $n): int
{
    static $cache = [];
    if (!isset($cache[$n])) {
        echo "(computing $n) ";
        $cache[$n] = $n * $n;
    }
    return $cache[$n];
}

echo slowSquare(12), "\n";
echo slowSquare(12), "\n";

slowSquare(12) yang kedua melewati perhitungannya. Seperti static property, nilai-nilai ini kembali ke awal di akhir setiap request. Halaman variabel membahas scope variabel secara umum.

Kapan static bukan pilihan yang tepat

Static method memang praktis, dan karena itu mudah dipakai berlebihan. Class yang semua method-nya membaca dan menulis static property sebenarnya adalah state global yang diberi nama class: setiap pemanggil memakainya bersama, test tidak bisa mendapat salinan baru, dan kamu tidak bisa menggantinya dengan implementasi lain.

<?php
// Static: one shared cart for the whole program
class StaticCart
{
    private static array $items = [];

    public static function add(string $item): void { self::$items[] = $item; }
    public static function items(): array { return self::$items; }
}

// Object: each cart is separate
class Cart
{
    private array $items = [];

    public function add(string $item): void { $this->items[] = $item; }
    public function items(): array { return $this->items; }
}

StaticCart::add('book');
StaticCart::add('pen');     // a "second customer" adds to the same cart
print_r(StaticCart::items());

$ada = new Cart();
$linus = new Cart();
$ada->add('book');
$linus->add('pen');
print_r($ada->items());
print_r($linus->items());

Pemakaian static yang baik: fungsi pembantu murni tanpa state (Slug::make()), named constructor (Color::fromHex()), dan konstanta untuk seluruh class. Kalau sebuah method butuh data yang bisa berbeda di antara dua pemakaian, method itu butuh objek.