blocks|key|67913|text|send和eval的全部意义在于您可以动态地更改命令。如果您要执行的方法是固定的，那么您可以在不使用send或eval的情况下硬连接该方法。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|67914|receiver.fixed_method(argument)|code-block|syntax|javascript|67915|但是当你想调用一个变化的或者事先不知道的方法时，你就不能直接写了。因此使用send或eval。|67916|receiver.send(method_that_changes_dynamically,+argument)
eval+"#{code_to_evaluate_that_changes_more_dramatically}"|67917|正如您所注意到的，send的其他用途是，您可以使用send调用具有显式接收器的方法。|67918|entityMap^0|0|4|5|4|1E|4|1J|4|0|0|11|4|16|4|0|0|9|4|P|4|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|12|8|@$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|17|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|18|8|@$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|1D|8|@]|D|@]|E|$]]]|R|$]]

The whole point of <code>send</code> and <code>eval</code> is that you can change the command dynamically. If the method you want to execute is fixed, then you can hard-wire that method without using <code>send</code> or <code>eval</code>.

<pre><code>receiver.fixed_method(argument)
</code></pre>

But when you want to invoke a method that varies or you do not know in advance, then you cannot write that directly. Hence the use of <code>send</code> or <code>eval</code>.

<pre><code>receiver.send(method_that_changes_dynamically, argument)
eval "#{code_to_evaluate_that_changes_more_dramatically}"
</code></pre>

Additional use of <code>send</code> is that, as you noticed, you can call a method with explicit receiver using <code>send</code>.

blocks|key|284345|text|这样想吧：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|284346|方法1+(method.call)：单一运行时|284347|如果你直接在你的程序上运行一次Ruby，你就可以控制整个系统，并且你可以通过"method.call“的方法保持一个”指向你的方法的指针“。你所要做的就是抓住一个“活动代码”的句柄，你可以随时运行它。这基本上与直接从对象内部调用方法一样快(但它没有使用object.send快-请参阅其他答案中的基准测试)。|284348|方法2+(object.send)：将方法名称持久化到数据库|284349|但是，如果您希望将要调用的方法的名称存储在数据库中，并且在将来的应用程序中，您希望通过在数据库中查找来调用该方法名称，该怎么办呢？然后，您将使用第二种方法，它会导致ruby使用第二个"s.send(:dynamic_method)“方法调用任意的方法名。|284350|方法3+(eval)：自修改方法代码|284351|如果您想以一种将方法作为全新代码运行的方式编写/修改/持久化代码到数据库中，该怎么办？您可能会定期修改写入数据库的代码，并希望每次都将其作为新代码运行。在这种(非常不寻常的情况)中，您可能希望使用第三种方法，它允许您将方法代码写出为字符串，在以后的某个日期加载回来，并完整地运行它。|284352|为了它的价值，通常在Ruby世界中，使用Eval+(方法3)被认为是不好的形式，除非在非常，非常深奥和罕见的情况下。因此，对于您遇到的几乎所有问题，您都应该坚持使用方法1和方法2。|284353|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|V|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|W|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|X|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|Y|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|Q|$]]

Think of it this way:

<h3>Method 1 (method.call): Single run-time</h3>

If you run Ruby once on your program straight through, you control the entire system and you can hold onto a "pointer to your method" via the "method.call" approach. All you are doing is holding on to a handle to "live code" that you can run whenever you want. This is basically as fast as calling the method directly from within the object (but it is not as fast as using object.send - see benchmarks in other answers).

<h3>Method 2 (object.send): Persist name of method to database</h3>

But what if you want to store the name of the method you want to call in a database and in a future application you want to call that method name by looking it up in the database? Then you would use the second approach, which causes ruby to call an arbitrary method name using your second "s.send(:dynamic_method)" approach.

<h3>Method 3 (eval): Self-modifying method code</h3>

What if you want to write/modify/persist code to a database in a way that will run the method as brand new code? You might periodically modify the code written to the database and want it to run as new code each time. In this (very unusual case) you would want to use your third approach, which allows you to write your method code out as a string, load it back in at some later date, and run it in its entirety. 

