as

Le mot-clé PHP as

as est un mot-clé PHP petit mais polyvalent. Ce n'est pas une fonction et il n'apparaît jamais seul — il agit toujours comme un lieur qui donne un nom temporaire à quelque chose. Vous le rencontrerez dans quatre contextes distincts :

1. Dans une boucle foreach, pour lier chaque élément (et optionnellement sa clé) à une variable.
2. Dans une instruction use, pour donner à un espace de noms, une classe ou une fonction importée un alias plus court.
3. Dans un bloc use de trait, pour créer un alias ou modifier la portée d'une méthode lors de la résolution de conflits.
4. Dans list() / la déstructuration de tableau à l'intérieur d'un foreach (foreach ($rows as [$a, $b])).

Ce guide couvre chaque utilisation avec des exemples exécutables, ainsi que les pièges courants.

as dans une boucle foreach

C'est l'utilisation la plus fréquente. Dans foreach, as lie l'élément courant à une variable pour le corps de la boucle. Il existe deux formes :

<?php

// Value only
foreach ($array as $value) {
  // $value is the current element
}

// Key and value
foreach ($array as $key => $value) {
  // $key is the current key, $value is the current element
}

La variable après as est réaffectée à chaque itération ; elle n'a pas besoin d'exister au préalable.

Itérer des valeurs et des paires clé/valeur

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

Parce que les objets PHP sont également itérables, la même forme clé => valeur parcourt les propriétés publiques d'un objet :

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

Modifier des éléments avec as &$value

Placez un & avant la variable de boucle pour la lier par référence, de sorte que les modifications se propagent dans le tableau d'origine :

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

Piège : après une boucle foreach (... as &$value), $value référence toujours le dernier élément. Faites toujours unset($value) ensuite, sinon une affectation ultérieure à $value écrasera silencieusement ce dernier élément du tableau.

Déstructuration avec as [...]

Depuis PHP 7.1, vous pouvez déstructurer chaque ligne directement dans la clause as, ce qui est parfait pour les tableaux de paires ou de lignes :

<?php

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

L'ancienne syntaxe list() — foreach ($pairs as list($num, $word)) — fait la même chose. Consultez list() pour plus de détails.

as pour les alias d'espaces de noms et d'importations

Dans une instruction use, as renomme un symbole importé. Cela évite les noms longs et entièrement qualifiés et résout les conflits lorsque deux importations partagent un nom court :

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

L'aliasing fonctionne de la même façon pour les fonctions et les constantes importées (use function ... as, use const ... as). Consultez les espaces de noms PHP pour une vue d'ensemble complète.

as pour la résolution de conflits de traits

Lorsqu'une classe utilise deux traits qui définissent une méthode avec le même nom, as vous permet de créer un alias pour l'un d'eux afin que les deux restent accessibles :

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

Ici, as n'itère pas — il renomme simplement une méthode. as peut également modifier la visibilité d'une méthode, par exemple report as protected reportInternal;.

Quand utiliser lequel

Erreurs courantes

• Utiliser as en dehors des contextes ci-dessus. as n'est pas un opérateur général — $x = $y as $z; est une erreur de syntaxe.
• Oublier unset() après une boucle par référence (voir le piège ci-dessus).
• S'attendre à accéder aux propriétés privées lors de l'itération d'un objet. Seules les propriétés visibles dans la portée courante sont exposées.

Résumé

Le mot-clé as lie toujours un nom : un élément de boucle dans foreach, un alias dans une importation use ou un bloc de trait, ou une valeur déstructurée. Connaître les quatre utilisations vous permettra de lire et d'écrire du PHP idiomatique sans surprises. Pour aller plus loin, explorez les boucles PHP, foreach, les espaces de noms et les traits.

Pratique