Ruby'de bir "do… while" döngüsü var mı?

Program boş bir dize girene kadar bir dizide saklarken kullanıcı adlarını girmesine izin vermek için bu kodu kullanıyorum (her adın ardından enter tuşuna basmaları gerekir):

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

Bu kod bir do ... while döngüsünde çok daha hoş görünecektir:

people = []

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

Bu kodda bazı rastgele dizelere bilgi atamak zorunda değilim.

Maalesef Ruby'de bu tür bir döngü yok gibi görünüyor. Herkes bunu yapmanın daha iyi bir yolunu önerebilir mi?

DİKKAT :

Bu begin <code> end while <condition>, Ruby'nin yazarı Matz tarafından reddedildi. Bunun yerine Kernel#loop,

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

İşte 23 Kasım 2005'te Matz'ın belirttiği bir e-posta alışverişi :

|> 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'nin benzer bir hikayesi var:

Kasım 2005 boyunca, Ruby'nin yaratıcısı Yukihiro Matsumoto bu döngü özelliğinden pişman oldu ve Kernel # loop'un kullanılmasını önerdi.

Tempfile#initializeRuby çekirdek kitaplığındaki kaynağı okurken aşağıdaki snippet'i buldum :

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)

İlk bakışta, while değiştiricisinin başlangıç ​​... sonundan önce değerlendirileceğini varsaydım, ancak durum böyle değil. Gözlemek:

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

Beklediğiniz gibi, döngü değiştirici doğruyken çalışmaya devam edecektir.

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

Bu deyimi bir daha asla görmekten mutlu olsam da, başlangıç ​​... son oldukça güçlü. Aşağıda, hiçbir parametresiz tek katmanlı bir yöntemi hatırlamak için yaygın bir deyim yer almaktadır:

def expensive
  @expensive ||= 2 + 2
end

İşte daha karmaşık bir şeyi hatırlamanın çirkin ama hızlı bir yolu:

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

Aslen Jeremy Voorhis tarafından yazılmıştır . İçerik, kaynak siteden kaldırılmış gibi göründüğü için buraya kopyalandı. Kopyaları Web Arşivinde ve Ruby Buzz Forumunda da bulabilirsiniz . Kertenkele fatura

Bunun gibi:

people = []

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

Referans: Ruby'nin Hidden'ı {} while () Döngüsü

Buna ne dersin?

people = []

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

İşte hubbardr'ın bloguma olan ölü bağlantısından tam metin makalesi.

Tempfile#initializeRuby çekirdek kitaplığındaki kaynağı okurken aşağıdaki snippet'i buldum :

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)

İlk bakışta, whiledeğiştiricinin içeriğinden önce değerlendirileceğini varsaydım begin...end, ancak durum böyle değil. Gözlemek:

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

Beklediğiniz gibi, döngü değiştirici doğruyken çalışmaya devam edecektir.

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

Bu deyimi bir daha asla görmekten mutlu olsam da begin...end, oldukça güçlü. Aşağıda, hiçbir parametresiz tek katmanlı bir yöntemi hatırlamak için yaygın bir deyim yer almaktadır:

def expensive
  @expensive ||= 2 + 2
end

İşte daha karmaşık bir şeyi hatırlamanın çirkin ama hızlı bir yolu:

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

Bu şimdi doğru çalışıyor:

begin
    # statment
end until <condition>

Ancak, gelecekte kaldırılabilir, çünkü beginifade mantıksızdır. Bkz. Http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-core/6745

Matz (Ruby'nin Yaratıcısı) bu şekilde yapılmasını önerdi:

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

Topladığımdan Matz, yapıyı sevmiyor

begin
    <multiple_lines_of_code>
end while <cond>

çünkü anlambiliminden farklı

<single_line_of_code> while <cond>

ilk yapının, koşulu kontrol etmeden önce kodu yürütmesi ve ikinci yapının, kodu çalıştırmadan önce koşulu test etmesi (eğer varsa). Matz, if ifadelerinin bir satır yapısıyla eşleştiği için ikinci yapıyı korumayı tercih ediyor.

If ifadeleri için bile ikinci yapıyı hiç sevmedim. Diğer tüm durumlarda, bilgisayar kodu soldan sağa (ör. || ve &&) yukarıdan aşağıya yürütür. İnsanlar kodu soldan sağa yukarıdan aşağıya okur.

Bunun yerine aşağıdaki yapıları öneririm:

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

Bu önerilerin dilin geri kalanıyla ayrışıp ayrışmayacağını bilmiyorum. Ancak her durumda, dil tutarlılığını olduğu kadar soldan sağa yürütmeyi tercih ediyorum.

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

İşte burada bir başkası:

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