Est-ce bon style pour renvoyer explicitement en Ruby ?

Question

Venant d'un Python de fond, où il y a toujours une "bonne façon de le faire" (un "Pythonic", si vous voulez) quand il s'agit de style, je me demande si la même chose existe pour Ruby. Je suis en quelque sorte été en utilisant mon propre style, mais je suis en train de penser au sujet de sortir de mon code source, et j'aimerais qu'il se conformer à l'une des règles non écrites qui pourraient exister.

Donc ma question est: Est-il "Le Rubis Façon" explicitement type return dans les méthodes? Je l'ai vu faire avec et sans, mais est-il une "bonne façon" de faire ça? Est-il peut-être "le bon temps" de le faire? Par exemple:

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

Answer 1

Ancienne (et la "réponse") de la question, mais je vais jeter dans mes deux cents, à titre de réponse.

Bien que n'utilisant pas un retour explicite peut être "le Rubis moyen", il est aussi source de confusion pour les programmeurs travaillant avec code inconnu, ou peu familiers avec cette fonctionnalité de Ruby.

Par exemple, on pourrait avoir un peu de fonction comme ceci, qui additionne un nombre passé, et l'affecte à une variable d'instance.

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

Était-ce censé être une fonction qui a retourné une valeur, ou pas? Il est vraiment difficile de dire ce que signifiait le développeur, il assigne à la variable d'instance, ET renvoie la valeur affectée.

Supposons que beaucoup plus tard, un autre programmeur (peut-être pas familier avec Ruby bizarreries) arrive et veut mettre dans certains des instructions d'impression, à l'exploitation, et la fonction devient ce...

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

Maintenant, la fonction est interrompue si quelque chose s'attend à une valeur de retour. Si rien ne s'attend à un retour de la valeur, c'est la fin. Clairement si, quelque part, plus loin dans le code de la chaîne, quelque chose de l'appel de cette s'attend à un retour de la valeur, c'est voué à l'échec car il n'est pas d'obtenir un numéro.

La vraie question maintenant est: est-ce a fait quelque chose de vraiment s'attendre à un retour de la valeur? A ce casser quelque chose ou pas? Il va casser quelque chose dans l'avenir? Qui sait? Seule une révision du code de tous les appels vous permettra de savoir.

Donc (pour moi au moins), la meilleure pratique est d'être très explicite sur le fait que vous êtes de retour quelque chose si il le faut, ou ne retournent rien du tout.

Ainsi, dans le cas de notre petite démo de la fonction, en supposant que nous voulions pour retourner une valeur, il devrait être écrit comme cela...

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

Et il serait très clair pour tout programmeur qui retourne une valeur, et beaucoup plus difficile pour lui de rompre sans s'en rendre compte.

Answer 2

Lol Bon style Ruby utiliseraient généralement seulement une déclarations explicites pour un retour anticipé. Ruby est grande sur la magie minimalisme/implicite de code.

Cela dit, si une déclaration explicite rendrait les choses plus claires ou plus faciles à lire, il ne nuira pas à quoi que ce soit.

Answer 3

Personnellement, j'utilise l' return mot-clé de la distinction entre ce que j'appelle fonctionnel des méthodes, c'est à dire des méthodes qui sont exécutés principalement pour leur valeur de retour, et les méthodes procédurales qui sont exécutés principalement pour leurs effets secondaires. Ainsi, les méthodes dans laquelle la valeur de retour est important, obtenir un supplément de return mot-clé pour attirer l'attention sur la valeur de retour.

J'utilise la même distinction lors de l'appel de méthodes: les méthodes fonctionnelles obtenir des parenthèses, des méthodes procédurales ne le font pas.

Et le dernier mais non le moindre, j'utilise aussi cette distinction avec des blocs: les blocs fonctionnels d'obtenir des accolades, de la procédure de blocs (c'est à dire, des blocs de "faire" quelque chose) obtenir de l' do/end.

Cependant, j'essaie de ne pas être religieux à ce sujet: avec des blocs, des accolades et do/end ont différentes priorité, et plutôt que d'ajouter explicite entre parenthèses pour lever l'ambiguïté d'une expression, je viens de basculer de l'autre style. Il en va de même pour l'appel de méthode: si l'ajout de parenthèses autour de la liste de paramètres rend le code plus lisible, je le fais, même si la méthode en question est de nature procédurale.

Answer 4

En fait l'important, c'est de faire la distinction entre:

1. Fonctions - méthodes exécutées pour le compte de leur valeur de retour
2. Procédures - méthodes exécutées pour le compte de leurs effets secondaires

Ruby n'a pas de façon native de distinguer ces derniers - ce qui vous laisse vulnérables à l'écriture d'une procédure d' side_effect() et un autre développeur de décider de l'abus de l'implicite de la valeur de retour de votre procédure (essentiellement en la traitant comme un impur de la fonction).

Pour résoudre ce problème, prendre une feuille de Scala, Haskell livre et avoir vos procédures de renvoyer explicitement nil (aka Unit ou () dans d'autres langues).

Si vous suivez cela, puis à l'aide explicite return de la syntaxe ou pas devient tout simplement une question de style personnel.

Pour distinguer entre les fonctions et procédures:

1. Copie Jörg W Mittag la belle idée de l'écriture de blocs fonctionnels avec des accolades procédures et des blocs avec des do/end
2. Lorsque vous appelez des procédures, utilisez (), alors que lors de l'appel de fonctions, de ne pas

Notez que Jörg W Mittag effectivement préconisé dans l'autre sens en évitant ()s pour les procédures - mais ce n'est pas conseillé parce que vous voulez côté d'effectuer des appels de méthode pour se distinguer nettement de variables, en particulier lors de l'arité est de 0. Voir la Scala style guide sur l'invocation de méthode pour plus de détails.

Answer 5

Il s’agit de quel style vous préférez la plupart du temps. Vous n’avez pas à utiliser le mot-clé de retour si vous voulez retourner à partir quelque part au milieu d’une méthode.