Il est de bon ton de renvoyer explicitement en Ruby?

À venir à partir d'un Python de fond, où il y a toujours une "bonne façon de le faire" (un "Pythonic manière de faire") quand il s'agit de style, je me demande si la même chose existe pour Ruby. J'ai é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.

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 le faire? Est-il peut-être un droit temps de le faire? Par exemple:

def some_func(arg1, arg2, etc)
  # Do some stuff...
  return value # <-- Is the 'return' needed here?
end
  • C'est une très vieille question, mais pour ceux qui ont des questions similaires, Le livre Éloquent Ruby est fortement recommandé. Ce n'est pas un guide de style autant que d'une introduction à l'écriture idiomatique Ruby. Je souhaite que plus de gens le lire!
  • Comme quelqu'un qui a hérité d'un grand héritage application qui a été développé en Ruby, j'ai beaucoup apprécié que vous avez posé cette question. Cela mérite un upvote. C'est parsemée tout au long de notre héritage app. Une de mes tâches de cette équipe est d'améliorer la base de code (dur quand étant nouveau pour Ruby).
InformationsquelleAutor Sasha Chedygov | 2009-06-21
  1. 214

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

    TL;DR - Vous n'avez pas à, mais il peut rendre votre code beaucoup plus clair dans certains cas.

    Mais pas à l'aide d'un retour explicite peut être "le Rubis moyen", c'est source de confusion pour les programmeurs travaillant avec code inconnu, ou peu familiers avec cette fonctionnalité de Ruby.

    C'est un peu artificiel exemple, mais l'imagerie d'avoir un peu de fonction comme celle-ci, 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 ainsi.

    Suppose que beaucoup plus tard, un autre programmeur (peut-être pas familier avec la façon dont Ruby ne renvoie basée sur la dernière ligne de code exécutée) 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 cassé si quelque chose s'attend à une valeur retournée. 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 ce qu'elle attend.

    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 renvoyer rien s'il ne le fait pas.

    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.

    Alternativement, on pourrait écrire comme ça et de sortir l'instruction de retour...

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

    Mais pourquoi s'embêter en laissant le mot de retour? Pourquoi ne pas simplement mettre en place et de le rendre 100% clair ce qui se passe? Il va littéralement n'ont aucun impact sur la capacité de votre code à exécuter.

    • Point intéressant. Je pense que j'ai fait, couru dans une situation similaire quand j'ai posé cette question, où le développeur à l'origine utilisé l'implicite de la valeur de retour dans leur code, et il était très difficile de comprendre ce qui se passait. Merci pour votre réponse!
    • J'ai trouvé la question pendant Googler sur le rendement implicite, car j'avais été brûlé par cette. J'avais ajouté un peu de logique à la fin d'une fonction qui a été implicitement le retour de quelque chose. La plupart des appels pour qu'il s'en foutait (ou vérifier) la valeur retournée, mais un fait, et il a échoué. Heureusement, au moins, il a montré dans des tests fonctionnels.
    • Si cela est vrai, c'est important pour que le code soit lisible, évitant une caractéristique bien connue d'un langage de programmation en faveur de verbosité est, à mon avis, une mauvaise pratique. Si un développeur n'est pas familier avec Ruby, alors peut-être qu'ils devraient apprendre à connaître avant de toucher au code. Je trouve ça un peu ridicule d'avoir à augmenter l'encombrement de mon code pour l'avenir de l'événement que certains non-développeur Ruby a faire quelque chose plus tard. Nous ne devrions pas être de réduire une langue au plus petit dénominateur commun. Une partie de la beauté de Ruby, c'est que nous n'avons pas d'utilisation de 5 lignes de code pour dire quelque chose qui ne devrait prendre que 3.
    • Si le mot return ajoute de sens sémantique du code, pourquoi pas? Ce n'est pas très prolixe - nous ne parlons pas des 5 lignes vs 3, juste un mot de plus. Je préfère voir return au moins dans les fonctions (peut-être pas dans les blocs) pour exprimer ce que le code fait réellement. Parfois, vous devez retourner à mi-fonction - ne pas laisser de côté la dernière return mot-clé sur la dernière ligne juste parce que vous le pouvez. Je ne suis pas en faveur de verbosité à tous, mais j'en faveur de la cohérence.
    • C'est une excellente réponse. Mais il laisse toujours le risque que vous écrivez une méthode Ruby ayant l'intention d'être une procédure (aka la fonction de retour de l'unité), par exemple side_effect() et un autre développeur décide de (ab)utiliser l'implicite de la valeur de retour de votre procédure. Pour résoudre ce problème, vous pouvez faire vos procédures explicitement return nil.
    • Bon point Alex Doyen
    • +1 c'est vraiment une bonne réponse sur le pourquoi du retour de valeurs explicites vraiment ajoute de la clarté et de la sécurité.
    • Il est une autre façon de faire en sorte que les gens ne seront pas abuser de votre implicite, les valeurs de retour: document de votre méthode. Toujours écrire ce que la méthode est censée retourner.
    • Entendre entendre! Absolument.
    • Je suis d'accord que la lisibilité est importante, mais si une fonction doit retourner une valeur, qu'est ce que les specs sont pour. Rendement implicite est le standard de ruby et doit être utilisé à moins que ça ne fait pas de sens (le retour précoce, ou quelque chose d'inattendu ou très complexe)
    • OMI mauvais raisonnement. Vous n'avez pas d'écrire du code pour les gens qui ne connaissent pas la langue. Quelle est la prochaine? "il ne faut pas utiliser >@> en haskell! ce n'est pas évident pour les gens qui ne savent pas haskell!"? Oui, un nouveau venu va casser le code existant. C'est normal et attendu. C'est (juste une raison) pourquoi vous avez des tests.
    • En dépit d'être familier ou non avec ruby l'exemple cité EST source de confusion. Dans ce cas concret, le retour rend le code plus facile à comprendre et moins ambiguë. Cependant, la plupart du temps, les méthodes sont d'autant plus évidentes, et dans ces cas je dirais que vous pouvez en toute sécurité ignorer le retour.
    • Oui. Intentionnellement ignorer le caractère unique d'une langue est à côté de la question de la langue.
    • Bon point. Une partie de la beauté du langage Ruby est que nous pouvons tout simplement le code
    • Vous pouvez également utiliser #tap pour éviter le retour, @y.tap { |value| puts value }. Voir medium.com/aviabird/ruby-tap-that-method-90c8a801fd6a

    InformationsquelleAutor Tim Holt
  2. 66

    Pas. Bon Ruby style généralement l'utilisation explicite retourne pour un retour anticipé. Ruby est grande sur le code minimalisme/implicite de la magie.

    Cela dit, si un retour explicite permettrait de rendre les choses plus claires, ou plus facile à lire, il ne nuira pas à quoi que ce soit.

    • Quel est le point de code minimalisme si elle aboutit à la confusion maximalisme?
    • Il devrait plutôt le résultat dans la documentation maximalisme.
    • Si vous avez fortement documenter votre code pour qu'il soit bien compris que vous n'êtes pas pratiquant le minimalisme, vous pratiquez code de golf.
    • Il n'est pas source de confusion pour exclure la déclaration finale, c'est source de confusion pour INCLURE, en tant que développeur Ruby, return a déjà une importante signification sémantique comme un DÉBUT de SORTIE de la fonction.
    • Comment sur la terre quelqu'un pourrait confondre un return sur la dernière ligne de SORTIE ANTICIPÉE, de toute façon?
    InformationsquelleAutor Ben Hughes
  3. 31

    Personnellement, j'utilise le return mot clé de distinguer entre ce que j'appelle fonctionnelle méthodes, c'est à dire des méthodes qui sont exécutés principalement pour leur valeur de retour, et 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.

    - Je utiliser la même distinction lorsque appel méthodes: les méthodes fonctionnelles obtenir des parenthèses, des méthodes procédurales ne 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 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.

    • Maintenant, je vous omettez un retour en "one-liners", qui est similaire à ce que vous êtes en train de faire, et je n'ai tout de même. Bon à savoir, je ne suis pas complètement à côté de mon style. 🙂
    • Utilisez-vous des retours anticipés dans votre code? Ne fait que créer une confusion avec votre procédure/schéma fonctionnel?
    • Grimm: Oui, et Oui. Je suis en train de penser en l'inversant. La grande majorité de mes méthodes est referentially transparent / pur / fonctionnel / tout ce que vous voulez l'appeler de toute façon, il est donc logique d'utiliser la version la plus courte il. Et méthodes écrites dans un style fonctionnel tendance à ne pas avoir de retour anticipé, depuis qu'implique la notion de "l'étape", ce qui n'est pas très fonctionnel. Bien que, je n'aime pas les retours dans le milieu. Je l'ai utiliser dans le début de la garde ou à la fin de simplifier les flux de contrôle.
    • Grande réponse, mais il est préférable d'appeler les méthodes procédurales avec () et fonctionnelle des méthodes sans - voir ma réponse ci-dessous pour pourquoi
    InformationsquelleAutor Jörg W Mittag
  4. 13

    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'est pas un natif de faire la distinction entre ces derniers - ce qui vous laisse vulnérables à l'écriture d'une procédure 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 fonction).

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

    Si vous suivez cela, puis à l'aide explicite return 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 do/end
    2. Lorsque vous appelez des procédures, l'utilisation (), alors que lors de l'appel de fonctions, de ne pas

    Noter 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.

    • Si j'ai besoin de la valeur retournée par function_a, et function_a a été écrit à l'appel (et ne peut fonctionner que par l'appelant) procedure_b, puis est function_a vraiment une fonction? Elle renvoie une valeur, répondre à votre exigence pour les fonctions, mais il a un effet secondaire, tout en remplissant les exigences en matière de procédures.
    • Vous avez raison Devon - function_a pourrait contenir un arbre de procedure_... appels, comme d'ailleurs procedure_a pourrait contenir un arbre de function_... appels. Comme la Scala, mais à la différence de Haskell, il ne peut y avoir aucune garantie en Ruby qu'une fonction n'est pas du côté-accomplissement.
    InformationsquelleAutor Alex Dean
  5. 7

    Le guide de style unis, que vous ne devriez pas être à l'aide de return sur votre dernier relevé. Vous pouvez toujours l'utiliser si ce n'est pas le dernier. C'est l'une des conventions sur lesquelles la communauté suit strictement, et vous devriez faire si vous avez l'intention de collaborer avec n'importe qui à l'aide de Ruby.

    Cela étant dit, le principal argument pour l'utilisation explicite returns, c'est que c'est source de confusion pour les personnes venant d'autres langues.

    • Tout d'abord, ce n'est pas totalement exclusif à Ruby. Par exemple Perl a rendement implicite trop.
    • Deuxièmement, la majorité des gens que cela s'applique à venir de l'Algol langues. La plupart de ceux qui sont "niveau inférieur" que le Rubis, par conséquent, vous devez écrire plus de code pour obtenir quelque chose.

    Une commune heuristique pour la méthode de la longueur (à l'exclusion des getters/setters) en java est un écran. Dans ce cas, vous pourriez ne pas voir que la définition de la méthode et/ou ont déjà oublié où vous étiez de retour d'.

    D'autre part, en Ruby, il est préférable de s'en tenir à des méthodes moins de 10 lignes. Étant donné que, on pourrait se demander pourquoi il a écrire ~10% de plus d'états, lorsqu'ils sont clairement sous-entendue.

    Depuis Ruby n'a pas vide méthodes et tout est beaucoup plus concis, vous êtes juste en ajoutant les frais généraux pour aucun des avantages si vous allez explicite returns.

    • "C'est l'une des conventions sur lesquelles la communauté suit strictement" de Mon expérience, c'est que non, les gens ne suivent pas cette strictement, sauf s'ils sont très expérimentés développeurs Ruby.
    • J'ai eu beaucoup de chance alors. (:
    • Je dirais que Rubyists devriez être à la suite Sandi Règles -- classes ne sont plus que 100 lignes, des méthodes plus que 5, pas plus de 4 paramètres passés à une méthode.
    • il pourrait être de trop de limiter dans certains cas. Mais tant que vous n'êtes pas réduire artificiellement la taille juste pour passer quelques contraintes, je suis d'accord que moins est plus.
    • tout à fait d'accord. La chose importante est que lorsqu'une méthode (ou une classe) commence à dépasser 5/100 lignes, alors c'est une bonne idée de revoir ce que vous essayez d'accomplir. Vraiment Sandi les Règles sont un cadre cognitif de la pensée à propos du code, par opposition à l'arbitraire d'un dogme. La majorité de code que je rencontre n'est pas problématique, car il est artificiellement limitée -- c'est généralement le contraire-classes avec de multiples responsabilités, les méthodes qui sont plus que de nombreuses classes. Essentiellement, trop de gens "jump the shark" -- mélange de responsabilités.
    • Parfois convention est toujours une mauvaise idée. Ses une stylistique de la convention, qui s'appuie sur la magie, fait revenir les types de difficile à deviner. offre aucun avantage autre que de sauver 7 frappes de touches et est incongru avec presque toutes les autres langues. Si Ruby jamais fait de Python 3 style de la consolidation et la simplification passe , j'espère implicite tout est le premier sur le billot.
    • les conventions sont là pour dire "il y a beaucoup de façons de le faire, ont toutes des avantages et des inconvénients, permet à tous d'accord pour le faire de cette façon parce que la cohérence est plus important que les avantages de l'un des ci-dessus". Il n'est pas sur l'enregistrement des frappes au clavier, il s'agit de rendre le code plus facile à lire par ne pas l'encombrer avec verbosities qui sont clairement sous-entendue. Aussi, je ne reçois pas votre point de vue sur la façon d'utiliser explicite returns fait du type de ce que vous êtes de retour plus facile à deviner.
    • À l'exception de toute évidence, elle n'a pas réellement rendre les choses plus facile à lire! La magie et la clarté ne sont pas l'ame chose.
    • comment est-ce clair? C'est plus facile à lire pour moi. Il pourrait être juste que vous n'êtes pas utilisé pour l'instant.
    • "le principal argument pour l'utilisation explicite des retours, c'est que c'est source de confusion pour les personnes venant d'autres langues" Non, l'argument principal est qu'il ne communique pas les développeurs de l'intention, mais plutôt de le cacher. La distinction entre les procédures et la fonction est essentielle pour la compréhension du code, quel que soit le langage de programmation. En enregistrant 5 touches, vous êtes ce qui en fait beaucoup plus difficile.
    • si elle est "fonction" ou "procédure" devrait être évident à partir de la dénomination et/ou la mise en œuvre. En outre, il est souvent utile pour les "procédures" de retour d'un statut ou de self pour le chaînage.
    • Le problème est que le langage de programmation Ruby renvoie la valeur de la dernière ligne si le programmeur en retrait ou pas. La accepté de répondre illustre ce problème clairement. Ce qui est peut-être évident pour vous, peut-être pas si évident à vos collègues ou à votre soi futur. L'ajout de l'instruction return ajoute de la valeur sémantique, la clarté et communique son intention dans une façon non ambiguë.

    InformationsquelleAutor ndnenkov
  6. 4

    Je suis d'accord avec Ben Hughes et en désaccord avec Tim Holt, parce que la question mentionne le chemin définitif Python-t-il et vous demande si Ruby est une norme similaire.

    Il n'.

    C'est une caractéristique bien connue de la langue que quiconque devrait déboguer un problème dans le rubis raisonnablement censé le savoir.

    • Je suis d'accord avec vous dans la théorie, mais dans la pratique, les programmeurs font des erreurs et de désordre. Affaire au point, nous savons tous que vous utilisez "==" dans une condition et pas de "=", mais nous avons TOUS fait cette erreur avant et ne le savais pas, jusqu'à ce que plus tard.
    • Je ne suis pas adressant tous les cas d'utilisation particulier, je suis juste de répondre à la question. Il est explicitement mauvais style, tel que choisi par la communauté, l'utilisation de la return mot clé lors de l'inutile.
    • Juste assez. Je suis en train de dire que le style que vous mentionnez peut conduire à des erreurs si vous n'êtes pas prudent. Basé sur mon expérience, j'ai personnellement l'avocat d'un style différent.
    • Par ailleurs, cette question a été posée avant le style guide a été écrit, donc les réponses qui sont en désaccord ne sont pas nécessairement mauvais, juste obsolètes. Je suis tombé ici en quelque sorte bien et n'ai pas vu le lien que j'ai fourni, j'ai donc pensé à quelqu'un d'autre pourrait se retrouver ici aussi.
    • Vrai. Je suppose qu'à la base, j'ai pas beaucoup de programmeurs qui collent avec les guides de style ou de lire dans la profondeur sur une langue lorsqu'ils commencent à travailler avec elle. Si ils sont les programmeurs expérimentés, ils êtes à la recherche de fonctionnalités telles que le tri de tableaux, chaîne de remplacement, la définition des classes, etc. Seulement si elles vont dans une langue en profondeur-ils commencer à trouver les nuances et les fonctionnalités. L'inconvénient est que cela signifie plain vanilla code qui ne fait pas profiter de certaines fonctionnalités de la langue et n'a donc pas l'utiliser à pleine capacité.
    • "la question mentionne le chemin définitif Python-t-il et vous demande si Ruby est une norme similaire. Il n'." Est-il considéré comme officiel ou fortement soutenu par les auteurs de la langue, comme la PEP 8 est? Ou comme le Zen de Python qui est inclus dans l'interpréteur Python (import this).
    • Ce n'est pas une "norme" officielle. Le rubis guide de style utilisée par rubocop et liés à ci-dessus avec la demande il y a là, par Devon Parsons, est créé par un non-core ruby hacker. Ainsi, le commentaire par Devon est factuellement fausse. Bien sûr, vous pouvez TOUJOURS l'utiliser mais il n'est pas un standard.

    InformationsquelleAutor Devon Parsons
  7. 1

    C'est une question de style que vous préférez, pour la plupart. Vous devez utiliser le mot-clé return si vous souhaitez revenir de quelque part au moyen d'une méthode.

    InformationsquelleAutor Praveen Angyan
  8. 0

    Comme dit Ben. Le fait que "la valeur de retour d'une méthode ruby est la valeur de retour de la dernière instruction dans le corps de la fonction" provoque le mot-clé return être rarement utilisé dans la plupart des méthodes ruby.

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


  # function code 

  @list     # returns the list
end
    • vous pouvez également écrire "retour nul si failed_some_early_check" si votre intention est toujours clair
    • Ce n'est pas un code valide, faisant de la réponse à confusion.
    • Fixe. L'espoir qui fonctionne pour vous maintenant.
    • J'ai été réellement se plaindre de l'instruction si, pas le nom de la méthode.
    • oh le manque la fin :). L'a obtenu. fixe pour pacifier les autres commentaires trop de Mike.
    • Pourquoi ne pas if failed_check then nil else @list end? C'est vraiment fonctionnel.
    • Pas clair sur les raisons de if then else est fonctionnel.. la raison de ce style est qu'il réduit de nidification par les sorties. À mon humble avis aussi plus lisible.
    • Un si-bloc est "fonctionnelle" parce que c'est une expression. Votre code est asymétrique. Si vous avez besoin d'un retour anticipé, puis d'utiliser des return à la fin de votre méthode. Si vous ne voulez pas explicite return à la fin, puis le faire à ma façon. Être cohérent.

    InformationsquelleAutor Gishu