Ist es ein guter Stil, explizit in Ruby zurückzukehren?

Ich komme aus einem Python-Hintergrund, in dem es immer einen "richtigen Weg" (einen "pythonischen" Weg) gibt, wenn es um Stil geht, und frage mich, ob es für Ruby dasselbe gibt. Ich habe meine eigenen Stilrichtlinien verwendet, denke aber darüber nach, meinen Quellcode freizugeben, und ich möchte, dass er sich an eventuell vorhandene ungeschriebene Regeln hält.

Ist es "The Ruby Way", returnMethoden explizit einzugeben? Ich habe es mit und ohne gesehen, aber gibt es einen richtigen Weg, es zu tun? Gibt es vielleicht einen richtigen Zeitpunkt dafür? Beispielsweise:

def some_func(arg1, arg2, etc)
  # Do some stuff...
  return value # <-- Is the 'return' needed here?
end

Alte (und "beantwortete") Frage, aber ich werde meine zwei Cent als Antwort einwerfen.

TL; DR - Sie müssen nicht, aber es kann Ihren Code in einigen Fällen viel klarer machen.

Obwohl die Verwendung einer expliziten Rückgabe möglicherweise "der Ruby-Weg" ist, ist dies für Programmierer, die mit unbekanntem Code arbeiten oder mit dieser Funktion von Ruby nicht vertraut sind, verwirrend.

Es ist ein etwas ausgeklügeltes Beispiel, aber stellen Sie sich vor, Sie hätten eine kleine Funktion wie diese, die der übergebenen Zahl eine hinzufügt und sie einer Instanzvariablen zuweist.

def plus_one_to_y(x)
    @y = x + 1
end

War dies eine Funktion, die einen Wert zurückgab, oder nicht? Es ist wirklich schwer zu sagen, was der Entwickler gemeint hat, da beide die Instanzvariable zuweisen UND auch den zugewiesenen Wert zurückgeben.

Angenommen, viel später kommt ein anderer Programmierer (der vielleicht nicht so vertraut damit ist, wie Ruby basierend auf der zuletzt ausgeführten Codezeile zurückgibt) und möchte einige print-Anweisungen für die Protokollierung eingeben, und die Funktion wird zu dieser ...

def plus_one_to_y(x)
    @y = x + 1
    puts "In plus_one_to_y"
end

Jetzt ist die Funktion unterbrochen, wenn etwas einen zurückgegebenen Wert erwartet . Wenn nichts einen zurückgegebenen Wert erwartet, ist dies in Ordnung. Wenn irgendwo weiter unten in der Codekette ein Aufruf einen zurückgegebenen Wert erwartet, wird dies eindeutig fehlschlagen, da er nicht das zurückerhält, was er erwartet.

Die eigentliche Frage lautet nun: Hat irgendetwas wirklich einen zurückgegebenen Wert erwartet? Hat das etwas kaputt gemacht oder nicht? Wird es in Zukunft etwas kaputt machen? Wer weiß! Nur eine vollständige Codeüberprüfung aller Anrufe informiert Sie.

Zumindest für mich besteht der Best-Practice-Ansatz darin, entweder sehr deutlich zu machen, dass Sie etwas zurückgeben, wenn es wichtig ist, oder überhaupt nichts zurückzugeben, wenn dies nicht der Fall ist.

Im Fall unserer kleinen Demofunktion würde sie also so geschrieben sein, vorausgesetzt, wir wollten, dass sie einen Wert zurückgibt ...

def plus_one_to_y(x)
    @y = x + 1
    puts "In plus_one_to_y"
    return @y
end

Und es wäre jedem Programmierer sehr klar, dass es einen Wert zurückgibt, und es ist für sie viel schwieriger, ihn zu brechen, ohne es zu merken.

Alternativ könnte man es so schreiben und die return-Anweisung weglassen ...

def plus_one_to_y(x)
    @y = x + 1
    puts "In plus_one_to_y"
    @y
end

Aber warum sollte man sich die Mühe machen, das Wort Rückkehr wegzulassen? Warum nicht einfach dort hineinstecken und 100% klar machen, was passiert? Dies hat buchstäblich keinen Einfluss auf die Leistungsfähigkeit Ihres Codes.

Nein. Ein guter Ruby-Stil verwendet im Allgemeinen nur explizite Rückgaben für eine frühzeitige Rückgabe . Ruby legt großen Wert auf Code-Minimalismus / implizite Magie.

Das heißt, wenn eine explizite Rückgabe die Dinge klarer oder leichter lesbar machen würde, würde dies nichts schaden.

Ich persönlich benutze das returnSchlüsselwort, um zwischen funktionalen Methoden zu unterscheiden , dh Methoden, die hauptsächlich wegen ihres Rückgabewerts ausgeführt werden, und prozeduralen Methoden , die hauptsächlich wegen ihrer Nebenwirkungen ausgeführt werden. Bei Methoden, bei denen der Rückgabewert wichtig ist, erhalten Sie ein zusätzliches returnSchlüsselwort, um auf den Rückgabewert aufmerksam zu machen.

Ich benutze die gleiche Unterscheidung beim Aufrufen von Methoden: Funktionsmethoden erhalten Klammern, prozedurale Methoden nicht.

