如何在Ruby中实现“回调”？

76

我不确定Ruby中C风格回调的最佳用法-还是有更好的东西（不太像C）。在C语言中，我将执行以下操作：

void DoStuff( int parameter, CallbackPtr callback )
{
  // Do stuff
  ...
  // Notify we're done
  callback( status_code )
}

Ruby的等效功能是什么？本质上，当“ DoStuff”中满足某个条件时，我想调用传入的类方法

ruby  callback 
— Justicle
source
这可能有用：github.com/krisleech/wisper
— Kris，

Answers:

97

不常见的红宝石等效为：

def my_callback(a, b, c, status_code)
  puts "did stuff with #{a}, #{b}, #{c} and got #{status_code}"
end

def do_stuff(a, b, c, callback)
  sum = a + b + c
  callback.call(a, b, c, sum)
end

def main
  a = 1
  b = 2
  c = 3
  do_stuff(a, b, c, method(:my_callback))
end

惯用的方法是传递一个块而不是引用一个方法。与独立方法相比，块具有的一个优点是上下文-块是闭包，因此它可以引用声明它的作用域中的变量。这减少了do_stuff传递给回调的参数数量。例如：

def do_stuff(a, b, c, &block)
  sum = a + b + c
  yield sum
end

def main
  a = 1
  b = 2
  c = 3
  do_stuff(a, b, c) { |status_code|
    puts "did stuff with #{a}, #{b}, #{c} and got #{status_code}"
  }
