Warum verlassen so viele Programmierer ihre Funktionen nicht mit return?

Schau dir einmal diese Funktion an, sie liefert als Ergebnis das Produkt der Argumente $x und $y, sofern beide vom Typ Integer sind. Ist eines der Argumente nicht von Typ Integer, liefert die Funktion false.


function mult ( $x, $y ) {
    if ( is_integer ( $x ) ) {
        if ( is_integer ( $y ) ) {
           $result = $x * $y;
        }
        else {
           $result = false;
        }  
    }
    else {
        $result = false;
    }
    return $result;
}

Warum schreiben so viele Programmiere so schlecht lesbaren Code? Es scheint kaum ein Open-Source-Projekt zu geben, das nicht solche Konstruktionen enthält, wo sich die Ifs bis zu einer Tiefe von mindestens 128 schachteln, die sich dann selbst mit zwei 27-Zoll-Bildschirmen nicht vernünftig darstellen lassen.

Warum nicht einfach die Funktion mit return verlassen, wenn eine Bedingung nicht greift? Zum Beispiel so:

function mult ( $x, $y ) {
 
    if ( !is_integer ( $x ) ) 
        return false;
 
    if ( !is_integer ( $y ) )
       return false;
 
    return x * y;
}

Oder so:

function mult ( $x, $y ) {
 
    if ( !is_integer ( $x ) || !is_integer ( $y )  ) 
        return false;
 
    return x * y;
}

Ist es so schwer, lesbaren Code zu schreiben? Oder ist es so leicht, unlesbaren Code zu schreiben? Ist es cool, ist es hip, ist es Sport, die Ifs bis zum Umfallen zu schachteln? Ist es Ausdruck von Wohlstand? “Äa was? Ihr könnt meinen Code nicht lesen? Ihr könnt euch wohl keine zwei 27-Zoll- Bildschirme leisten?” Oder fühlen sich die Programmierer damit besonders skilled und meinen, wer bei mehr als 16 geschachtelten Ifs den Überblick verliert, ist ein schlechter Coder?

Und nebenbei … wie gefällt das folgende? Ist das gut oder schlecht?

function mult ( $x, $y ) {
    return is_integer ( $x ) && is_integer ( $y ) ? x*y : false;
}

Es müssen gar nicht mal geschachtelte Ifs sein. Es reicht ein einziges If zu Beginn einer 20 Seiten langen Funktion, um den Code schlechter lesbar zu machen. Zum Beispiel so:

static void drawWindowContent()
{
        if (screen_is_visible) {

                19 Seiten Code ...

Um nun herauszufinden, was passiert, wenn screen_is_visible nicht wahr ist, scrollen wir auf Seite 20 und finden …


                20. Seite Code ...
        }
}

… nichts. Es wird nichts gemacht, wenn screen_is_visible nicht wahr ist. Warum nicht einfach die Funktion zu Beginn mit return verlassen, verdammt noch mal? Ist es so schwer, einen logischen Ausdruck zu negieren?

static void drawWindowContent()
{
        if (!screen_is_visible)
                return;


        20 Seiten Code ...

Selbst, wenn es auf Seite 20 noch einen Else-Zweig geben sollte, kommt es der Lesbarkeit normalerweise zugute, wenn die Funktion möglichst früh mit return verlassen wird.

Anstatt

static void drawWindowContent()
{
        if (screen_is_visible) {
                20 Seiten Code ...
        }
        else {  
                printf("Error: Screen is not visible\n");
        }

}

schreiben wir

static void drawWindowContent()
{
        if (!screen_is_visible) {
                printf("Error: Screen is not visible\n");
                return;
        }

        20 Seiten Code ...
}

Aber dazu muß schon wieder ein logischer Ausdruck negiert werden. Ist es das, was so viele nicht können? Sind so viele Coder so schlecht skilled, daß sie nicht wissen, wie logische Ausdrücke negiert werden?

Es ist übrigens mit Sicherheit nicht nur den Open-Source-Projekten vorbehalten, mit schlechtem Code zu glänzen. Bei Closed-Source-Software sehen wir den Mist nur nicht.

Warum verlassen so viele Programmierer ihre Funktionen nicht mit return?

Schreib einen Kommentar