PHP static: Statik Metotlar, Özellikler ve self ile static

Bir static metot veya özellik herhangi bir nesneye değil sınıfın kendisine aittir. Statik bir metodu ClassName::method() ile çağırır ve statik bir özelliği ClassName::$property ile okursunuz; önce bir nesne oluşturmanız gerekmez. Sınıfın içinde self:: aynı üyelere başvurur.

<?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";

Hiçbir yerde new Temperature() yoktur. Statik üyeler nesne durumuna ihtiyaç duymayan yardımcılar (dönüştürmeler, fabrikalar, doğrulama) ve bir sayaç gibi bütün olarak sınıfa ait veriler için kullanışlıdır.

Statik özellikler tüm nesneler tarafından paylaşılır

Normal bir özelliğin nesne başına bir değeri vardır. Statik bir özelliğin tüm sınıf için tek bir değeri vardır, bu yüzden her nesne aynısını görür. Burada her yeni User paylaşılan bir sayacı artırır ve bir sonraki ID'yi alır:

<?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";

self::$nextId içindeki $ işaretine dikkat edin: statik özellikler :: sonrasında onu korur, sabitler (self::MAX) ise korumaz. Statik bir özellik yalnızca bir PHP isteği boyunca yaşar. Tipik bir web sitesinde (PHP-FPM veya Apache) her sayfa yüklemesinde baştan başlar, bu yüzden ziyaretçiler arasında veri saklama yeri değildir.

Statik metotlarda $this yoktur

Statik bir metot nesne olmadan çalışır, bu yüzden içinde $this yoktur. Statik bir metot diğer statik metotları self:: ile çağırabilir, ama normal özellikleri okuyamaz. Normal bir metodu statik olarak çağırmak da başarısız olur:

<?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";
}

Ters yön sorun değildir: withSeparator() metodunun self::make() ile yaptığı gibi normal bir metot statik metotları çağırabilir.

self ile static: geç statik bağlama

self:: kodun yazıldığı sınıfı gösterir. static:: çalışma zamanında metodun üzerinde çağrıldığı sınıfı gösterir. Fark yalnızca kalıtımla ortaya çıkar ve en çok fabrika metotlarında önemlidir:

<?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() bir Model döndürür; çağıranın istediği bu neredeyse hiçbir zaman değildir. static Post olarak çözümlenir, çünkü çağrıda adı geçen sınıf odur; PHP buna geç statik bağlama der. Kalıtılması amaçlanan metotlarda static:: ve new static(), gerçekten tam bu sınıfı kastettiğinizde self:: kullanın. Aynı kural sabitler için de geçerlidir: static::TABLE bir alt sınıfın kendi TABLE sabitini alır, self::TABLE ise her zaman kodun yazıldığı sınıftakini okur.

Kalıtılan statik özellikler paylaşılır

Bir alt sınıf, kendi statik özelliğini tanımlamadıkça üst sınıfınınkini paylaşır. Bu klasik statik sürprizidir: iki alt sınıf aynı sayıya sayar.

<?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 sınıfının kendi $count özelliği yoktur, bu yüzden Apples::$count Counter::$count olur ve ikisi de 2 yazdırır. Pears özelliği yeniden tanımlar ve kendi başına sayar. Bir trait içinde tanımlanan statik bir özellik farklı davranır: trait'i kullanan her sınıf ayrı bir kopya alır.

Fonksiyon içindeki statik değişkenler

static bir fonksiyon gövdesinin içinde ikinci bir anlama sahiptir: statik bir değişken değerini çağrılar arasında korur. Başlangıç değeri yalnızca fonksiyon ilk çalıştığında atanır:

<?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";

İkinci slowSquare(12) hesaplamayı atlar. Statik özellikler gibi bu değerler de her isteğin sonunda sıfırlanır. Değişkenler sayfası genel olarak değişken kapsamını anlatır.

static ne zaman yanlış seçimdir

Statik metotlar kullanışlıdır ve bu da onları aşırı kullanmayı kolaylaştırır. Tüm metotları statik özellikleri okuyup yazan bir sınıf, üzerinde bir sınıf adı olan global durumdur: her çağıran onu paylaşır, testler taze bir kopya alamaz ve farklı bir uygulamayı yerine koyamazsınız.

<?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());

static için iyi kullanımlar: durumu olmayan saf yardımcılar (Slug::make()), adlandırılmış yapıcılar (Color::fromHex()) ve sınıf genelindeki sabitler. Bir metot iki kullanım arasında farklı olabilecek verilere ihtiyaç duyuyorsa bir nesne ister.