Gibt es in Ruby eine "do ... while" -Schleife?

Ich verwende diesen Code, damit der Benutzer Namen eingeben kann, während das Programm sie in einem Array speichert, bis er eine leere Zeichenfolge eingibt (er muss nach jedem Namen die Eingabetaste drücken):

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

Dieser Code würde in einer do ... while-Schleife viel besser aussehen:

people = []

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

In diesem Code muss ich keiner zufälligen Zeichenfolge Informationen zuweisen.

Leider scheint diese Art von Schleife in Ruby nicht zu existieren. Kann jemand einen besseren Weg vorschlagen, dies zu tun?

VORSICHT :

Das begin <code> end while <condition>wird von Rubys Autor Matz abgelehnt. Stattdessen schlägt er vor Kernel#loop, z

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

Hier ist ein E-Mail-Austausch am 23. November 2005, in dem Matz Folgendes feststellt:

|> 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 hat eine ähnliche Geschichte:

Im November 2005 bedauerte Yukihiro Matsumoto, der Erfinder von Ruby, diese Schleifenfunktion und schlug vor, die Kernel # -Schleife zu verwenden.

Beim Lesen der Quelle Tempfile#initializein der Ruby- Kernbibliothek habe ich den folgenden Ausschnitt gefunden :

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)

Auf den ersten Blick ging ich davon aus, dass der Modifikator while vor dem Inhalt von begin ... end ausgewertet wird, aber das ist nicht der Fall. Beobachten:

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

Wie zu erwarten, wird die Schleife weiterhin ausgeführt, solange der Modifikator wahr ist.

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

Ich würde mich freuen, diese Redewendung nie wieder zu sehen, aber Anfang ... Ende ist ziemlich mächtig. Das Folgende ist eine gebräuchliche Redewendung, um eine Einzeilermethode ohne Parameter auswendig zu lernen:

def expensive
  @expensive ||= 2 + 2
end

Hier ist eine hässliche, aber schnelle Möglichkeit, sich etwas Komplexeres zu merken:

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

Ursprünglich geschrieben von Jeremy Voorhis . Der Inhalt wurde hier kopiert, da er anscheinend von der ursprünglichen Website entfernt wurde. Kopien finden Sie auch im Webarchiv und im Ruby Buzz Forum . - Rechnung die Eidechse

So was:

people = []

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

Referenz: Ruby's Hidden do {} while () Schleife

Wie wäre es damit?

people = []

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

Hier ist der Volltextartikel von Hubbardrs totem Link zu meinem Blog.

Beim Lesen der Quelle Tempfile#initializein der Ruby- Kernbibliothek habe ich den folgenden Ausschnitt gefunden :

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)

Auf den ersten Blick habe ich angenommen, dass der whileModifikator vor dem Inhalt von ausgewertet wird begin...end, aber das ist nicht der Fall. Beobachten:

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

Wie zu erwarten, wird die Schleife weiterhin ausgeführt, solange der Modifikator wahr ist.

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

Ich würde mich freuen, diese Redewendung nie wieder zu sehen, begin...endist aber ziemlich mächtig. Das Folgende ist eine gebräuchliche Redewendung, um eine Einzeilermethode ohne Parameter auswendig zu lernen:

def expensive
  @expensive ||= 2 + 2
end

Hier ist eine hässliche, aber schnelle Möglichkeit, sich etwas Komplexeres zu merken:

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

Das funktioniert jetzt richtig:

begin
    # statment
end until <condition>

Es kann jedoch in Zukunft entfernt werden, da die beginAussage nicht intuitiv ist. Siehe: http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-core/6745

Matz (Ruby's Creator) empfahl dies folgendermaßen:

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

Soweit ich weiß, mag Matz das Konstrukt nicht

begin
    <multiple_lines_of_code>
end while <cond>

weil seine Semantik anders ist als

<single_line_of_code> while <cond>

, dass das erste Konstrukt den Code zuerst ausführt, bevor die Bedingung überprüft wird, und das zweite Konstrukt die Bedingung zuerst testet, bevor es den Code ausführt (falls jemals). Ich nehme an, Matz zieht es vor, das zweite Konstrukt beizubehalten, da es mit einem Zeilenkonstrukt von if-Anweisungen übereinstimmt.

Ich habe das zweite Konstrukt selbst für if-Anweisungen nie gemocht. In allen anderen Fällen führt der Computer den Code von links nach rechts (z. B. || und &&) von oben nach unten aus. Menschen lesen den Code von links nach rechts von oben nach unten.

Ich schlage stattdessen die folgenden Konstrukte vor:

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

Ich weiß nicht, ob diese Vorschläge mit dem Rest der Sprache übereinstimmen. Aber auf jeden Fall bevorzuge ich die Ausführung von links nach rechts sowie die Sprachkonsistenz.

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

Hier ist ein anderes:

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