Devcartes

Guard Clauses

Tristan

Einleitung

Softwareentwickler aller Erfahrungsstufen, weltweit kennen das Problem:
Man schaut sich Code von Kollegen oder eigenen, älteren Code an und hat keine Ahnung, was dieser eigentlich macht. Er ist so tief verschachtelt und nimmt so viele Abzweigungen, dass man überhaupt nicht mehr weiß, welches Kriterium nun zum Abbruch der Funktion geführt hat oder welchen Wert eine Variable zu Zeitpunkt des Ausstiegs hat.

Viel schöner wäre es doch, wenn man seine Funktion lesen könnte wie ein Buch, von oben nach unten, und dabei auf einen Blick erkennen kann, an welcher Stelle die Funktion vorzeitig verlassen wird und warum.

Eines der Werkzeuge, auch Patterns genannt, in der Softwareentwicklung, das genau diesem Zweck dient, nennt man Guard Clauses.

Sie machen deinen Code sowohl lesbarer und wartbarer als auch robuster.

Was sind Guard Clauses

Guard Clauses (ins Deutsche frei übersetzt Schutzklausel), sind ein Pattern, bei dem man frühzeitig aus einer Funktion aussteigt, wenn eine bestimmte Bedingung eintritt, die die weitere Abarbeitung des Codes unnötig macht.

Das Prinzip ist, dass man Ausnahmen zuerst behandelt und dann den eigentlichen Programmfluss.

Entscheide selbst, welchen der beiden folgenden Codeabschnitte du lesbarer findest:

if user.is_logged_in {
    if user.has_permission {
        if user.name == "Max" {
            // logik kommt hier
        }
    }
}
if !user.is_logged_in { return; }
if !user.has_permission { return; }
if user.name != "Max" { return; }
//logik kommt hier

Wichtig! Die Bedingungen der Guard Clauses sind logisch negiert, da wir prüfen, wann wir nicht weitermachen dürfen.

Wann solltest du Guard Clauses nutzen

  • Wenn dein Code zu tief verschachtelt ist
  • Bei Vorbedingungen (Preconditions), die den Rest der Funktion hinfällig machen (z.B. Null-Checks)
  • Wenn die Ausnahmen klar vom Normalfall abgegrenzt werden können
  • Wenn du Code von oben nach unten lesen willst, wie ein Buch

Wann solltest du Guard Clauses nicht nutzen

  • Wenn es nicht den einen Normalfall gibt, sondern mehrere gleichwertige Zweige
    • z.B. wenn je nach User-Rolle unterschiedliche Logik ausgeführt werden soll (Zweige sind gleichwertig)
  • Wenn es viele Vorbedingungen (mehr als 5 - 6) gibt, dann lohnt es sich in eine eigene Validierungsfunktion auszulagern

Best Practices

  • Guard Clauses am Anfang der Funktion bündeln
  • Eine Bedingung pro Guard Clause
  • Aussagekräftige Fehler zurückgeben oder sauberes Logging statt stiller returns
  • Guards nicht schachteln
  • Reihenfolge nach Wahrscheinlichkeit, statistisch häufige Fehler zuerst prüfen
  • Trotzdem das Single Responsibility Principle einhalten
  • In Teams das Pattern klar als Standard definieren, das spart Zeit und Diskussionen im Code Review

Schluss

Du siehst also, Guard Clauses sind ein sehr einfaches und nützliches Pattern, um deinen Code zu verbessern. Sie reduzieren Verschachtelung und erhöhen somit die Lesbarkeit.

Doch trotz der Einfachheit nutzen nicht alle erfahrenen Entwickler sie.

Was denkst du, woran liegt das?
Liegt es vielleicht daran, dass viele Entwickler mit if-else-Verschachtelungen groß geworden sind und Guard Clauses sich fremd anfühlen?