Regel
Verwendung mit dem Namen Argumente für Klarheit
Benannte Argumente machen Code selbstdokumentierend 
und verhindern Parameter Fehler Fehler.
Verwenden benannte Argumente bei Funktionen haben mehr
als 2-3 Parameter oder boolesche Flags.

Unterstützte Sprachen: Python, PHP

Einleitung

Funktionen mit mehreren Parametern werden unklar, wenn man die Aufrufstelle betrachtet. Lesen sendEmail('user@example.com', true, false, 30) erfordert das Nachschlagen der Funktionssignatur, um zu verstehen, was wahr, falsch, und 30 bedeuten. Benannte Argumente lösen dies, indem sie den Zweck jedes Parameters an der Aufrufstelle explizit machen. Sie verhindern auch Fehler durch Parameter-Neuordnung, wenn sich Funktionssignaturen ändern.

Warum es wichtig ist

Code-Wartbarkeit: Benannte Argumente dokumentieren die Absicht an der Aufrufstelle, ohne ständiges Nachschlagen zu erfordern. Wenn Sie sehen sendEmail(to: $email, retry: true, async: false, timeout: 30), verstehen Sie genau, was jeder Wert steuert. Dies eliminiert Verwirrung während des Code-Reviews und beschleunigt das Debugging, da Sie positionale Argumente nicht mental auf Parameternamen abbilden müssen.

Sicherheitsimplikationen: Fehler in der Parameterreihenfolge in sicherheitskritischen Funktionen können Schwachstellen erzeugen. Das Vertauschen der $username und $password Parameter, oder das versehentliche Übergeben des Klartextpassworts, wo das gehashte Passwort hingehört, schlägt bei Positionsargumenten stillschweigend fehl. Benannte Argumente zwingen Sie dazu, explizit anzugeben, welcher Wert wohin gehört, wodurch diese gefährlichen Fehler verhindert werden.

Refactoring-Sicherheit: Das Hinzufügen optionaler Parameter zu bestehenden Funktionen führt dazu, dass alle Aufrufe mit Positionsargumenten fehlschlagen, es sei denn, Sie fügen sie am Ende an. Benannte Argumente ermöglichen es Ihnen, Parameter hinzuzufügen, neu anzuordnen oder zu ändern, ohne bestehenden Code zu beschädigen, solange die Parameternamen konsistent bleiben. Dies macht APIs stabiler und die Weiterentwicklung weniger riskant.

Code-Beispiele

❌ Nicht konform:

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

Warum es falsch ist: Die Aufrufstelle bietet keinen Kontext dafür, was wahr ist, falsch, und 3 bedeuten, was eine ständige Referenz auf die Funktionssignatur erfordert. Der Austausch von $role und $password oder $verified und $sendEmail würde still fehlschlagen und potenziell Sicherheitsprobleme verursachen.

✅ Konform:

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

Warum das wichtig ist: Der Zweck jedes Parameters ist an der Aufrufstelle explizit, was den Code selbstdokumentierend macht. Fehler in der Parameterreihenfolge sind unmöglich, da jedes Argument explizit benannt wird, und das Hinzufügen neuer optionaler Parameter wird bestehenden Code nicht beeinträchtigen.

Fazit

Verwenden Sie benannte Argumente für Funktionen mit mehr als 2-3 Parametern, booleschen Flags oder ähnlichen Typen, die aufeinanderfolgend erscheinen. Die leichte Ausführlichkeit an der Aufrufstelle zahlt sich in Klarheit, Sicherheit und Wartbarkeit aus. Reservieren Sie positionale Argumente für einfache Funktionen, bei denen die Reihenfolge der Parameter offensichtlich ist und sich wahrscheinlich nicht ändern wird.