Czy w Ruby jest pętla „do… while”?

Używam tego kodu, aby pozwolić użytkownikowi na wprowadzanie nazw, podczas gdy program przechowuje je w tablicy, dopóki nie wprowadzi pustego ciągu (muszą nacisnąć Enter po każdej nazwie):

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

Ten kod wyglądałby znacznie ładniej w pętli do ... while:

people = []

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

W tym kodzie nie muszę przypisywać informacji do jakiegoś losowego ciągu.

Niestety ten typ pętli nie istnieje w Ruby. Czy ktoś może zaproponować lepszy sposób na zrobienie tego?

UWAGA :

Został begin <code> end while <condition>odrzucony przez autora Ruby, Matza. Zamiast tego sugeruje użycie Kernel#loopnp

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

Oto wymiana wiadomości e-mail z 23 listopada 2005 r., W której Matz stwierdza:

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

Wiki RosettaCode ma podobną historię:

W listopadzie 2005 roku Yukihiro Matsumoto, twórca Ruby, żałował tej funkcji pętli i zaproponował użycie pętli Kernel #.

Podczas czytania źródła Tempfile#initializew bibliotece Ruby core znalazłem następujący fragment kodu :

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)

Na pierwszy rzut oka zakładałem, że modyfikator while zostanie oceniony przed zawartością początku ... końca, ale tak nie jest. Przestrzegać:

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

Jak można się spodziewać, pętla będzie nadal działać, dopóki modyfikator będzie prawdziwy.

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

Chociaż byłbym szczęśliwy, że nigdy więcej nie zobaczę tego idiomu, początek ... koniec jest dość potężny. Poniższy typowy idiom zapamiętuje metodę jednowierszową bez parametrów:

def expensive
  @expensive ||= 2 + 2
end

Oto brzydki, ale szybki sposób na zapamiętanie czegoś bardziej złożonego:

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

Pierwotnie napisany przez Jeremy Voorhis . Treść została tutaj skopiowana, ponieważ wygląda na to, że została usunięta z witryny źródłowej. Kopie można również znaleźć w Archiwum internetowym i na forum Ruby Buzz . -Bill Jaszczurka

Lubię to:

people = []

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

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

Co powiesz na to?

people = []

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

Oto pełny artykuł z martwego linku Hubbardra do mojego bloga.

Podczas czytania źródła Tempfile#initializew bibliotece Ruby core znalazłem następujący fragment kodu :

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)

Na pierwszy rzut oka założyłem, że whilemodyfikator będzie oceniany przed zawartością begin...end, ale tak nie jest. Przestrzegać:

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

Jak można się spodziewać, pętla będzie nadal działać, dopóki modyfikator będzie prawdziwy.

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

Chociaż byłbym szczęśliwy, że nigdy więcej nie zobaczę tego idiomu, begin...endjest dość potężny. Poniższy typowy idiom zapamiętuje metodę jednowierszową bez parametrów:

def expensive
  @expensive ||= 2 + 2
end

Oto brzydki, ale szybki sposób na zapamiętanie czegoś bardziej złożonego:

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

Działa to teraz poprawnie:

begin
    # statment
end until <condition>

Ale może zostać usunięty w przyszłości, ponieważ beginoświadczenie jest sprzeczne z intuicją. Widzieć: http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-core/6745

Matz (Ruby's Creator) zalecił zrobienie tego w ten sposób:

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

Z tego, co zbieram, Matz nie lubi konstrukcji

begin
    <multiple_lines_of_code>
end while <cond>

ponieważ jego semantyka jest inna niż

<single_line_of_code> while <cond>

w tym, że pierwsza konstrukcja najpierw wykonuje kod przed sprawdzeniem warunku, a druga konstrukcja najpierw sprawdza warunek, zanim wykona kod (jeśli w ogóle). Rozumiem, że Matz woli zachować drugą konstrukcję, ponieważ pasuje ona do konstrukcji liniowej instrukcji if.

Nigdy nie podobał mi się drugi konstrukt, nawet jeśli instrukcje. We wszystkich innych przypadkach komputer wykonuje kod od lewej do prawej (np. || i &&) od góry do dołu. Ludzie czytają kod od lewej do prawej od góry do dołu.

Zamiast tego sugeruję następujące konstrukcje:

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

Nie wiem, czy te sugestie zostaną przeanalizowane z resztą języka. Ale w każdym razie wolę zachować wykonanie od lewej do prawej, a także spójność językową.

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

Oto kolejny:

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