Regla
Evitar dinámico variable dinámicas
Dinámico variables nombres (variables variables) pueden conducir
a dificultar difícil mantener código y comportamiento . 
Su uso es normalmente el resultado de un error tipográfico.

Idiomas admitidos: PHP

Introducción

La característica de variables variables de PHP permite usar el valor de una variable como el nombre de otra variable con el $$ sintaxis. Lo que parece un atajo inteligente se convierte en una pesadilla de depuración cuando no se puede determinar estáticamente qué variables existen o qué contienen. El código que utiliza $$userName en lugar de una propiedad de array u objeto hace imposible que los IDEs proporcionen autocompletado, que los analizadores estáticos detecten errores o que los desarrolladores rastreen el flujo de datos a través de la aplicación.

Por qué es importante

Mantenibilidad del código: Las variables variables rompen todas las herramientas en las que confían los desarrolladores. Los IDEs no pueden autocompletar nombres de variables, encontrar usos o refactorizar de forma segura. Las herramientas de análisis estático no pueden detectar variables no definidas o desajustes de tipo. La depuración requiere inspección en tiempo de ejecución porque no se puede hacer grep en la base de código para encontrar dónde se establecen o leen las variables.

Implicaciones de seguridad: Cuando los nombres de variables variables provienen de la entrada del usuario, los atacantes pueden sobrescribir variables arbitrarias, incluyendo las críticas para la seguridad. Un parámetro de solicitud malicioso podría apuntar a $$_GET['var'] para sobrescribir $isAdmin, $userId, o variables de sesión. Esto crea vulnerabilidades de inyección de variables que son difíciles de detectar y fáciles de explotar.

Impacto en el rendimiento: Las variables variables obligan a PHP a realizar búsquedas en tiempo de ejecución en lugar de la resolución de símbolos en tiempo de compilación. El intérprete debe evaluar el nombre de la variable dinámicamente en cada acceso, lo que impide optimizaciones que funcionan con variables normales. Los arrays y objetos proporcionan una funcionalidad similar con mejores características de rendimiento.

Ejemplos de código

❌ No conforme:

function processFormData($formType) {
    $userForm = ['name' => '', 'email' => ''];
    $adminForm = ['name' => '', 'email' => '', 'role' => ''];

    $formName = $formType . 'Form';
    $$formName = array_merge($$formName, $_POST);

    if ($$formName['email']) {
        sendEmail($$formName['email']);
    }

    return $$formName;
}

// What variable does this actually use?
processFormData('user');

Por qué es incorrecto: El código crea $userForm o $adminForm utilizando dinámicamente $$formName, lo que hace imposible rastrear qué variable se está modificando. Si $formType procede de la entrada del usuario, los atacantes podrían inyectar nombres de variables arbitrarios para sobrescribir variables críticas.

✅ Conforme:

function processFormData(string $formType): array {
    $forms = [
        'user' => ['name' => '', 'email' => ''],
        'admin' => ['name' => '', 'email' => '', 'role' => '']
    ];

    if (!isset($forms[$formType])) {
        throw new InvalidArgumentException('Invalid form type');
    }

    $form = array_merge($forms[$formType], $_POST);

    if (!empty($form['email'])) {
        sendEmail($form['email']);
    }

    return $form;
}

// Clear which data structure is being used
processFormData('user');

Por qué esto es importante: El código utiliza un array explícito con claves conocidas, lo que hace que el flujo de datos sea obvio y habilita todas las características del IDE. La validación de entrada previene ataques de inyección, y el análisis estático puede verificar que el código es correcto.

Conclusión

Reemplazar variables variables con arrays, objetos o una mejor estructura de código. Utilice arrays cuando necesite acceso dinámico por clave, objetos para datos estructurados con propiedades conocidas y refactorice la lógica duplicada en abstracciones adecuadas. Las variables variables casi siempre indican un problema de diseño que las estructuras de datos adecuadas resolverían con mayor claridad.