end
— dstnbrkr
source
17
如果您使用的是yield，则不需要在参数列表中使用＆block。
— 道格拉斯
41
我仍然喜欢使用这种&block表示法，因为这样一来，很明显该方法仅通过查看定义的第一行即可占用一个块。
— Patrick Oscity
同意@ Douglas的评论; ＆block让我都很奇怪：(
— gabriel-kaam 2015年
80

这个“惯用的块”是日常Ruby的核心部分，在书籍和教程中经常涉及。在Ruby的信息部分提供了指向有用[在线]学习资源。

惯用的方法是使用一个块：

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

或者也许转换为Proc ; 在这里，我展示了用隐式转换为Proc的“块”&block只是另一个“可调用”值：

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

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

（仅使用上面的格式保存立即保存的块以供以后使用或在其他特殊情况下使用，因为这会增加开销和语法干扰。）

但是，lambda可以同样容易地使用（但这不是惯用的）：

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

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

尽管上述方法在创建闭包时都可以包装“调用方法”，但是绑定方法也可以视为一类可调用对象：

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

另外，有时使用该#send方法很有用（特别是在名称已知的情况下）。这里保存了在上一个示例中创建的中间Method对象。Ruby是一个消息传递系统：

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

祝您编码愉快！

— 社区
source
6

进一步探讨了该主题，并更新了代码。

以下版本是对技术进行概括的尝试，尽管仍然极其简化和不完整。

我很大程度上偷走了DataMapper的回调，并从中找到了灵感，在我看来，这很完整，很漂亮。

我强烈建议看一下代码@ http://github.com/datamapper/dm-core/blob/master/lib/dm-core/support/hook.rb

无论如何，尝试使用Observable模块重现该功能非常吸引人并且具有启发性。一些注意事项：

  • 似乎需要添加方法，因为在注册回调时原始实例方法不可用
  • 包含类是观察者和自我观察者
  • 该示例仅限于实例方法，不支持块，参数等

码：

require 'observer'

module SuperSimpleCallbacks
  include Observable

  def self.included(klass)
    klass.extend ClassMethods
    klass.initialize_included_features
  end

  # the observed is made also observer
  def initialize
    add_observer(self)
  end

  # TODO: dry
  def update(method_name, callback_type) # hook for the observer
    case callback_type
    when :before then self.class.callbacks[:before][method_name.to_sym].each{|callback| send callback}
    when :after then self.class.callbacks[:after][method_name.to_sym].each{|callback| send callback}
    end
  end

  module ClassMethods
    def initialize_included_features
      @callbacks = Hash.new
      @callbacks[:before] = Hash.new{|h,k| h[k] = []}
      @callbacks[:after] = @callbacks[:before].clone
      class << self
        attr_accessor :callbacks
      end
    end

    def method_added(method)
      redefine_method(method) if is_a_callback?(method)
    end

    def is_a_callback?(method)
      registered_methods.include?(method)
    end

    def registered_methods
      callbacks.values.map(&:keys).flatten.uniq
    end

    def store_callbacks(type, method_name, *callback_methods)
      callbacks[type.to_sym][method_name.to_sym] += callback_methods.flatten.map(&:to_sym)
    end

    def before(original_method, *callbacks)
      store_callbacks(:before, original_method, *callbacks)
    end

    def after(original_method, *callbacks)
      store_callbacks(:after, original_method, *callbacks)
    end

    def objectify_and_remove_method(method)
      if method_defined?(method.to_sym)
        original = instance_method(method.to_sym)
        remove_method(method.to_sym)
        original
      else
        nil
      end
    end

    def redefine_method(original_method)
      original = objectify_and_remove_method(original_method)
      mod = Module.new
      mod.class_eval do
        define_method(original_method.to_sym) do
          changed; notify_observers(original_method, :before)
          original.bind(self).call if original
          changed; notify_observers(original_method, :after)
        end
      end
      include mod
    end
  end
end


class MyObservedHouse
  include SuperSimpleCallbacks

  before :party, [:walk_dinosaure, :prepare, :just_idle]
  after :party, [:just_idle, :keep_house, :walk_dinosaure]

  before :home_office, [:just_idle, :prepare, :just_idle]
  after :home_office, [:just_idle, :walk_dinosaure, :just_idle]

  before :second_level, [:party]

  def home_office
    puts "learning and working with ruby...".upcase
  end

  def party
    puts "having party...".upcase
  end

  def just_idle
    puts "...."
  end

  def prepare
    puts "preparing snacks..."
  end

  def keep_house
    puts "house keeping..."
  end

  def walk_dinosaure
    puts "walking the dinosaure..."
  end

  def second_level
    puts "second level..."
  end
end

MyObservedHouse.new.tap do |house|
  puts "-------------------------"
  puts "-- about calling party --"
  puts "-------------------------"

  house.party

  puts "-------------------------------"
  puts "-- about calling home_office --"
  puts "-------------------------------"

  house.home_office

  puts "--------------------------------"
  puts "-- about calling second_level --"
  puts "--------------------------------"

  house.second_level
end
# => ...
# -------------------------
# -- about calling party --
# -------------------------
# walking the dinosaure...
# preparing snacks...
# ....
# HAVING PARTY...
# ....
# house keeping...
# walking the dinosaure...
# -------------------------------
# -- about calling home_office --
# -------------------------------
# ....
# preparing snacks...
# ....
# LEARNING AND WORKING WITH RUBY...
# ....
# walking the dinosaure...
# ....
# --------------------------------
# -- about calling second_level --
# --------------------------------
# walking the dinosaure...
# preparing snacks...
# ....
# HAVING PARTY...
# ....
# house keeping...
# walking the dinosaure...
# second level...

这个简单的Observable使用方法可能会有用：http : //www.oreillynet.com/ruby/blog/2006/01/ruby_design_patterns_observer.html

— 路卡
source
希望您不要介意，但我将您的代码抄写了一下，并为我当前的项目做了一些修改。这是目前简单，但你去那里-随意批评/脱渣等github.com/davesims/Simple-AOP/blob/master/lib/simple_aop.rb
— 戴夫·西姆斯
我对此有一个问题-为什么要使用Observable？我的方法名称与需要集成的类发生冲突，并且简单地调用实例方法（trigger_callbacks）即可正常工作。
— Dave Sims
3

因此，这可能是非常“粗鲁的”，而且我不是“专业”的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＃经验塞进一种新语言中，但这对我有用。

— Ed S.
source
1

如果您愿意使用ActiveSupport（来自Rails），则可以轻松实现

class ObjectWithCallbackHooks
  include ActiveSupport::Callbacks
  define_callbacks :initialize # Your object supprots an :initialize callback chain

  include ObjectWithCallbackHooks::Plugin 

  def initialize(*)
    run_callbacks(:initialize) do # run `before` callbacks for :initialize
      puts "- initializing" # then run the content of the block
    end # then after_callbacks are ran
  end
end

module ObjectWithCallbackHooks::Plugin
  include ActiveSupport::Concern

  included do 
    # This plugin injects an "after_initialize" callback 
    set_callback :initialize, :after, :initialize_some_plugin
  end
end
— 西里尔·杜松·多丽丝
source
0

我经常像下面的示例一样在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
— 2转
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.