blocks|key|1415518|text|ruby的等价物不是惯用的，应该是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1415519|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+%2B+b+%2B+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|code-block|syntax|javascript|1415520|惯用的方法是传递一个块，而不是对方法的引用。与独立方法相比，块的一个优点是上下文--块是一个closure，因此它可以引用声明它的作用域中的变量。这减少了do_stuff需要传递给回调的参数数量。例如：|offset|length|1415521|def+do_stuff(a,+b,+c,+&block)
++sum+=+a+%2B+b+%2B+c
++yield+sum
end

def+main
++a+=+1
++b+=+2
++c+=+3
++do_stuff(a,+b,+c)+{+%7Cstatus_code%7C
++++puts+"did+stuff+with+#{a},+#{b},+#{c}+and+got+#{status_code}"
++}
end|1415522|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Closure_(computer_science))^0|0|0|1A|7|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@$I|X|J|Y|1|Z]]|A|$]]|$1|K|3|L|5|D|7|10|8|@]|9|@]|A|$E|F]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

The ruby equivalent, which isn't idiomatic, would be:

<pre><code>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
</code></pre>

The idiomatic approach would be to pass a block instead of a reference to a method. One advantage a block has over a freestanding method is context - a block is a <a href="http://en.wikipedia.org/wiki/Closure_(computer_science)" rel="noreferrer">closure</a>, so it can refer to variables from the scope in which it was declared. This cuts down on the number of parameters do_stuff needs to pass to the callback. For instance:

<pre><code>def do_stuff(a, b, c, &amp;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
</code></pre>

blocks|key|1415596|text|我经常用Ruby实现回调，如下面的例子所示。它使用起来非常舒服。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1415597|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+%2B+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+%7Cname%7C
+++++++++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+%7Cnumber%7C
+++puts(+number+)
end

foo.run|code-block|syntax|javascript|1415598|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I often implement callbacks in Ruby like in the following example. It's very comfortable to use.

<pre><code>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 &lt;&lt;-EOF
 @#{name} = false
 def #{name}( *args, &amp;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
</code></pre>

blocks|key|1200562|text|我知道这是一个古老的帖子，但其他遇到这个问题的人可能会发现我的解决方案很有帮助。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1200563|http://chrisshepherddev.blogspot.com/2015/02/callbacks-in-pure-ruby-prepend-over.html|offset|length|1200564|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|2D|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@$D|O|E|P|1|Q]]|A|$]]|$1|F|3|-4|5|6|7|R|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|C]]]]

I know this is an old post, but others that come across this may find my solution helpful.

<a href="http://chrisshepherddev.blogspot.com/2015/02/callbacks-in-pure-ruby-prepend-over.html" rel="nofollow">http://chrisshepherddev.blogspot.com/2015/02/callbacks-in-pure-ruby-prepend-over.html</a>

blocks|key|1415734|text|如果您愿意使用ActiveSupport+(来自Rails)，那么您就有了一个简单的实现|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1415735|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|code-block|syntax|javascript|1415736|entityMap|0|LINK|mutability|MUTABLE|url|https://api.rubyonrails.org/classes/ActiveSupport/Callbacks.html^0|7|D|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

If you are willing to use <a href="https://api.rubyonrails.org/classes/ActiveSupport/Callbacks.html" rel="nofollow noreferrer">ActiveSupport</a> (from Rails), you have a straightforward implementation

<pre><code>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
</code></pre>

blocks|key|1200679|text|我知道这是一个古老的帖子，但我在尝试解决类似的问题时发现了它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1200680|这是一个非常优雅的解决方案，最重要的是，它可以在有或没有回调的情况下工作。|1200681|1200682|假设我们有Arithmetic类，它实现了对它们的基本操作-+addition和subtraction。|offset|length|style|CODE|1200683|class+Arithmetic
++def+addition(a,+b)
++++a+%2B+b
++end

++def+subtraction(a,+b)
++++a+-+b
++end
end|code-block|syntax|javascript|1200684|我们希望为每个操作添加一个回调，该回调将对输入数据和结果执行一些操作。|1200685|在下面的示例中，我们将实现接受Ruby块的after_operation方法，该块将在操作后执行。|1200686|class+Arithmetic
++def+after_operation(&block)
++++@after_operation_callback+=+block
++end

++def+addition(a,+b)
++++do_operation('%2B',+a,+b)
++end

++def+subtraction(a,+b)
++++do_operation('-',+a,+b)
++end

++private

++def+do_operation(sign,+a,+b)
++++result+=
++++++case+sign
++++++when+'%2B'
++++++++a+%2B+b
++++++when+'-'
++++++++a+-+b
++++++end

++++if+callback+=+@after_operation_callback
++++++callback.call(sign,+a,+b,+result)
++++end

++++result
++end
end|1200687|使用with+callback：|1200688|callback+=+->+(sign,+a,+b,+result)+do
++puts+"#{a}+#{sign}+#{b}+=+#{result}"
end

arithmetic+=+Arithmetic.new
arithmetic.after_operation(&callback)

puts+arithmetic.addition(1,+2)
puts+arithmetic.subtraction(3,+1)|1200689|输出：|1200690|1+%2B+2+=+3
3
3+-+1+=+2
2|1200691|entityMap^0|0|0|0|5|A|V|8|14|B|0|0|0|L|F|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|15|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|16|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|17|8|@]|9|@]|A|$]]|$1|E|3|F|5|6|7|18|8|@$G|19|H|1A|I|J]|$G|1B|H|1C|I|J]|$G|1D|H|1E|I|J]]|9|@]|A|$]]|$1|K|3|L|5|M|7|1F|8|@]|9|@]|A|$N|O]]|$1|P|3|Q|5|6|7|1G|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|1H|8|@$G|1I|H|1J|I|J]]|9|@]|A|$]]|$1|T|3|U|5|M|7|1K|8|@]|9|@]|A|$N|O]]|$1|V|3|W|5|6|7|1L|8|@]|9|@]|A|$]]|$1|X|3|Y|5|M|7|1M|8|@]|9|@]|A|$N|O]]|$1|Z|3|10|5|6|7|1N|8|@]|9|@]|A|$]]|$1|11|3|12|5|M|7|1O|8|@]|9|@]|A|$N|O]]|$1|13|3|-4|5|6|7|1P|8|@]|9|@]|A|$]]]|14|$]]

