extract()

Qu'est-ce que extract() en PHP ?

extract() est une fonction PHP intégrée qui importe les éléments d'un array associatif dans la table des symboles courante — en transformant chaque clé en variable dont la valeur correspond à l'élément de l'array. Elle est l'inverse de compact(), qui construit un array à partir de variables existantes.

Sa signature est :

extract(array &$array, int $flags = EXTR_OVERWRITE, string $prefix = ""): int

• $array — l'array source. Seules les clés string qui sont des noms de variables PHP valides deviennent des variables. Les clés numériques sont ignorées, sauf si vous utilisez un flag de préfixe.
• $flags — contrôle la gestion des collisions de noms avec des variables existantes (voir Flags et comportement).
• $prefix — une chaîne ajoutée en préfixe aux noms de variables lorsqu'un flag de préfixe est utilisé.

Elle retourne le nombre de variables importées avec succès.

Comment utiliser extract() en PHP

Commencez avec un array associatif dont les clés sont les noms de variables souhaités :

$person = [
    'name'  => 'John Doe',
    'age'   => 30,
    'email' => '[email protected]',
];

extract($person);

echo $name;   // John Doe
echo $age;    // 30
echo $email;  // [email protected]

Après extract($person), trois variables — $name, $age et $email — existent dans la portée courante, chacune contenant la valeur de la clé correspondante.

Extraire uniquement certaines clés

Par défaut, extract() crée des variables pour chaque clé. Pour n'importer qu'un sous-ensemble, filtrez d'abord l'array avec array_intersect_key() et array_flip() :

$wanted = ['name', 'email'];
$count = extract(array_intersect_key($person, array_flip($wanted)));

echo $count;  // 2
echo $name;   // John Doe
echo $email;  // [email protected]
// $age is NOT created

array_flip($wanted) transforme ['name', 'email'] en ['name' => 0, 'email' => 1], et array_intersect_key() ne conserve que ces clés de $person, de sorte que seuls $name et $email sont extraits.

Flags et comportement

Le deuxième paramètre contrôle la façon dont les variables existantes sont gérées quand une clé entre en collision avec une variable déjà présente. Les flags les plus courants sont :

Comparaison de EXTR_OVERWRITE (par défaut) avec EXTR_SKIP :

$name = 'Existing Name';
$data = ['name' => 'New Name'];

extract($data);             // default: overwrites
echo $name;                 // New Name

$name = 'Existing Name';
extract($data, EXTR_SKIP);  // keep what's already set
echo $name;                 // Existing Name

Utilisez EXTR_PREFIX_ALL pour préfixer toutes les variables et éviter entièrement les collisions :

$data = ['name' => 'John', 'age' => 30];
extract($data, EXTR_PREFIX_ALL, 'user');

echo $user_name;  // John
echo $user_age;   // 30

Avertissement de sécurité

Parce que extract() crée des variables dynamiquement à partir des clés, lui fournir des données non fiables peut écraser des variables existantes — y compris des variables critiques ou des superglobales telles que $_GET, $_POST et $_SESSION. Une vulnérabilité classique est extract($_GET), qui permet à un attaquant de définir n'importe quelle variable dans votre script via la chaîne de requête :

$is_admin = false;
extract($_GET);          // ?is_admin=1 now makes $is_admin truthy — dangerous!

N'appelez jamais extract() directement sur des données de requête. Si vous le devez, passez EXTR_SKIP pour que les variables existantes ne puissent pas être écrasées, ou mettez les clés sur liste blanche avec array_intersect_key() comme indiqué ci-dessus.

Quand utiliser extract()

extract() est particulièrement utile dans des situations étroites et contrôlées :

• Rendu de templates — un moteur de vues extrait un array de données connu dans des variables locales juste avant d'inclure un template, afin que le template puisse écrire $title au lieu de $data['title'].
• Décompression de configuration — transformer un petit array de configuration fiable en variables nommées au début d'un script.

Pour la plupart du code, l'affectation explicite est plus claire et plus sûre que extract(), car le lecteur peut voir exactement quelles variables entrent dans la portée. N'y recourez que lorsque les clés sont fiables et que le gain de lisibilité est réel.

Résumé

extract() importe les clés d'un array associatif comme variables dans la portée courante et retourne le nombre de variables créées. Son comportement par défaut EXTR_OVERWRITE le rend puissant mais risqué : filtrez toujours ou utilisez EXTR_SKIP avec des entrées non fiables. Pour aller dans l'autre sens — construire un array à partir de variables — utilisez compact().

Pratique