我不知道对于C风格的回调在Ruby中最好的成语 - 或者，如果有什么更好的（而不像C）。在C语言中，我会做一些事情，如：
void DoStuff( int parameter, CallbackPtr callback )
{
// Do stuff
...
// Notify we're done
callback( status_code )
}
请告诉我一个很好的Ruby等价？基本上我想调用类方法的传递，当达到一定条件内“DoStuff”会见
红宝石等同，这是不地道的，应该是：
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
惯用的方法是通过，而不是到的方法的参考块。一个优点块具有超过一个独立的方法是上下文 - 一个块是closure，所以它可以是指从在其被声明的范围的变量。这减少了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
这种“习惯块”是日常的Ruby的一个非常核心的部分，是书籍和教程经常覆盖。该Ruby information section提供链接到有用[在线]学习资源。
惯用的方法是使用一个块：
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
虽然上述的方法都可以包装“调用一个方法”，因为它们创建封闭件，结合Methods也可视为第一类可调用对象：
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
编码愉快！
探讨的话题更多的和更新的代码。
以下版本是推广该技术的尝试，尽管剩余的极其简化，并且不完整的。
我主要是偷 - 下摆，发现灵感 - DataMapper的，这在我看来，相当完整和beatiful的回调的实现。
我强烈建议看一下代码@ http://github.com/datamapper/dm-core/blob/master/lib/dm-core/support/hook.rb
总之，试图重现使用可观察模块的功能是相当耐看的启发。几点注意事项：
码：
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...
这个简单的使用可观察到的表现可能是有用的：http://www.oreillynet.com/ruby/blog/2006/01/ruby_design_patterns_observer.html
所以，这可能是非常“非红宝石”，我不是一个“专业” Ruby开发者，所以如果你们要嫌是，要温柔请:)
Ruby有所谓观察员内置INT模块。我还没有发现它易于使用，但要公平的我没有给它多少机会。在我的项目我都使出创造我自己的事件处理程序的类型（是的，我用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.some_value_changed.add_listener(self, lambda { some_func })
我相信这不是惯用的Ruby和我只是shoehorning我的C＃经验变成一种新的语言，但它已经为我工作。
如果您愿意使用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
我经常在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
我知道这是一个古老的职位，但其他人碰到这种可能发现我的解决方案很有帮助。
http://chrisshepherddev.blogspot.com/2015/02/callbacks-in-pure-ruby-prepend-over.html