Und zu guter Letzt verwende ich diese Unterscheidung auch bei Blöcken: Funktionsblöcke erhalten geschweifte Klammern, prozedurale Blöcke (dh Blöcke, die etwas "tun") erhalten do/ end.

Ich versuche jedoch, nicht religiös zu sein: Mit Blöcken, geschweiften Klammern und do/ oder endunterschiedlicher Priorität, und anstatt explizite Klammern hinzuzufügen, um einen Ausdruck eindeutig zu machen, wechsle ich einfach zum anderen Stil. Gleiches gilt für den Methodenaufruf: Wenn das Hinzufügen von Klammern um die Parameterliste den Code lesbarer macht, mache ich das auch dann, wenn die betreffende Methode prozeduraler Natur ist.

Eigentlich ist es wichtig zu unterscheiden zwischen:

1. Funktionen - Methoden, die für ihren Rückgabewert ausgeführt werden
2. Prozeduren - Methoden, die wegen ihrer Nebenwirkungen ausgeführt werden

Ruby hat keine native Methode, um diese zu unterscheiden. Dies macht Sie anfällig für das Schreiben einer Prozedur side_effect()und einen anderen Entwickler, der beschließt, den impliziten Rückgabewert Ihrer Prozedur zu missbrauchen (im Grunde genommen als unreine Funktion zu behandeln).

Um dies zu beheben, nehmen Sie ein Blatt aus Scala und Haskells Buch und lassen Sie Ihre Verfahren explizit zurückgeben nil(auch bekannt als Unitoder ()in anderen Sprachen).

Wenn Sie dies befolgen, wird die Verwendung einer expliziten returnSyntax oder nicht nur eine Frage des persönlichen Stils.

Weitere Unterscheidung zwischen Funktionen und Verfahren:

1. Kopieren Sie Jörg W Mittag's schöne Idee, Funktionsblöcke mit geschweiften Klammern und Verfahrensblöcke mit zu schreiben do/end
2. Wenn Sie Prozeduren aufrufen, verwenden Sie (), während dies beim Aufrufen von Funktionen nicht der Fall ist

Beachten Sie, dass Jörg W Mittag tatsächlich den umgekehrten Fall befürwortet hat - ()s für Prozeduren zu vermeiden -, aber dies ist nicht ratsam, da Sie möchten, dass nebeneffektive Methodenaufrufe klar von Variablen unterschieden werden können, insbesondere wenn arity 0 ist. Siehe den Scala-Styleguide zum Methodenaufruf für Einzelheiten.

Der Styleguide besagt, dass Sie returnIhre letzte Anweisung nicht verwenden sollten. Sie können es weiterhin verwenden, wenn es nicht das letzte ist . Dies ist eine der Konventionen, die die Community strikt befolgt. Dies sollten Sie auch tun, wenn Sie vorhaben, mit anderen Personen zusammenzuarbeiten, die Ruby verwenden.

Abgesehen davon ist das Hauptargument für die Verwendung von expliziten returns, dass es für Leute aus anderen Sprachen verwirrend ist.

• Erstens ist dies nicht nur Ruby vorbehalten. Zum Beispiel hat Perl auch implizite Rückgaben.
• Zweitens kommt die Mehrheit der Menschen, für die dies gilt, aus algolischen Sprachen. Die meisten davon sind viel "niedriger" als Ruby, daher müssen Sie mehr Code schreiben, um etwas zu erledigen.

Eine gängige Heuristik für die Methodenlänge (ohne Getter / Setter) in Java ist ein Bildschirm . In diesem Fall wird die Methodendefinition möglicherweise nicht angezeigt und / oder Sie haben bereits vergessen, von wo Sie zurückgekehrt sind.

Auf der anderen Seite ist es in Ruby am besten, sich an Methoden zu halten, die weniger als 10 Zeilen lang sind . Angesichts dessen würde man sich fragen, warum er ~ 10% mehr Aussagen schreiben muss, wenn sie eindeutig impliziert sind.

Da Ruby keine ungültigen Methoden hat und alles so viel präziser ist, fügen Sie nur Overhead für keinen der Vorteile hinzu, wenn Sie explizite returns verwenden.

Ich stimme Ben Hughes zu und stimme Tim Holt nicht zu, da in der Frage die endgültige Vorgehensweise von Python erwähnt wird und gefragt wird, ob Ruby einen ähnlichen Standard hat.

Es tut.

Dies ist ein so bekanntes Merkmal der Sprache, dass jeder, von dem erwartet wird, dass er ein Problem in Ruby debuggt, vernünftigerweise davon erfahren sollte.

Es ist eine Frage des Stils, den Sie größtenteils bevorzugen. Sie müssen das Schlüsselwort return verwenden, wenn Sie von irgendwo in der Mitte einer Methode zurückkehren möchten.

Wie Ben sagte. Die Tatsache, dass 'der Rückgabewert einer Ruby-Methode der Rückgabewert der letzten Anweisung im Funktionskörper ist', führt dazu, dass das Schlüsselwort return in den meisten Ruby-Methoden selten verwendet wird.

def some_func_which_returns_a_list( x, y, z)
  return nil if failed_some_early_check


  # function code 

  @list     # returns the list
end