Por qué deberías usar argumentos con nombre en Python y PHP

Regla
Usar argumentos con nombre para mayor claridad
Los argumentos con nombre hacen que el código se autodocumente 
y previenen errores en el orden de los parámetros.
Utilice argumentos con nombre cuando las funciones tengan más
de 2-3 parámetros o indicadores booleanos.

Lenguajes soportados: Python, PHP

Introducción

Las funciones con múltiples parámetros se vuelven poco claras cuando se ve el sitio de llamada. Leer sendEmail('user@example.com', true, false, 30) requiere buscar la firma de la función para entender qué true, falso, y 30 significado. Los argumentos con nombre resuelven esto haciendo explícito el propósito de cada parámetro en el punto de llamada. También evitan errores por la reordenación de parámetros cuando las firmas de las funciones cambian.

Por qué es importante

Mantenibilidad del código: Los argumentos con nombre documentan la intención en el punto de llamada sin requerir una comprobación constante de referencias. Cuando ves sendEmail(to: $email, retry: true, async: false, timeout: 30), se entiende exactamente qué controla cada valor. Esto elimina la confusión durante la revisión de código y acelera la depuración, ya que no es necesario mapear mentalmente los argumentos posicionales a los nombres de los parámetros.

Implicaciones de seguridad: Errores en el orden de los parámetros en funciones críticas para la seguridad pueden crear vulnerabilidades. Intercambiar el $username y $password parámetros, o pasar accidentalmente la contraseña en texto plano donde debería ir la contraseña hash, falla silenciosamente con argumentos posicionales. Los argumentos con nombre le obligan a indicar explícitamente qué valor va dónde, evitando estos errores peligrosos.

Seguridad en el refactoring: Añadir parámetros opcionales a funciones existentes rompe todos los puntos de llamada con argumentos posicionales a menos que se añadan al final. Los argumentos con nombre permiten añadir, reordenar o cambiar parámetros sin romper el código existente, siempre que los nombres de los parámetros se mantengan consistentes. Esto hace que las API sean más estables y la evolución menos arriesgada.

Ejemplos de código

❌ No conforme:

function createUser($email, $password, $role, $verified, $sendEmail, $retryCount) {
    $hashedPassword = password_hash($password, PASSWORD_BCRYPT);

    $user = User::create([
        'email' => $email,
        'password' => $hashedPassword,
        'role' => $role,
        'verified' => $verified
    ]);

    if ($sendEmail) {
        sendWelcomeEmail($user->email, $retryCount);
    }

    return $user;
}

// Unclear what each parameter means
createUser('user@example.com', 'secret123', 'admin', true, false, 3);

Por qué es incorrecto: El sitio de llamada no proporciona contexto sobre lo que es verdadero, falso, y 3 significan, lo que requiere una referencia constante a la firma de la función. Intercambiar $role y $password o $verified y $sendEmail fallaría silenciosamente, lo que podría generar problemas de seguridad.

✅ Conforme:

function createUser(
    string $email,
    string $password,
    string $role = 'user',
    bool $verified = false,
    bool $sendEmail = true,
    int $retryCount = 3
) {
    $hashedPassword = password_hash($password, PASSWORD_BCRYPT);

    $user = User::create([
        'email' => $email,
        'password' => $hashedPassword,
        'role' => $role,
        'verified' => $verified
    ]);

    if ($sendEmail) {
        sendWelcomeEmail($user->email, $retryCount);
    }

    return $user;
}

// Self-documenting call site
createUser(
    email: 'user@example.com',
    password: 'secret123',
    role: 'admin',
    verified: true,
    sendEmail: false,
    retryCount: 3
);

Por qué esto es importante: El propósito de cada parámetro es explícito en el sitio de llamada, lo que hace que el código se autodocumente. Los errores en el orden de los parámetros son imposibles ya que se nombra explícitamente cada argumento, y añadir nuevos parámetros opcionales no romperá el código existente.

Conclusión

Utilice argumentos con nombre para funciones con más de 2-3 parámetros, flags booleanos o tipos similares que aparezcan consecutivamente. La ligera verbosidad en el sitio de la llamada se compensa con mayor claridad, seguridad y mantenibilidad. Reserve los argumentos posicionales para funciones simples donde el orden de los parámetros es obvio y es poco probable que cambie.