static

Das PHP-Schlüsselwort static

Das Schlüsselwort static in PHP hat zwei unterschiedliche Verwendungszwecke, und es hilft, diese von Anfang an auseinanderzuhalten:

1. Klassenmember — static markiert eine Eigenschaft oder Methode als zur Klasse selbst gehörend, nicht zu einem einzelnen Objekt. Sie greifen darauf zu, ohne eine Instanz zu erstellen, und alle Instanzen teilen denselben Wert.
2. Statische lokale Variablen — innerhalb einer Funktion bewirkt static, dass eine lokale Variable ihren Wert zwischen Aufrufen beibehält, anstatt jedes Mal zurückgesetzt zu werden.

Dieses Kapitel behandelt beide Verwendungen sowie die verwandten Schlüsselwörter self, static:: und parent::, denen Sie fast immer neben statischen Membern begegnen. Wenn Klassen und Objekte neu für Sie sind, lesen Sie zuerst Klassen und Objekte.

Statische Klassenmember

Eine normale Eigenschaft existiert auf jedem Objekt. Eine statische Eigenschaft existiert auf der Klasse — es gibt genau eine Kopie, die von jeder Instanz geteilt wird und auch dann zugänglich ist, wenn keine Instanz vorhanden ist.

Grundlegende Syntax

<?php

class MyClass {
  public static $myProperty = "Hello, world!";

  public static function myMethod() {
    return self::$myProperty;
  }
}

Sie lesen ein statisches Member mit dem Bereichsauflösungsoperator ::, nicht mit dem Objektoperator ->:

<?php

echo MyClass::$myProperty;   // Hello, world!
echo MyClass::myMethod();    // Hello, world!

Innerhalb der Klasse verweisen Sie auf Ihre eigenen statischen Member mit self:: (oder static::, unten erklärt) — niemals $this, da eine statische Methode möglicherweise ohne Objekt ausgeführt wird.

Für tiefergehende Informationen siehe Statische Eigenschaften und Statische Methoden.

Statische lokale Variablen

Dasselbe Schlüsselwort tut innerhalb einer Funktion etwas völlig anderes: Es lässt eine Variable über Aufrufe hinweg bestehen. Ohne static wird eine lokale Variable bei jedem Aufruf neu initialisiert; mit static wird der Anfangswert einmal gesetzt und die Variable behält den zuletzt gehaltenen Wert.

<?php

function counter() {
  static $count = 0;   // initialised only on the first call
  $count++;
  return $count;
}

echo counter(); // 1
echo counter(); // 2
echo counter(); // 3

Dies ist praktisch zum Zwischenspeichern eines aufwendigen Ergebnisses oder zum Zählen, wie oft eine Funktion ausgeführt wurde, ohne eine globale Variable einzuführen.

Beispiele

Schauen wir uns einige praktische Beispiele statischer Klassenmember an:

Beispiele für das PHP-Schlüsselwort static

<?php

// Example 1
class Counter
{
  public static $count = 0;

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

Counter::increment();
Counter::increment();
echo Counter::$count . PHP_EOL;

// Example 2
class User
{
  public static $name;

  public static function setName($name)
  {
    self::$name = $name;
  }
}

User::setName("John Doe");
echo User::$name;

In Counter wird die statische Eigenschaft $count geteilt, sodass zwei Aufrufe von increment() auf 2 akkumulieren. In User speichert setName() Daten auf der Klasse selbst statt auf einem Objekt.

self vs. static (späte statische Bindung)

Wenn Sie von innerhalb einer Methode auf ein statisches Member verweisen, haben Sie zwei Optionen, und der Unterschied ist bei Vererbung wichtig:

• self:: wird zur Compile-Zeit aufgelöst — es zeigt immer auf die Klasse, in der der Code geschrieben wurde.
• static:: verwendet späte statische Bindung — es wird zur Laufzeit auf die tatsächlich aufgerufene Klasse aufgelöst.

<?php

class Base {
  public static function create() {
    return new static();   // runtime class
  }
  public static function createSelf() {
    return new self();     // always Base
  }
}

class Child extends Base {}

echo get_class(Child::create());     // Child
echo "\n";
echo get_class(Child::createSelf()); // Base

Verwenden Sie static::, wenn eine Unterklasse in der Lage sein soll, das Verhalten zu überschreiben oder die instantiierte Klasse zu sein — das obige Muster ist das Rückgrat von Factory-Methoden. Verwenden Sie self::, wenn Sie speziell diese Klasse meinen. Um die statische Methode einer Elternklasse aufzurufen, verwenden Sie parent::. Siehe Vererbung für das umfassendere Bild.

Häufige Anwendungsfälle

• Zähler und gemeinsamer Zustand — ein einzelner Wert, der über alle Instanzen verfolgt wird, wie der obige Counter.
• Hilfs-/Utility-Methoden — zustandslose Funktionen, die unter einer Klasse gruppiert sind, z. B. Math::clamp(), ohne Objekt aufgerufen.
• Factory-Methoden — User::fromArray($data) gibt eine konfigurierte Instanz zurück; new static() hält sie unterklassenfreundlich.
• Singletons und einfache Caches — eine statische Eigenschaft hält die einzelne Instanz oder ein gespeichertes Ergebnis.

Für benannte, unveränderliche gemeinsame Werte bevorzugen Sie eine Klassenkonstante gegenüber einer statischen Eigenschaft.

Fallstricke

• Kein $this in statischen Methoden. Eine statische Methode kann ohne Objekt aufgerufen werden, daher ist $this dort undefiniert. Das Zugreifen auf Instanzzustand aus einer statischen Methode ist ein Design-Geruch.
• Statische Eigenschaften sind quasi-globaler gemeinsamer Zustand. Da jede Instanz die eine Kopie teilt, beeinflusst deren Änderung von irgendwo alle — leicht verborgene Kopplung einzuführen und die Testisolation zu brechen. Verwenden Sie sie bewusst.
• :: für statisch, -> für Instanzen. MyClass::$prop (statisch) vs. $obj->prop (Instanz). Beachten Sie, dass $ beim statischen Zugriff beim Eigenschaftsnamen bleibt: Counter::$count, nicht Counter::count.
• Statische lokale Variablen gelten pro Funktion, nicht pro Aufruf. Zwei rekursive Aufrufe teilen dieselbe static-Variable, was gelegentlich überraschend ist.

Fazit

Das Schlüsselwort static erfüllt zwei Aufgaben: Es definiert Eigenschaften und Methoden auf Klassenebene, die über alle Instanzen geteilt werden und ohne Objekt erreichbar sind, und es lässt die lokale Variable einer Funktion zwischen Aufrufen bestehen. Kombinieren Sie es mit self::, static:: und parent::, um genau zu steuern, auf welche Klasse Ihre statischen Aufrufe aufgelöst werden. Verwenden Sie statische Member für wirklich gemeinsamen Zustand und zustandslose Hilfsfunktionen — behandeln Sie gemeinsam veränderliche statische Daten jedoch mit derselben Vorsicht wie eine globale Variable.

Übungen