For what it's worth, generally it is regarded in the Ruby world as bad form to use Eval (method 3) except in very, very esoteric and rare cases. So you should really stick with methods 1 and 2 for almost all problems you encounter.

blocks|key|67975|text|我从@Stefan更新了基准测试，以检查在保存对方法的引用时是否有一些速度上的改进。但是，send比call快得多|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|67976|require+'benchmark'

class+Foo
++def+bar;+end
end

foo+=+Foo.new
foo_bar+=+foo.method(:bar)

Benchmark.bm(4)+do+%7Cb%7C
++b.report("send")+{+1_000_000.times+{+foo.send(:bar)+}+}
++b.report("call")+{+1_000_000.times+{+foo_bar.call+}+}
end|code-block|syntax|javascript|67977|结果如下：|67978|+++++++++++user+++++system++++++total++++++++real
send+++0.080000+++0.000000+++0.080000+(++0.088685)
call+++0.110000+++0.000000+++0.110000+(++0.108249)|67979|因此，send似乎就是最好的选择。|67980|entityMap^0|19|4|1E|4|0|0|0|0|3|4|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|13|8|@]|D|@]|E|$]]]|R|$]]

I updated the benchmark from @Stefan to check if there are some speed improvements when saving reference to method. But again – <code>send</code> is much faster than <code>call</code>

<pre><code>require 'benchmark'

class Foo
 def bar; end
end

foo = Foo.new
foo_bar = foo.method(:bar)

Benchmark.bm(4) do |b|
 b.report("send") { 1_000_000.times { foo.send(:bar) } }
 b.report("call") { 1_000_000.times { foo_bar.call } }
end
</code></pre>

These are the results:

<pre><code> user system total real
send 0.080000 0.000000 0.080000 ( 0.088685)
call 0.110000 0.000000 0.110000 ( 0.108249)
</code></pre>

So <code>send</code> seems to be the one to take.

blocks|key|284481|text|下面是所有可能的方法调用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|284482|require+'benchmark/ips'

class+FooBar
++def+name;+end
end

el+=+FooBar.new

Benchmark.ips+do+%7Cx%7C
++x.report('plain')+{+el.name+}
++x.report('eval')+{+eval('el.name')+}
++x.report('method+call')+{+el.method(:name).call+}
++x.report('send+sym')+{+el.send(:name)+}
++x.report('send+str')+{+el.send('name')+}
++x.compare!
end|code-block|syntax|javascript|284483|结果是：|284484|Warming+up+--------------------------------------
+++++++++++++++plain+++236.448k+i/100ms
++++++++++++++++eval++++20.743k+i/100ms
+++++++++method+call+++131.408k+i/100ms
++++++++++++send+sym+++205.491k+i/100ms
++++++++++++send+str+++168.137k+i/100ms
Calculating+-------------------------------------
+++++++++++++++plain++++++9.150M+(±+6.5%25)+i/s+-+++++45.634M+in+++5.009566s
++++++++++++++++eval++++232.303k+(±+5.4%25)+i/s+-++++++1.162M+in+++5.015430s
+++++++++method+call++++++2.602M+(±+4.5%25)+i/s+-+++++13.009M+in+++5.010535s
++++++++++++send+sym++++++6.729M+(±+8.6%25)+i/s+-+++++33.495M+in+++5.016481s
++++++++++++send+str++++++4.027M+(±+5.7%25)+i/s+-+++++20.176M+in+++5.027409s

