Как реализовать “обратный вызов” в Ruby?

This "idiomatic block" is a very core part of everyday Ruby and is covered frequently in books and tutorials. The Ruby information section provides links to useful [online] learning resources.

The idiomatic way is to use a block:

def x(z)
  yield z   # perhaps used in conjunction with #block_given?
end
x(3) {|y| y*y}  # => 9

Or perhaps converted to a Proc; here I show that the "block", converted to a Proc implicitly with &block, is just another "callable" value:

def x(z, &block)
  callback = block
  callback.call(z)
end

# look familiar?
x(4) {|y| y * y} # => 16

(Only use the above form to save the block-now-Proc for later use or in other special cases as it adds overhead and syntax noise.)

However, a lambda can be use just as easily (but this is not idiomatic):

def x(z,fn)
  fn.call(z)
end

# just use a lambda (closure)
x(5, lambda {|y| y * y}) # => 25

While the above approaches can all wrap "calling a method" as they create closures, bound Methods can also be treated as first-class callable objects:

class A
  def b(z)
    z*z
  end
end

callable = A.new.method(:b)
callable.call(6) # => 36

# and since it's just a value...
def x(z,fn)
  fn.call(z)
end
x(7, callable) # => 49

In addition, sometimes it's useful to use the #send method (in particular if a method is known by name). Here it saves an intermediate Method object that was created in the last example; Ruby is a message-passing system:

# Using A from previous
def x(z, a):
  a.__send__(:b, z)
end
x(8, A.new) # => 64

Happy coding!

Так что, это может быть очень "нерубиново", и я не "профессиональный" Ruby-разработчик, так что если вы, ребята, собираетесь шлепнуть, будьте осторожны, пожалуйста :)

Ruby имеет встроенный модуль под названием Observer. Я не нашел его простым в использовании, но, честно говоря, я не дал ему особого шанса. В своих проектах я прибегал к созданию собственного типа EventHandler (да, я много использую C #). Вот основная структура:

class EventHandler

  def initialize
    @client_map = {}
  end

  def add_listener(id, func)
    (@client_map[id.hash] ||= []) << func
  end

  def remove_listener(id)
    return @client_map.delete(id.hash)
  end

  def alert_listeners(*args)
    @client_map.each_value { |v| v.each { |func| func.call(*args) } }
  end

end

Итак, чтобы использовать это, я выставляю его как член класса, доступный только для чтения:

class Foo

  attr_reader :some_value_changed

  def initialize
    @some_value_changed = EventHandler.new
  end

end

Клиенты класса «Foo» могут подписаться на событие, подобное этому:

foo.some_value_changed.add_listener(self, lambda { some_func })

Я уверен, что это не является идиоматическим Ruby, и я просто переношу свой опыт работы с C # на новый язык, но у меня это сработало.

Я часто реализую обратные вызовы в Ruby, как в следующем примере. Это очень удобно в использовании.

class Foo
   # Declare a callback.
   def initialize
     callback( :on_die_cast )
   end

   # Do some stuff.
   # The callback event :on_die_cast is triggered.
   # The variable "die" is passed to the callback block.
   def run
      while( true )
         die = 1 + rand( 6 )
         on_die_cast( die )
         sleep( die )
      end
   end

   # A method to define callback methods.
   # When the latter is called with a block, it's saved into a instance variable.
   # Else a saved code block is executed.
   def callback( *names )
      names.each do |name|
         eval <<-EOF
            @#{name} = false
            def #{name}( *args, &block )
               if( block )
                  @#{name} = block
               elsif( @#{name} )
                  @#{name}.call( *args )
               end
            end
         EOF
      end
   end
end

foo = Foo.new

# What should be done when the callback event is triggered?
foo.on_die_cast do |number|
   puts( number )
end

foo.run