如何将“每个”方法添加到Ruby对象(或者我应该扩展数组)?

我有一个对象结果,其中包含一个result对象数组以及一些有关数组中的对象的caching统计信息。 我希望结果对象能够像数组一样行事。 我的第一个切入点是添加这样的方法

  def <<(val) @result_array << val end 

这感觉非常像C,我知道Ruby有更好的方法。

我也想能够做到这一点

  Results.each do |result| result.do_stuff end 

但是我不确定each方法在底层实际上做了什么。

目前,我只是简单地通过一个方法返回底层数组,并调用它,这似乎并不是最优雅的解决scheme。

任何帮助,将不胜感激。

对于实现类数组方法的一般情况,是的,你必须自己实现它们。 Vava的回答显示了这个的一个例子。 然而,在你给出的情况下,你真正想要做的是委托处理each (也许一些其他方法)到包含的数组,并且可以自动化的任务。

 require 'forwardable' class Results include Enumerable extend Forwardable def_delegators :@result_array, :each, :<< end 

这个类将得到所有Array的Enumerable行为以及Array <<操作符,它将全部通过内部数组。


注意,当你将代码从Arrayinheritance转换到这个技巧时,你的<<方法将开始不返回对象intself,就像真正的Array的<< did一样 – 每次使用<<这会花费你声明另一个variables。

each只是通过数组,每个元素调用给定的块,这很简单。 因为在类中你也使用了数组,所以你可以将each方法redirect到数组中的each方法,这是快速和容易阅读/维护。

 class Result include Enumerable def initialize @results_array = [] end def <<(val) @results_array << val end def each(&block) @results_array.each(&block) end end r = Result.new r << 1 r << 2 r.each { |v| pv } #print: # 1 # 2 

请注意,我在Enumerable混合使用。 这会给你一堆像all?的数组方法all?map等免费。

顺便说一句,你可以忘记inheritance。 你不需要接口inheritance,因为duck-typing并不真正关心实际的types,而且你不需要代码inheritance,因为mixins只是更好的types的东西。

这感觉非常像C,我知道Ruby有更好的方法。

如果你想让一个对象感觉像是一个数组,那么重写<<是一个好主意,而且是'Ruby'-ish。

但是我不确定每种方法在底层实际上做了什么。

Array的每个方法只是遍历所有的元素(使用for循环, 我想 )。 如果你想添加你自己的每个方法(这也是非常'Ruby'-ish),你可以做这样的事情:

 def each 0.upto(@result_array.length - 1) do |x| yield @result_array[x] end end 

你的<<方法非常好,很像Ruby。

为了使一个类像一个数组一样,不需要直接从Arrayinheritance,你可以混合使用Enumerable模块并添加一些方法。

下面是一个例子(包括Chuck提出的使用Forwardable的优秀build议):

 # You have to require forwardable to use it require "forwardable" class MyArray include Enumerable extend Forwardable def initialize @values = [] end # Map some of the common array methods to our internal array def_delegators :@values, :<<, :[], :[]=, :last # I want a custom method "add" available for adding values to our internal array def_delegator :@values, :<<, :add # You don't need to specify the block variable, yield knows to use a block if passed one def each # "each" is the base method called by all the iterators so you only have to define it @values.each do |value| # change or manipulate the values in your value array inside this block yield value end end end m = MyArray.new m << "fudge" m << "icecream" m.add("cake") # Notice I didn't create an each_with_index method but since # I included Enumerable it knows how and uses the proper data. m.each_with_index{|value, index| puts "m[#{index}] = #{value}"} puts "What about some nice cabbage?" m[0] = "cabbage" puts "m[0] = #{m[0]}" puts "No! I meant in addition to fudge" m[0] = "fudge" m << "cabbage" puts "m.first = #{m.first}" puts "m.last = #{m.last}" 

哪些产出:

 m[0] = fudge m[1] = icecream m[2] = cake What about some nice cabbage? m[0] = cabbage No! I meant in addition to fudge m.first = fudge m.last = cabbage 

如果你创build一个从Arrayinheritance的类,你将inheritance所有的function。

然后,您可以通过重新定义它们来补充需要更改的方法,并且可以针对旧function调用super。

例如:

 class Results < Array # Additional functionality def best find {|result| result.is_really_good? } end # Array functionality that needs change def compact delete(ininteresting_result) super end end 

或者,您可以使用内置库可forwardable 。 如果你不能从数组inheritance,这是特别有用的,因为你需要从另一个类inheritance:

 require 'forwardable' class Results extend Forwardable def_delegator :@result_array, :<<, :each, :concat # etc... def best @result_array.find {|result| result.is_really_good? } end # Array functionality that needs change def compact @result_array.delete(ininteresting_result) @result_array.compact self end end 

在这两种forms中,您都可以按照自己的意愿使用它:

 r = Results.new r << some_result r.each do |result| # ... end r.compact puts "Best result: #{r.best}" 

不知道我是否添加了新的东西,但决定显示一个非常短的代码,我希望我能在答案中find快速显示可用选项。 这里没有@shelvacu所说的统计员。

 class Test def initialize @data = [1,2,3,4,5,6,7,8,9,0,11,12,12,13,14,15,16,172,28,38] end # approach 1 def each_y @data.each{ |x| yield(x) } end #approach 2 def each_b(&block) @data.each(&block) end end 

让我们检查性能:

 require 'benchmark' test = Test.new n=1000*1000*100 Benchmark.bm do |b| b.report { 1000000.times{ test.each_y{|x| @foo=x} } } b.report { 1000000.times{ test.each_b{|x| @foo=x} } } end 

结果如下:

  user system total real 1.660000 0.000000 1.660000 ( 1.669462) 1.830000 0.000000 1.830000 ( 1.831754) 

这意味着yield比阻止我们已经知道的顺便更快。

更新 :这是国际海事组织最好的方式来创build每个方法,也照顾返回一个枚举

 class Test def each if block_given? @data.each{|x| yield(x)} else return @data.each end end end 

如果你真的想制作自己的#each方法,并假设你不想转发,如果没有给出块,你应该返回一个枚举器

 class MyArrayLikeClass include Enumerable def each(&block) return enum_for(__method__) if block.nil? @arr.each do |ob| block.call(ob) end end end 

如果没有给出块,这将返回一个Enumerable对象,允许Enumerable方法链接