Remove reference of an object while iterating over the array of the objects

I can see a few performance issues with the code, although others may do better.

Here's what I think:

1. you are storing nil objects in the Array instead of removing the references and then you are calling the compacts... this iterates over the Array two times instead of one.
2. your update and delete methods could fit inside one keep_if method call
3. you would probably do better initializing the object with the initialize method rather then using lazy initialization (though that might or might not show on the benchmarks you created) - you have an extra computation for every update call.

Also, your benchmarks always create an object and update it one time - this is not the best base for comparison.

for instance, your update_2 is actually much slower over time... which you aren't noticing at all with your benchmarks.

I updated your update_2 method and added an update_3 method which was a bit faster with the new benchmarks.

the update_3 method required an adjustment to the Test class, which now has a new method called update_or_destroy and returns true for update and false for destroy.

I also added an initializer method to reduce the lazy initialization effect (during my testing it showed to be an effective way to reduce the workload).

try this:

require 'benchmark'
class Test
  def initialize
    @counter ||= 0
  end
  def update
    @counter += 1
  end
  def destroy?
    @counter > 10
  end
  def dispose
    # dispose this object
  end
  def update_or_destroy
    update
    if destroy?
      dispose
      false
    else
      true
    end
  end
end

class Tests
  def initialize(number)
    @data = []
    number.times do 
      @data.push(Test.new)
    end
  end
  def add_data(data)
    @data.push(data)
  end
  def update
    @data.each_with_index do |t, index|
      t.update
      if t.destroy?
        t.dispose # need to dispose the sprite object in my realcode before delete ref.
        @data[index] = nil
      end
    end.compact!
  end
  # this would be another attempt, which is a little bit faster
  # but this wont work because in my case the objects I use are
  # sprite objects which needs to be disposed like shown above
  # before the reference is removed
  def update_2_updated
    # @data.each(&:update)
    @data.delete_if{|obj| obj.update; obj.destroy?}
  end

  def update_3
    @data.keep_if {|obj| obj.update_or_destroy}
  end
end

iterations = 2000000

Benchmark.bm do |x|
  x.report {Tests.new(iterations).update}
  x.report {Tests.new(iterations).update_2_updated}
  x.report {Tests.new(iterations).update_3}
end

#new benchmarks
iterations = 100000
test_object = Tests.new(iterations)
puts Benchmark.measure { iterations.times { test_object.update  } }

test_object = Tests.new(iterations)
puts Benchmark.measure { iterations.times { test_object.update_2_updated  } }

test_object = Tests.new(iterations)
puts Benchmark.measure { iterations.times { test_object.update_3  } }