Micro-benchmark to test `||=` and `[]=` vs. explicit initialize xor `[]=`

benchmark.rb

#!/usr/bin/env ruby

require 'benchmark'

keys = ('aa'..'zz').map(&:to_sym)

Benchmark.bm do |b|
  n = 10_000

  b.report('lazy initialize') do
    n.times do
      hash = nil

      keys.each do |key|
        hash ||= {}
        hash[key] = 1
      end
    end
  end

  b.report('explicit initialize') do
    n.times do
      hash = nil

      keys.each do |key|
        if hash
          hash[key] = 1
        else
          hash = {key => 1}
        end
      end
    end
  end
end

       user     system      total        real
lazy initialize  0.968563   0.049878   1.018441 (  1.023334)
explicit initialize  0.950206   0.003927   0.954133 (  0.958803)

IMHO, it's not fair when comparing that way.

In the lazy initialize part, should we change it to below instead?
(since we need to initialize the hash with the default key rather than an empty hash.)

    n.times do
      hash = nil

      keys.each do |key|
        hash ||= {key: 1}
      end
    end

Agree to @sanG-github Nope, that would then only set the very first key.

Alternative:

else # !hash
  hash = {}
  hash[key] = 1
end

In my case, doesnt have much effect on the benchmark results, though.
Quicker implementation in my short tests is

b.report('explicit initialize, always assign') do
    n.times do
      hash = nil

      keys.each do |key|
        if !hash
          hash = {}
        end

        hash[key] = 1
      end
    end
 end