Est-il un “do ... while” boucle en Ruby?

ATTENTION:

La begin <code> end while <condition> est rejeté par Ruby auteur du Matz. Au lieu de cela, il suggère d'utiliser Kernel#loop, par exemple

loop do 
  # some code here
  break if <condition>
end 

Voici un échange de mail dans 23 Nov 2005 où Matz états:

|> Don't use it please.  I'm regretting this feature, and I'd like to
|> remove it in the future if it's possible.
|
|I'm surprised.  What do you regret about it?

Because it's hard for users to tell

  begin <code> end while <cond>

works differently from

  <code> while <cond>

RosettaCode wiki a une histoire similaire:

Au cours de novembre 2005, Yukihiro Matsumoto, le créateur de Ruby, a regretté cette fonction de boucle et a suggéré d'utiliser le Noyau#boucle.

Comme ceci:

people = []

begin
  info = gets.chomp
  people += [Person.new(info)] if not info.empty?
end while not info.empty?

Référence: Le rubis est Caché do {} while () en Boucle

Voici le texte intégral de l'article de hubbardr morts lien vers mon blog.

J'ai trouvé le bout de code suivant lors de la lecture de la source pour Tempfile#initialize dans la librairie principale:

begin
  tmpname = File.join(tmpdir, make_tmpname(basename, n))
  lock = tmpname + '.lock'
  n += 1
end while @@cleanlist.include?(tmpname) or
  File.exist?(lock) or File.exist?(tmpname)

Au premier coup d'œil, j'ai pris le while modificateur sera évaluée avant le contenu de begin...end, mais ce n'est pas le cas. Observer:

>> begin
?>   puts "do {} while ()" 
>> end while false
do {} while ()
=> nil

Que vous attendez, la boucle continuera à exécuter, tandis que le modificateur est vrai.

>> n = 3
=> 3
>> begin
?>   puts n
>>   n -= 1
>> end while n > 0
3
2
1
=> nil

Tandis que je serais heureux de ne jamais voir cet idiome nouveau, begin...end est assez puissant. Ce qui suit est une commune de l'idiome à memoize un one-liner méthode sans paramètres:

def expensive
  @expensive ||= 2 + 2
end

Ici est moche, mais moyen rapide de memoize quelque chose de plus complexe:

def expensive
  @expensive ||=
    begin
      n = 99
      buf = "" 
      begin
        buf << "#{n} bottles of beer on the wall\n" 
        # ...
        n -= 1
      end while n > 0
      buf << "no more bottles of beer" 
    end
end

De ce que je comprends, Il n'aime pas la construction

begin
    <multiple_lines_of_code>
end while <cond>

parce que c'est de la sémantique est différente de celle

<single_line_of_code> while <cond>

en ce que la première construction exécute le code en premier avant de la vérification de l'état,
et la deuxième construire des tests de la condition d'abord avant d'exécuter le code (si jamais). Je le prends Matz préfère garder la deuxième construire car il correspond à une ligne de construction de if.

Je n'ai jamais aimé le deuxième construire, même pour des instructions if. Dans tous les autres cas, l'ordinateur
exécute le code de gauche à droite (eg. || et &&) de haut en bas. L'homme lire le code de gauche à droite
de haut en bas.

Je suggère que les constructions suivantes à la place:

if <cond> then <one_line_code>      # matches case-when-then statement

while <cond> then <one_line_code>

<one_line_code> while <cond>

begin <multiple_line_code> end while <cond> # or something similar but left-to-right

Je ne sais pas si ces suggestions seront analysés avec le reste de la langue. Mais dans tous les cas
Je visez plutôt garder la gauche à la droite de l'exécution ainsi que la langue de la cohérence.

En voici une autre:

people = []
1.times do
  info = gets.chomp
  unless info.empty? 
    people += [Person.new(info)]
    redo
  end
end