How do I add 'each' method to Ruby object (or should I extend Array)?

前端 未结 7 1471
抹茶落季
抹茶落季 2021-01-30 04:00

I have an object Results that contains an array of result objects along with some cached statistics about the objects in the array. I\'d like the Results object to

相关标签:
7条回答
  • 2021-01-30 04:35

    each just goes through array and call given block with each element, that is simple. Since inside the class you are using array as well, you can just redirect your each method to one from array, that is fast and easy to read/maintain.

    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|
       p v
    }
    
    #print:
    # 1
    # 2
    

    Note that I have mixed in Enumerable. That will give you a bunch of array methods like all?, map, etc. for free.

    BTW with Ruby you can forget about inheritance. You don't need interface inheritance because duck-typing doesn't really care about actual type, and you don't need code inheritance because mixins are just better for that sort of things.

    0 讨论(0)
  • 2021-01-30 04:36

    If you really do want to make your own #each method, and assuming you don't want to forward, you should return an Enumerator if no block is given

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

    This will return an Enumerable object if no block is given, allowing Enumerable method chaining

    0 讨论(0)
  • 2021-01-30 04:38

    Not sure I'm adding anything new, but decided to show a very short code that I wish I could have found in the answers to quickly show available options. Here it is without the enumerator that @shelvacu talks about.

    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
    

    Lets check performance:

    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
    

    Here's the result:

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

    This means yield is marginally faster than &block what we already know btw.

    UPDATE: This is IMO the best way to create an each method which also takes care of returning an enumerator

    class Test
      def each
        if block_given?
          @data.each{|x| yield(x)}  
        else    
          return @data.each
        end  
      end  
    end
    
    0 讨论(0)
  • 2021-01-30 04:41

    For the general case of implementing array-like methods, yes, you have to implement them yourself. Vava's answer shows one example of this. In the case you gave, though, what you really want to do is delegate the task of handling each (and maybe some other methods) to the contained array, and that can be automated.

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

    This class will get all of Array's Enumerable behavior as well as the Array << operator and it will all go through the inner array.


    Note, that when you switch your code from Array inheritance to this trick, your << methods would start to return not the object intself, like real Array's << did -- this can cost you declaring another variable everytime you use <<.

    0 讨论(0)
  • 2021-01-30 04:42

    This feels very c-like and I know Ruby has better way.

    If you want an object to 'feel' like an array, than overriding << is a good idea and very 'Ruby'-ish.

    but am not sure what the each method is really doing under the hood.

    The each method for Array just loops through all the elements (using a for loop, I think). If you want to add your own each method (which is also very 'Ruby'-ish), you could do something like this:

    def each
      0.upto(@result_array.length - 1) do |x|
        yield @result_array[x]
      end
    end
    
    0 讨论(0)
  • 2021-01-30 04:52

    Your << method is perfectly fine and very Ruby like.

    To make a class act like an array, without actually inheriting directly from Array, you can mix-in the Enumerable module and add a few methods.

    Here's an example (including Chuck's excellent suggestion to use Forwardable):

    # 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}"
    

    Which outputs:

    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
    
    0 讨论(0)
提交回复
热议问题