extract()

¿Qué es extract() en PHP?

extract() es una función integrada de PHP que importa los elementos de un array asociativo en la tabla de símbolos actual, convirtiendo cada clave en una variable cuyo valor es el elemento del array correspondiente. Es el inverso de compact(), que construye un array a partir de variables existentes.

Su firma es:

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

• $array — el array fuente. Solo las claves string que sean nombres de variables PHP válidos se convierten en variables. Las claves numéricas se omiten a menos que uses un flag de prefijo.
• $flags — controla cómo se manejan las colisiones de nombres con variables existentes (ver Flags y comportamiento).
• $prefix — una cadena que se antepone a los nombres de variable cuando se usa un flag de prefijo.

Devuelve el número de variables importadas correctamente.

Cómo usar extract() en PHP

Comienza con un array asociativo cuyas claves sean los nombres de variable que deseas:

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

extract($person);

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

Después de extract($person), tres variables — $name, $age y $email — existen en el ámbito actual, cada una con el valor de la clave correspondiente.

Extraer solo algunas claves

Por defecto, extract() crea variables para cada clave. Para importar un subconjunto, filtra el array primero con array_intersect_key() y 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) transforma ['name', 'email'] en ['name' => 0, 'email' => 1], y array_intersect_key() conserva solo esas claves de $person, por lo que únicamente se extraen $name y $email.

Flags y comportamiento

El segundo parámetro controla cómo se manejan las variables existentes cuando una clave colisiona con una variable que ya existe. Los flags más comunes son:

Compara EXTR_OVERWRITE (el comportamiento por defecto) con 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

Usa EXTR_PREFIX_ALL para agregar un espacio de nombres a cada variable y evitar colisiones por completo:

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

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

Advertencia de seguridad

Dado que extract() crea variables dinámicamente a partir de claves, alimentarla con datos no confiables puede sobreescribir variables existentes, incluidas las críticas o los superglobales como $_GET, $_POST y $_SESSION. Una vulnerabilidad clásica es extract($_GET), que permite a un atacante establecer cualquier variable del script a través de la cadena de consulta:

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

Nunca llames a extract() directamente sobre datos de solicitud. Cuando sea necesario, pasa EXTR_SKIP para que las variables existentes no puedan ser sobreescritas, o filtra las claves con array_intersect_key() como se mostró anteriormente.

Cuándo usar extract()

extract() brilla en situaciones limitadas y controladas:

• Renderizado de plantillas — un motor de vistas extrae un array de datos conocidos en variables locales justo antes de incluir una plantilla, para que esta pueda escribir $title en vez de $data['title'].
• Desempaquetado de configuración — convertir un array de configuración pequeño y confiable en variables con nombre al inicio de un script.

Para la mayoría del código, la asignación explícita es más clara y segura que extract(), porque un lector puede ver exactamente qué variables entran en el ámbito. Úsalo solo cuando las claves son confiables y la ganancia en legibilidad es real.

Resumen

extract() importa las claves de un array asociativo como variables en el ámbito actual y devuelve cuántas creó. Su comportamiento por defecto EXTR_OVERWRITE lo hace potente pero arriesgado: siempre filtra o usa EXTR_SKIP con entradas no confiables. Para hacer lo contrario — construir un array a partir de variables — usa compact().

Práctica