les meilleures pratiques pour les valeurs de retour des méthodes de rubis

Question

je trouve moi-même faire ce qui suit beaucoup pour définir les valeurs de retour des méthodes de rubis:

def foo 
    val = (some expression) 
    val 
end 

Cela semble toujours un peu artificiel. Quelle est la meilleure pratique ici?

Answer 1

Il n'est pas nécessaire de l'enregistrer dans une variable sauf si (une expression) est lourde et sera appelée plusieurs fois. Dans ce cas, vous pourriez vouloir le mettre en cache.

Je voudrais aller avec soit:

def foo 
    (some expression) 
end 

ou pour la mise en cache:

def foo 
    @val ||= (some expression) 
end 

Answer 2

Tant que votre dernière expression évalue celle que vous voulez retourner, vous êtes en sécurité.

def foo 
    val = (some expression) 
end 

est identique à celui de la question qu'il évalue à (some expression), tout comme le ferait val.

Answer 3

Notez que comme de Ruby 1.9, vous pouvez utiliser Object#tap pour enregistrer une valeur pour le retour à la fin si vous devez faire autre chose avec la valeur avant de le renvoyer:

def foo 
    (some expression).tap do |val| 
    # use val here 
    end 
    # The return value of the tap is _val_ 
    # and hence the return value of your method 
end 

Answer 4

Les variables temporaires sont mauvaises parce qu'elles augmentent la connectivité.

http://www.mgroves.com/what-is-connascence

ReplaceTempWithQuery est un refactoring J'utilise beaucoup:

def discount_price 
    base_price = quantity * item_price 
    if (base_price > 1000) 
    base_price * 0.95 
    else 
    base_price * 0.98 
    end 
end 

code

après refactoring:

def discount_price 
    if (base_price > 1000) 
    base_price * 0.98 
    else 
    base_price * 0.98 
    end 
end 

def base_price 
    quantity * item_price 
end 

http://www.refactoring.com/catalog/replaceTempWithQuery.html

Answer 5

Personnellement, je aime en utilisant retour pour appeler explicitement ce qui est retourné. C'est un code supplémentaire que Ruby ne vous oblige pas à utiliser, mais cela m'aide à la lisibilité. Cela vous permet également d'avoir plusieurs points de sortie dans votre méthode puisque l'exécution de votre méthode s'arrêtera dès que le retour est appelé.

Ce n'est vraiment pas très différent de l'exemple que vous avez donné dans votre question initiale.

def foo 
    val = (some expression) 
    val 
end 

pourrait ressembler à

def foo 
    return (some expression) 
end 

Answer 6

je fais parfois ce que vous avez dans votre question.

Quelques cas où je le fais sont:

1. Quand je fais la programmation imperitive (foo = Foo.new; foo.modify_state; foo)
2. Si je veux valider un objet avant de revenir, mais comme mentionné Phrogz, Object#tap peut aider ici (foo = new_foo; raise if foo.empty?; foo)
3. Quand je veux préciser que je retourne une variable, plutôt que de faire plus de choses (do_this; do_that; do_other_thing; result #done!)

Il peut cependant indiquer des odeurs de code, comme dans le cas 1.