Array#fill方法支持块参数的实际优势与设计缘由问询

Great question! As someone who’s worked extensively with Ruby’s array methods, let’s break this down clearly.

Why the Block Uses Absolute Indices #

Ruby’s design philosophy prioritizes intuition, consistency, and flexibility—and the choice to use absolute indices in Array#fill’s block aligns perfectly with that. Here’s why:

• Consistency with other Ruby methods: Most Ruby array iterators (like each_with_index, map.with_index) use absolute indices relative to the entire array. By following this pattern, fill avoids forcing developers to learn a new, context-dependent indexing rule. When you see |i| in a fill block, you immediately know it’s the element’s position in the full array, not a relative offset from the fill start.
• Clarity when filling partial ranges: If fill used relative indices (e.g., starting at 0 for the first element in the fill range), you’d have to manually calculate the absolute position if your logic depends on it. For example, filling array.fill(2..5) { |relative_i| ... } would require adding 2 to relative_i to get the real index—extra mental work and a source of bugs. Absolute indices eliminate this friction.
• Unified behavior across use cases: Whether you’re filling the entire array or just a slice, the block’s index meaning stays the same. This predictability makes the method easier to reason about, even in complex scenarios.

Practical Advantages of the Block Parameter #

The block version of fill solves several common pain points that the fixed-value version can’t handle. Here are the most impactful use cases:

• Avoiding object reference bugs: When you pass an object (like a hash or array) to fill, every element in the target range gets a reference to the same object. For example:

  bad_array = Array.new(3).fill({})
  bad_array[0][:key] = "value"
  # All elements now have {:key => "value"}—not what you want!
  

  Using a block creates a new instance every time:

  good_array = Array.new(3).fill { {} }
  good_array[0][:key] = "value"
  # Only the first element has the key—perfect!
  

• Dynamic, position-dependent values: You can generate values directly based on the element’s index. This is ideal for creating sequences, grids, or conditionally populated arrays:

  # Create an array of squares
  squares = Array.new(5).fill { |i| i ** 2 } # => [0, 1, 4, 9, 16]
  
  # Fill even indices with "even", odd with "odd"
  parity = Array.new(6).fill { |i| i.even? ? "even" : "odd" }
  

• Flexible partial-range filling: When you only need to update a slice of the array, the block’s absolute index lets you tie the new values to the element’s global position without extra calculations. For example:

  array = Array.new(10, "default")
  # Fill positions 3-7 with labels based on their index
  array.fill(3..7) { |i| "element_#{i}" }
  # Result: ["default", "default", "default", "element_3", "element_4", "element_5", "element_6", "element_7", "default", "default"]
  

• On-demand value generation: If generating values is expensive (e.g., complex computations, API calls), the block ensures you only generate values for the elements you’re actually filling—unlike pre-generating a list of values and passing it to fill. This saves memory and processing time for large arrays or sparse fills.

内容的提问来源于stack exchange，提问作者DreamWalker