Y a-t-il une boucle "do ... while" dans Ruby?

J'utilise ce code pour permettre à l'utilisateur d'entrer des noms pendant que le programme les stocke dans un tableau jusqu'à ce qu'ils entrent une chaîne vide (ils doivent appuyer sur Entrée après chaque nom):

people = []
info = 'a' # must fill variable with something, otherwise loop won't execute

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

Ce code serait beaucoup plus agréable dans une boucle do ... while:

people = []

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

Dans ce code, je n'ai pas à attribuer d'informations à une chaîne aléatoire.

Malheureusement, ce type de boucle ne semble pas exister dans Ruby. Quelqu'un peut-il suggérer une meilleure façon de procéder?

ATTENTION :

Le begin <code> end while <condition>est rejeté par l'auteur de Ruby, 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 d'e-mails le 23 novembre 2005 où Matz déclare:

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

Le wiki de RosettaCode a une histoire similaire:

En novembre 2005, Yukihiro Matsumoto, le créateur de Ruby, a regretté cette fonctionnalité de boucle et a suggéré d'utiliser la boucle Kernel #.

J'ai trouvé l'extrait suivant lors de la lecture de la source Tempfile#initializedans la bibliothèque principale Ruby:

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)

À première vue, j'ai supposé que le modificateur while serait évalué avant le contenu de begin ... end, mais ce n'est pas le cas. Observer:

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

Comme vous vous en doutez, la boucle continuera de s'exécuter tant que le modificateur est vrai.

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

Bien que je serais heureux de ne plus jamais revoir cet idiome, commencez ... fin est assez puissant. Voici un idiome commun pour mémoriser une méthode à une ligne sans paramètres:

def expensive
  @expensive ||= 2 + 2
end

Voici un moyen laid mais rapide de mémoriser 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

Écrit à l'origine par Jeremy Voorhis . Le contenu a été copié ici car il semble avoir été retiré du site d'origine. Des copies peuvent également être trouvées dans les archives Web et sur Ruby Buzz Forum . -Bill le lézard

Comme ça:

people = []

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

Référence: Ruby's Hidden do {} while () Loop

Que dis-tu de ça?

people = []

until (info = gets.chomp).empty?
  people += [Person.new(info)]
end

Voici l'article en texte intégral du lien mort de hubbardr vers mon blog.

J'ai trouvé l'extrait suivant lors de la lecture de la source Tempfile#initializedans la bibliothèque principale Ruby:

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)

À première vue, j'ai supposé que le whilemodificateur serait évalué avant le contenu de begin...end, mais ce n'est pas le cas. Observer:

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

Comme vous vous en doutez, la boucle continuera de s'exécuter tant que le modificateur est vrai.

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

Bien que je serais heureux de ne plus jamais revoir cet idiome, il begin...endest assez puissant. Voici un idiome commun pour mémoriser une méthode à une ligne sans paramètres:

def expensive
  @expensive ||= 2 + 2
end

Voici un moyen laid mais rapide de mémoriser 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

Cela fonctionne correctement maintenant:

begin
    # statment
end until <condition>

Mais, il peut être supprimé à l'avenir, car la begindéclaration est contre-intuitive. Voir: http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-core/6745

Matz (Ruby's Creator) a recommandé de le faire de cette façon:

loop do
    # ...
    break if <condition>
end

D'après ce que je comprends, Matz n'aime pas la construction

begin
    <multiple_lines_of_code>
end while <cond>

parce que sa sémantique est différente de

<single_line_of_code> while <cond>

en ce que la première construction exécute le code en premier avant de vérifier la condition, et la deuxième construction teste la condition en premier avant d'exécuter le code (si jamais). Je suppose que Matz préfère conserver la deuxième construction, car elle correspond à une construction de ligne des instructions if.

Je n'ai jamais aimé la deuxième construction, même pour les instructions if. Dans tous les autres cas, l'ordinateur exécute le code de gauche à droite (par exemple || et &&) de haut en bas. Les humains lisent le code de gauche à droite de haut en bas.

Je suggère plutôt les constructions suivantes:

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ées avec le reste de la langue. Mais dans tous les cas, je préfère garder l'exécution de gauche à droite ainsi que la cohérence du langage.

a = 1
while true
  puts a
  a += 1
  break if a > 10
end

En voici un autre:

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

ppl = []
while (input=gets.chomp)
 if !input.empty?
  ppl << input
 else
 p ppl; puts "Goodbye"; break
 end
end