I know this is an old post, but I found it when tried to solve a similar problem.
It's a really elegant solution, and most importantly, it can work with and without a callback.
<hr />
Let's say we have the <code>Arithmetic</code> class which implements basic operations on them — <code>addition</code> and <code>subtraction</code>.
<pre class="lang-rb prettyprint-override"><code>class Arithmetic
 def addition(a, b)
 a + b
 end

 def subtraction(a, b)
 a - b
 end
end
</code></pre>
And we want to add a callback for each operation which will do something with the input data and result.
In the below example we will implement the <code>after_operation</code> method which accepts the Ruby block which will be executed after an operation.
<pre class="lang-rb prettyprint-override"><code>class Arithmetic
 def after_operation(&amp;block)
 @after_operation_callback = block
 end

 def addition(a, b)
 do_operation('+', a, b)
 end

 def subtraction(a, b)
 do_operation('-', a, b)
 end

 private

 def do_operation(sign, a, b)
 result =
 case sign
 when '+'
 a + b
 when '-'
 a - b
 end

 if callback = @after_operation_callback
 callback.call(sign, a, b, result)
 end

 result
 end
end
</code></pre>
Using with callback:
<pre class="lang-rb prettyprint-override"><code>callback = -&gt; (sign, a, b, result) do
 puts &quot;#{a} #{sign} #{b} = #{result}&quot;
end

arithmetic = Arithmetic.new
arithmetic.after_operation(&amp;callback)

puts arithmetic.addition(1, 2)
puts arithmetic.subtraction(3, 1)
</code></pre>
Output:
<pre><code>1 + 2 = 3
3
3 - 1 = 2
2
</code></pre>

I'm not sure of the best idiom for C style call-backs in Ruby - or if there is something even better ( and less like C ). In C, I'd do something like:

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

Whats a good Ruby equivalent? Essentially I want to call a passed in class method, when a certain condition is met within "DoStuff"

How to implement a "callback" in Ruby?

我不确定Ruby中C风格回调的最好习惯用法是什么--或者是否有更好的东西(不太像C语言)。在C语言中，我会这样做：void DoStuff( int parameter, CallbackPtr callback ){  // Do stuff  ...  // Notify we're done  callback(...

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

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

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

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

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