web-dev-qa-db-fra.com

quel est le point de retour en Ruby?

Quelle est la différence entre return et simplement mettre une variable telle que la suivante:

non-retour

def write_code(number_of_errors)
  if number_of_errors > 1
     mood = "Ask me later"
  else
     mood = "No Problem"
  end  
  mood
end

revenir

def write_code(number_of_errors)
  if number_of_errors > 1
    mood =  "Ask me later"
  else
    mood = puts "No Problem"
  end  
  return mood
end
rubyreturn
76
thenengah

return vous permet d'éclater tôt:

def write_code(number_of_errors)
  return "No problem" if number_of_errors == 0
  badness = compute_badness(number_of_errors)
  "WHAT?!  Badness = #{badness}."
end

Si number_of_errors == 0, Alors "No problem" Sera retourné immédiatement. À la fin d'une méthode, cependant, ce n'est pas nécessaire, comme vous l'avez observé.

Edit: Pour démontrer que return se ferme immédiatement, considérez cette fonction:

def last_name(name)
  return nil unless name
  name.split(/\s+/)[-1]
end

Si vous appelez cette fonction en tant que last_name("Antal S-Z"), elle renverra "S-Z". Si vous l'appelez comme last_name(nil), il renvoie nil. Si return n'a pas abandonné immédiatement, il tentera d'exécuter nil.split(/\s+/)[-1], ce qui générera une erreur.

112
Antal Spector-Zabusky

L'utilisation de "return" n'est pas nécessaire s'il s'agit de la dernière ligne à exécuter dans la méthode, car Ruby renvoie automatiquement la dernière expression évaluée.

Vous n'avez même pas besoin de cette "humeur" finale, ni de ces affectations dans l'instruction IF.

def write_code(number_of_errors)
    if number_of_errors > 1
       "ERROR"
    else
       "No Problem"
    end  
end

puts write_code(10)

Sortie:

ERREUR

38
danneu

Ruby revient toujours! le meilleur moyen est

def write_code(number_of_errors)
  (number_of_errors > 1)? "ERROR" : "No Problem"
end

cela signifie que si number_of_errors> 1, il retournera ERROR else Pas de problème

4
msroot

J'utilise return lorsque je parcours une liste et je souhaite quitter la fonction si un membre de la liste répond à un critère. Je pourrais accomplir cela avec une seule déclaration comme:

list.select{|k| k.meets_criteria}.length == 0

dans certaines situations, mais

list.each{|k| return false if k.meets_criteria}

est aussi une ligne - avec, à mon avis, une certaine flexibilité supplémentaire. Par exemple, le premier exemple suppose qu'il s'agit de la seule ligne de la méthode et que nous voulons revenir à partir de ce point quoi qu'il arrive. Mais s'il s'agit d'un test pour voir s'il est sûr de poursuivre avec le reste de la méthode, le premier exemple devra gérer cela d'une manière différente.

MODIFIER:

Pour ajouter une certaine flexibilité, considérez la ligne de code suivante:

list_of_method_names_as_symbols.each{|k| list_of_objects.each{|j| return k if j.send(k)}}

Je suis sûr que cela peut être accompli, en une seule ligne, sans return, mais du haut de ma tête, je ne vois pas comment.

Mais c'est maintenant une ligne de code assez flexible qui peut être appelée avec n'importe quelle liste de méthodes booléennes et une liste d'objets qui implémentent ces méthodes.

MODIFIER

Il convient de noter que je suppose que cette ligne est à l'intérieur d'une méthode, pas d'un bloc.

Mais c'est surtout un choix stylistique, je pense que dans la plupart des situations, vous pouvez et devriez éviter d'utiliser return.

4
philosodad

Son Nice Ruby donne cette bonne caractéristique de ne pas spécifier explicitement l'instruction de retour, mais je pense simplement, en tant que norme de programmation, que l'on devrait toujours s'efforcer de spécifier des instructions de "retour" partout où cela est nécessaire. Cela aide à faire du code plus lisible pour quelqu'un qui vient d'horizons différents comme C++, Java, PHP etc. et apprendre Ruby. L'instruction "return" ne nuira à rien, alors pourquoi ignorer les méthodes de retour conventionnelles et plus standard des fonctions.

3
Kush

Une petite mise en garde pour ceux qui viennent d'autres langues. Supposons que vous ayez une fonction comme celle des OP et que vous utilisiez la règle de la "dernière chose calculée" pour définir automatiquement votre valeur de retour:

def write_code(number_of_errors)
  if number_of_errors > 1
     mood = "Ask me later"
  else
     mood = "No Problem"
  end  
end

et disons que vous ajoutez une instruction de débogage (ou de journalisation):

def write_code(number_of_errors)
  if number_of_errors > 1
     mood = "Ask me later"
  else
     mood = "No Problem"
  end  
  puts "### mood = #{mood}"
end

Maintenant devinez quoi. Vous avez cassé votre code, car le puts retourne nil, qui devient maintenant la valeur de retour de la fonction.

La solution est de prendre l'habitude de toujours mettre explicitement la valeur de retour sur la dernière ligne, comme l'OP l'a fait:

def write_code(number_of_errors)
  if number_of_errors > 1
     mood = "Ask me later"
  else
     mood = "No Problem"
  end  
  puts "### mood = #{mood}"
  mood
end
0
Tom Hundt