C'è un ciclo "do ... while" in Ruby?

Sto usando questo codice per consentire all'utente di inserire i nomi mentre il programma li memorizza in un array fino a quando non inseriscono una stringa vuota (devono premere Invio dopo ogni nome):

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

Questo codice sarebbe molto più bello in un do ... while loop:

people = []

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

In questo codice non devo assegnare informazioni ad alcuna stringa casuale.

Sfortunatamente questo tipo di loop non sembra esistere in Ruby. Qualcuno può suggerire un modo migliore per farlo?

ATTENZIONE :

Il begin <code> end while <condition>è rifiutato dall'autore di Ruby Matz. Invece suggerisce di usare Kernel#loop, ad es

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

Ecco uno scambio di email nel 23 novembre 2005 in cui Matz afferma:

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

La wiki di RosettaCode ha una storia simile:

Nel novembre 2005, Yukihiro Matsumoto, il creatore di Ruby, si è pentito di questa funzione del ciclo e ha suggerito di usare il ciclo Kernel #.

Ho trovato il seguente frammento durante la lettura della fonte Tempfile#initializenella libreria principale di 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)

A prima vista, ho ipotizzato che il modificatore while sarebbe stato valutato prima del contenuto di begin ... end, ma non è così. Osservare:

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

Come prevedibile, il ciclo continuerà a essere eseguito mentre il modificatore è true.

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

Mentre sarei felice di non rivedere mai più questo idioma, inizio ... fine è abbastanza potente. Di seguito è riportato un linguaggio comune per memorizzare un metodo one-liner senza parametri:

def expensive
  @expensive ||= 2 + 2
end

Ecco un modo brutto, ma rapido per memorizzare qualcosa di più complesso:

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

Originariamente scritto da Jeremy Voorhis . Il contenuto è stato copiato qui perché sembra essere stato rimosso dal sito di origine. Copie si possono trovare anche nell'Archivio Web e nel Forum di Ruby Buzz . -Bill the Lizard

Come questo:

people = []

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

Riferimento: Ruby's Hidden do {} while () Loop

Cosa ne pensi di questo?

people = []

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

Ecco l'articolo di testo completo dal link morto di hubbardr al mio blog.

Ho trovato il seguente frammento durante la lettura della fonte Tempfile#initializenella libreria principale di 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)

A prima vista, ho ipotizzato che il whilemodificatore sarebbe stato valutato prima del contenuto di begin...end, ma non è così. Osservare:

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

Come prevedibile, il ciclo continuerà a essere eseguito mentre il modificatore è true.

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

Mentre sarei felice di non rivedere mai più questo idioma, begin...endè abbastanza potente. Di seguito è riportato un linguaggio comune per memorizzare un metodo one-liner senza parametri:

def expensive
  @expensive ||= 2 + 2
end

Ecco un modo brutto, ma rapido per memorizzare qualcosa di più complesso:

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

Ora funziona correttamente:

begin
    # statment
end until <condition>

Ma potrebbe essere rimosso in futuro, perché l' beginaffermazione è controintuitiva. Vedi: http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-core/6745

Matz (Ruby Creator) ha raccomandato di farlo in questo modo:

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

Da quello che raccolgo, Matz non piace il costrutto

begin
    <multiple_lines_of_code>
end while <cond>

perché, la sua semantica è diversa da

<single_line_of_code> while <cond>

in quanto il primo costrutto esegue il codice prima di verificare la condizione e il secondo costrutto verifica la condizione prima di eseguire il codice (se mai). Presumo che Matz preferisca mantenere il secondo costrutto perché corrisponde a un costrutto di riga delle istruzioni if.

Non mi è mai piaciuto il secondo costrutto neanche per le dichiarazioni if. In tutti gli altri casi, il computer esegue il codice da sinistra a destra (ad es. || e &&) dall'alto verso il basso. Gli umani leggono il codice da sinistra a destra dall'alto verso il basso.

Suggerisco invece i seguenti costrutti:

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

Non so se questi suggerimenti analizzeranno il resto della lingua. Ma in ogni caso preferisco mantenere l'esecuzione da sinistra a destra e la coerenza del linguaggio.

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

Eccone un altro:

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