as

Das PHP-Schlüsselwort as

as ist ein kleines, aber vielseitiges PHP-Schlüsselwort. Es ist keine Funktion und tritt nie allein auf – es dient stets als Binder, der etwas vorübergehend benennt. Es begegnet Ihnen an vier verschiedenen Stellen:

1. In einer foreach-Schleife, um jedes Element (und optional seinen Schlüssel) an eine Variable zu binden.
2. In einer use-Anweisung, um einem importierten Namespace, einer Klasse oder einer Funktion einen kürzeren Alias zu geben.
3. In einem Trait-use-Block, um eine Methode bei der Konfliktlösung zu aliasieren oder ihren Gültigkeitsbereich zu ändern.
4. In list() / array-Destrukturierung innerhalb eines foreach (foreach ($rows as [$a, $b])).

Dieser Leitfaden behandelt jeden Anwendungsfall mit ausführbaren Beispielen sowie häufige Fallstricke.

as in einer foreach-Schleife

Dies ist der am häufigsten vorkommende Anwendungsfall. Innerhalb von foreach bindet as das aktuelle Element an eine Variable für den Schleifenkörper. Es gibt zwei Formen:

<?php

// Nur Wert
foreach ($array as $value) {
  // $value ist das aktuelle Element
}

// Schlüssel und Wert
foreach ($array as $key => $value) {
  // $key ist der aktuelle Schlüssel, $value ist das aktuelle Element
}

Die Variable nach as wird bei jeder Iteration neu zugewiesen; sie muss vorher nicht existieren.

Werte und Schlüssel/Wert-Paare iterieren

<?php

// Indexed array — value only
$names = ["John", "Doe"];
foreach ($names as $name) {
  echo $name . "\n";
}
// John
// Doe

// Associative array — key => value
$person = ["name" => "John", "age" => 30];
foreach ($person as $property => $value) {
  echo "$property: $value\n";
}
// name: John
// age: 30

Da PHP-Objekte ebenfalls iterierbar sind, durchläuft dieselbe key => value-Form die öffentlichen Eigenschaften eines Objekts:

<?php

class Person {
  public $name = "John";
  public $age = 30;
  private $secret = "hidden"; // not visible from outside
}

foreach (new Person() as $property => $value) {
  echo "$property: $value\n";
}
// name: John
// age: 30

Elemente mit as &$value modifizieren

Platzieren Sie ein & vor die Schleifenvariable, um sie per Referenz zu binden, sodass Änderungen in das ursprüngliche array zurückpropagiert werden:

<?php

$nums = [1, 2, 3];
foreach ($nums as &$n) {
  $n *= 2;
}
unset($n); // important — see gotcha below

print_r($nums);
// Array ( [0] => 2 [1] => 4 [2] => 6 )

Fallstrick: Nach einer foreach (... as &$value)-Schleife referenziert $value immer noch das letzte Element. Führen Sie danach immer unset($value) aus, da eine spätere Zuweisung an $value sonst dieses letzte array-Element stillschweigend überschreibt.

Destrukturierung mit as [...]

Seit PHP 7.1 können Sie jede Zeile direkt in der as-Klausel destrukturieren, was sich ideal für arrays von Paaren oder Zeilen eignet:

<?php

$pairs = [[1, "one"], [2, "two"]];
foreach ($pairs as [$num, $word]) {
  echo "$num => $word\n";
}
// 1 => one
// 2 => two

Die ältere list()-Syntax – foreach ($pairs as list($num, $word)) – tut dasselbe. Siehe list() für Details.

as für Namespace- und Import-Aliase

In einer use-Anweisung benennt as ein importiertes Symbol um. Dadurch werden lange vollqualifizierte Namen vermieden und Konflikte gelöst, wenn zwei Imports denselben Kurznamen haben:

<?php

use App\Models\User as UserModel;
use Acme\Auth\User as AuthUser;

// Both "User" classes are now usable without collision:
$a = new UserModel();
$b = new AuthUser();

Aliasierung funktioniert auf die gleiche Weise für importierte Funktionen und Konstanten (use function ... as, use const ... as). Siehe PHP-Namespaces für das vollständige Bild.

as zur Trait-Konfliktlösung

Wenn eine Klasse zwei Traits verwendet, die eine Methode mit demselben Namen definieren, können Sie mit as einen davon aliasieren, sodass beide erreichbar bleiben:

<?php

trait Logger     { public function report() { return "log"; } }
trait Notifier   { public function report() { return "notify"; } }

class Service {
  use Logger, Notifier {
    Logger::report insteadof Notifier; // pick Logger's report()
    Notifier::report as notify;        // keep Notifier's under a new name
  }
}

$s = new Service();
echo $s->report() . "\n"; // log
echo $s->notify() . "\n"; // notify

Hier iteriert as nichts – es benennt lediglich eine Methode um. as kann auch die Sichtbarkeit einer Methode ändern, z. B. report as protected reportInternal;.

Wann welches verwenden

Häufige Fehler

• as außerhalb der oben genannten Kontexte verwenden. as ist kein allgemeiner Operator – $x = $y as $z; ist ein Syntaxfehler.
• unset() nach einer Referenzschleife vergessen (siehe den Fallstrick oben).
• Private Eigenschaften beim Iterieren eines Objekts erwarten. Nur Eigenschaften, die im aktuellen Gültigkeitsbereich sichtbar sind, werden zugänglich.

Zusammenfassung

Das Schlüsselwort as bindet immer einen Namen: ein Schleifen-Element in foreach, einen Alias in einem use-Import oder Trait-Block oder einen destrukturierten Wert. Wenn Sie alle vier Verwendungen kennen, können Sie idiomatisches PHP lesen und schreiben, ohne überrascht zu werden. Für eine tiefere Beschäftigung erkunden Sie PHP-Schleifen, foreach, Namespaces und Traits.

Übungen