Jak wydostać się z rubinowego bloku?

Oto 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

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

Myślałem o użyciu przebicia, ale staram się, aby było to ogólne, więc nie chcę dodawać nic konkretnego Foo.

Użyj słowa kluczowego next. Jeśli nie chcesz przejść do następnego elementu, użyj break.

Gdy nextjest używany w bloku, powoduje natychmiastowe wyjście z bloku, zwracając kontrolę do metody iteratora, która może następnie rozpocząć nową iterację poprzez ponowne wywołanie bloku:

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

W przypadku użycia w bloku breakprzekazuje kontrolę poza blok, z iteratora, który wywołał blok, i do pierwszego wyrażenia następującego po wywołaniu iteratora:

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

I wreszcie użycie returnw bloku:

return zawsze powoduje zwrócenie metody zamykającej, niezależnie od tego, jak głęboko jest zagnieżdżona w blokach (z wyjątkiem lambd):

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

Chciałem po prostu móc wydostać się z bloku - coś w rodzaju goto do przodu, niezupełnie związanego z pętlą. W rzeczywistości chcę zerwać z bloku, który jest w pętli bez przerywania pętli. Aby to zrobić, utworzyłem blok w pętli jednoetapowej:

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

Mam nadzieję, że to pomoże następnemu Google'owi, który wyląduje tutaj na podstawie tematu.

Jeśli chcesz, aby powrócić do bloku użyteczną wartość (na przykład przy użyciu #map, #injectetc.), nexta breaktakże przyjąć argumentu.

Rozważ następujące:

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

Odpowiednik przy użyciu 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

Oczywiście zawsze można wyodrębnić potrzebną logikę do metody i wywołać ją z wnętrza bloku:

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

użyj słowa kluczowego breakzamiastreturn

Być może możesz użyć wbudowanych metod do znajdowania określonych elementów w tablicy, zamiast each-ing targetsi robienia wszystkiego ręcznie. Kilka przykładów:

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"

Jednym z przykładów może być zrobienie czegoś takiego:

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

nexti breakwydaje się, że robi to poprawnie w tym uproszczonym przykładzie!

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

wyjście: 1 3 4 5 6 7 8

Aby wyjść z rubinowego bloku, wystarczy użyć returnsłowa kluczowego return if value.nil?