Comparison:
+++++++++++++++plain:++9149514.0+i/s
++++++++++++send+sym:++6729490.1+i/s+-+1.36x++slower
++++++++++++send+str:++4026672.4+i/s+-+2.27x++slower
+++++++++method+call:++2601777.5+i/s+-+3.52x++slower
++++++++++++++++eval:+++232302.6+i/s+-+39.39x++slower|284485|预计普通调用是最快的，没有任何额外的分配，符号查找，只是查找和评估方法。|284486|至于通过符号的send，它比通过字符串更快，因为它更容易为符号分配内存。一旦它被定义，它就会在内存中存储很长时间，并且没有重新分配。|offset|length|style|CODE|284487|同样的原因也适用于method(:name)+(1)，它需要为Proc对象分配内存(2)我们在类中调用方法，这导致了额外的方法查找，这也需要时间。|284488|eval是运行解释器的，所以它是最重的。|284489|entityMap^0|0|0|0|0|0|7|4|0|9|D|V|4|0|0|4|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|12|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|13|8|@$O|14|P|15|Q|R]]|9|@]|A|$]]|$1|S|3|T|5|6|7|16|8|@$O|17|P|18|Q|R]|$O|19|P|1A|Q|R]]|9|@]|A|$]]|$1|U|3|V|5|6|7|1B|8|@$O|1C|P|1D|Q|R]]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|X|$]]

Here is all possible method calls:

<pre><code>require 'benchmark/ips'

class FooBar
 def name; end
end

el = FooBar.new

Benchmark.ips do |x|
 x.report('plain') { el.name }
 x.report('eval') { eval('el.name') }
 x.report('method call') { el.method(:name).call }
 x.report('send sym') { el.send(:name) }
 x.report('send str') { el.send('name') }
 x.compare!
end
</code></pre>

And results are:

<pre><code>Warming up --------------------------------------
 plain 236.448k i/100ms
 eval 20.743k i/100ms
 method call 131.408k i/100ms
 send sym 205.491k i/100ms
 send str 168.137k i/100ms
Calculating -------------------------------------
 plain 9.150M (± 6.5%) i/s - 45.634M in 5.009566s
 eval 232.303k (± 5.4%) i/s - 1.162M in 5.015430s
 method call 2.602M (± 4.5%) i/s - 13.009M in 5.010535s
 send sym 6.729M (± 8.6%) i/s - 33.495M in 5.016481s
 send str 4.027M (± 5.7%) i/s - 20.176M in 5.027409s

Comparison:
 plain: 9149514.0 i/s
 send sym: 6729490.1 i/s - 1.36x slower
 send str: 4026672.4 i/s - 2.27x slower
 method call: 2601777.5 i/s - 3.52x slower
 eval: 232302.6 i/s - 39.39x slower
</code></pre>

It's expected that plain call is the fastest, no any additional allocations, symbol lookups, just lookup and evaluation of method.

As for <code>send</code> via symbol, it is faster than via string as its much more easer to allocate memory for symbol. Once it's defined it's stored for long term in memory and there no reallocations.

The same reason can be said about <code>method(:name)</code> (1) it's requires to allocate memory for <code>Proc</code> object (2) we are calling the method in class which leads for additional method lookup which takes time too.

<code>eval</code> is runs interpreter so it's the heaviest.

As far as I am aware there are three ways to dynamically call a method in Ruby:

Method 1:

<pre><code>s = SomeObject.new
method = s.method(:dynamic_method)
method.call
</code></pre>

Method 2:

<pre><code>s = SomeObject.new
s.send(:dynamic_method)
</code></pre>

Method 3:

<pre><code>s = SomeObject.new
eval "s.dynamic_method"
</code></pre>

By benchmarking them I have established that Method 1 is by far the fastest, Method 2 is slower, and Method 3 is by far the slowest.

I have also found that <code>.call</code> and <code>.send</code> both allow calling private methods, while <code>eval</code> does not.

So my question is: is there any reason to ever use <code>.send</code> or <code>eval</code>? Why would you not always just use the fastest method? What other differences do these methods of calling dynamic methods have?

Dynamic method calling in Ruby

数据库

解释器

据我所知，在Ruby中有三种动态调用方法：方法1：s = SomeObject.newmethod = s.method(:dynamic_method)method.call方法二：s = SomeObject.news.send(:dynamic_method)方法3：s = SomeObject.neweval ...

问Ruby中的动态方法调用
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Ruby中的动态方法调用EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Ruby中的动态方法调用
EN