Sollte eine Funktion nur eine Rückgabeanweisung haben?

Question

Gibt es gute Gründe, warum es besser ist, nur eine Rückgabeanweisung in einer Funktion zu haben?

Oder ist es in Ordnung, aus einer Funktion zurückzukehren, sobald dies logisch korrekt ist, d.h. es kann viele Return-Anweisungen in der Funktion geben?

Answer 1

Ich habe oft mehrere Anweisungen am Anfang einer Methode, um für "einfache" Situationen zurückzukehren. Zum Beispiel dies:

public void DoStuff(Foo foo)
{
    if (foo != null)
    {
        ...
    }
}

... kann (IMHO) auf diese Weise lesbarer gemacht werden:

public void DoStuff(Foo foo)
{
    if (foo == null) return;

    ...
}

Also ja, ich denke, es ist in Ordnung, mehrere "Ausstiegspunkte" aus einer Funktion/Methode zu haben.

Answer 2

Niemand hat erwähnt oder zitiert Code vollständig also werde ich es tun.

17.1 Rückgabe

Minimieren Sie die Anzahl der Rückgaben in jeder Routine . Es ist schwieriger, eine Routine zu verstehen, wenn man sie am Ende liest und nicht weiß, dass sie irgendwo oben zurückkommt.

Verwenden Sie eine return wenn es die Lesbarkeit verbessert . In bestimmten Routinen möchten Sie die Antwort, sobald Sie sie kennen, sofort an die aufrufende Routine zurückgeben. Wenn die Routine so definiert ist, dass sie keine Aufräumarbeiten erfordert, bedeutet eine nicht sofortige Rückgabe, dass Sie mehr Code schreiben müssen.

Answer 3

Ich würde sagen, dass es äußerst unklug wäre, sich willkürlich gegen mehrere Ausstiegspunkte zu entscheiden, da ich die Technik in der Praxis als nützlich empfunden habe immer und immer wieder Ich habe in der Tat oft Überarbeitung des bestehenden Codes der Übersichtlichkeit halber auf mehrere Ausstiegspunkte. Wir können die beiden Ansätze folgendermaßen vergleichen:-

string fooBar(string s, int? i) {
  string ret = "";
  if(!string.IsNullOrEmpty(s) && i != null) {
    var res = someFunction(s, i);

    bool passed = true;
    foreach(var r in res) {
      if(!r.Passed) {
        passed = false;
        break;
      }
    }

    if(passed) {
      // Rest of code...
    }
  }

  return ret;
}

Vergleichen Sie dies mit dem Code, bei dem mehrere Ausstiegspunkte sont erlaubt:-

string fooBar(string s, int? i) {
  var ret = "";
  if(string.IsNullOrEmpty(s) || i == null) return null;

  var res = someFunction(s, i);

  foreach(var r in res) {
      if(!r.Passed) return null;
  }

  // Rest of code...

  return ret;
}

Ich denke, letzteres ist wesentlich klarer. Soweit ich das beurteilen kann, ist die Kritik an mehreren Ausstiegspunkten heutzutage eine ziemlich archaische Sichtweise.

Answer 4

Ich arbeite derzeit an einer Codebasis, bei der zwei der daran arbeitenden Personen blindlings der "Single Point of Exit"-Theorie anhängen, und ich kann Ihnen aus Erfahrung sagen, dass dies eine furchtbare Praxis ist. Es macht den Code extrem schwer zu pflegen und ich werde Ihnen zeigen, warum.

Mit der "Single Point of Exit"-Theorie landet man unweigerlich bei einem Code, der wie folgt aussieht:

function()
{
    HRESULT error = S_OK;

    if(SUCCEEDED(Operation1()))
    {
        if(SUCCEEDED(Operation2()))
        {
            if(SUCCEEDED(Operation3()))
            {
                if(SUCCEEDED(Operation4()))
                {
                }
                else
                {
                    error = OPERATION4FAILED;
                }
            }
            else
            {
                error = OPERATION3FAILED;
            }
        }
        else
        {
            error = OPERATION2FAILED;
        }
    }
    else
    {
        error = OPERATION1FAILED;
    }

    return error;
}

Das macht den Code nicht nur sehr unübersichtlich, sondern man muss auch später noch einmal zurückgehen und eine Operation zwischen 1 und 2 einfügen. Sie müssen fast die gesamte Funktion einrücken, und viel Glück dabei, alle if/else-Bedingungen und geschweiften Klammern richtig zu platzieren.

Diese Methode macht die Codepflege extrem schwierig und fehleranfällig.

Answer 5

Strukturierte Programmierung besagt, dass man immer nur eine Return-Anweisung pro Funktion haben sollte. Damit soll die Komplexität begrenzt werden. Viele Leute wie Martin Fowler argumentieren, dass es einfacher ist, Funktionen mit mehreren Rückgabeanweisungen zu schreiben. Er präsentiert dieses Argument in dem Klassiker Refaktorierung Buch, das er geschrieben hat. Das funktioniert gut, wenn man seine anderen Ratschläge befolgt und kleine Funktionen schreibt. Ich stimme dieser Sichtweise zu, und nur strenge Puristen der strukturierten Programmierung halten sich an einzelne Rückgabeanweisungen pro Funktion.