Bagaimana cara keluar dari blok ruby?

Ini adalah Bar#do_things:

class Bar   
  def do_things
    Foo.some_method(x) do |x|
      y = x.do_something
      return y_is_bad if y.bad? # how do i tell it to stop and return do_things? 
      y.do_something_else
    end
    keep_doing_more_things
  end
end

Dan di sini adalah Foo#some_method:

class Foo
  def self.some_method(targets, &block)
    targets.each do |target|
      begin
        r = yield(target)
      rescue 
        failed << target
      end
    end
  end
end

Saya berpikir tentang menggunakan kenaikan gaji, tetapi saya mencoba membuatnya generik, jadi saya tidak ingin memasukkan sesuatu yang spesifik Foo.

Gunakan kata kunci next. Jika Anda tidak ingin melanjutkan ke item berikutnya, gunakan break.

Ketika nextdigunakan di dalam blok, itu menyebabkan blok untuk segera keluar, mengembalikan kontrol ke metode iterator, yang kemudian dapat memulai iterasi baru dengan memohon blok lagi:

f.each do |line|              # Iterate over the lines in file f
  next if line[0,1] == "#"    # If this line is a comment, go to the next
  puts eval(line)
end

Saat digunakan dalam sebuah blok, breaktransfer kontrol keluar dari blok, keluar dari iterator yang memanggil blok, dan ke ekspresi pertama setelah doa iterator:

f.each do |line|             # Iterate over the lines in file f
  break if line == "quit\n"  # If this break statement is executed...
  puts eval(line)
end
puts "Good bye"              # ...then control is transferred here

Dan akhirnya, penggunaan returndalam blok:

return selalu menyebabkan metode penutup untuk kembali, terlepas dari seberapa dalam bersarang di dalam blok itu (kecuali dalam kasus lambdas):

def find(array, target)
  array.each_with_index do |element,index|
    return index if (element == target)  # return from find
  end
  nil  # If we didn't find the element, return nil
end

Saya hanya ingin bisa keluar dari blok - semacam goto ke depan, tidak benar-benar terkait dengan loop. Bahkan, saya ingin memecah blok yang ada dalam satu lingkaran tanpa mengakhiri loop. Untuk melakukan itu, saya membuat blok loop satu iterasi:

for b in 1..2 do
    puts b
    begin
        puts 'want this to run'
        break
        puts 'but not this'
    end while false
    puts 'also want this to run'
end

Semoga ini bisa membantu googler berikutnya yang mendarat di sini berdasarkan baris subjek.

Jika Anda ingin blok Anda untuk mengembalikan nilai yang berguna (misalnya saat menggunakan #map, #inject, dll), nextdanbreak juga menerima argumen.

Pertimbangkan yang berikut ini:

def contrived_example(numbers)
  numbers.inject(0) do |count, x|
    if x % 3 == 0
      count + 2
    elsif x.odd?
      count + 1
    else 
      count
    end
  end
end

Setara menggunakan next:

def contrived_example(numbers)
  numbers.inject(0) do |count, x|
    next count if x.even?
    next (count + 2) if x % 3 == 0
    count + 1
  end
end

Tentu saja, Anda selalu dapat mengekstrak logika yang diperlukan ke dalam metode dan menyebutnya dari dalam blok Anda:

def contrived_example(numbers)
  numbers.inject(0) { |count, x| count + extracted_logic(x) }
end

def extracted_logic(x)
  return 0 if x.even?
  return 2 if x % 3 == 0
  1
end

gunakan kata kunci breakalih-alihreturn

Mungkin Anda dapat menggunakan built-in metode untuk menemukan item tertentu dalam Array, bukan each-ing targetsdan melakukan segala sesuatu dengan tangan. Beberapa contoh:

class Array
  def first_frog
    detect {|i| i =~ /frog/ }
  end

  def last_frog
    select {|i| i =~ /frog/ }.last
  end
end

p ["dog", "cat", "godzilla", "dogfrog", "woot", "catfrog"].first_frog
# => "dogfrog"
p ["hats", "coats"].first_frog
# => nil
p ["houses", "frogcars", "bottles", "superfrogs"].last_frog
# => "superfrogs"

Salah satu contoh akan melakukan sesuatu seperti ini:

class Bar
  def do_things
    Foo.some_method(x) do |i|
      # only valid `targets` here, yay.
    end
  end
end

class Foo
  def self.failed
    @failed ||= []
  end

  def self.some_method(targets, &block)
    targets.reject {|t| t.do_something.bad? }.each(&block)
  end
end

nextdan breaktampaknya melakukan hal yang benar dalam contoh sederhana ini!

class Bar
  def self.do_things
      Foo.some_method(1..10) do |x|
            next if x == 2
            break if x == 9
            print "#{x} "
      end
  end
end

class Foo
    def self.some_method(targets, &block)
      targets.each do |target|
        begin
          r = yield(target)
        rescue  => x
          puts "rescue #{x}"
        end
     end
   end
end

Bar.do_things

output: 1 3 4 5 6 7 8

Untuk keluar dari blok ruby ​​cukup gunakan returnkata kunci return if value.nil?