Ruby Array.fill用法及代码示例

fill(obj) → self

fill(obj, start) → self

fill(obj, start, length) → self

fill(obj, range) → self

fill {|index| ... } → self

fill(start) {|index| ... } → self

fill(start, length) {|index| ... } → self

fill(range) {|index| ... } → self

用指定的对象替换self中的指定元素；返回 self 。

使用参数 obj 并且没有给出块，用那个对象替换所有元素：

a = ['a', 'b', 'c', 'd']
a # => ["a", "b", "c", "d"]
a.fill(:X) # => [:X, :X, :X, :X]

使用参数 obj 和整数 start ，并且没有给出块，根据给定的开始替换元素。

如果 start 在范围内 (0 <= start < array.size )，则替换从偏移量 start 到末尾的所有元素：

a = ['a', 'b', 'c', 'd']
a.fill(:X, 2) # => ["a", "b", :X, :X]

如果 start 太大( start >= array.size )，什么也不做：

a = ['a', 'b', 'c', 'd']
a.fill(:X, 4) # => ["a", "b", "c", "d"]
a = ['a', 'b', 'c', 'd']
a.fill(:X, 5) # => ["a", "b", "c", "d"]

如果 start 为负数，则从末尾开始计数(起始索引为 start + array.size )：

a = ['a', 'b', 'c', 'd']
a.fill(:X, -2) # => ["a", "b", :X, :X]

如果 start 太小(小于且远离零)，则替换所有元素：

a = ['a', 'b', 'c', 'd']
a.fill(:X, -6) # => [:X, :X, :X, :X]
a = ['a', 'b', 'c', 'd']
a.fill(:X, -50) # => [:X, :X, :X, :X]

使用参数 obj 、 Integer start 和 Integer length ，并且没有给出块，根据给定的 start 和 length 替换元素。

如果 start 在范围内，则替换从偏移量 start 开始的 length 元素：

a = ['a', 'b', 'c', 'd']
a.fill(:X, 1, 1) # => ["a", :X, "c", "d"]

如果 start 为负数，则从末尾开始计数：

a = ['a', 'b', 'c', 'd']
a.fill(:X, -2, 1) # => ["a", "b", :X, "d"]

如果 start 很大 ( start >= array.size )，则使用 nil 扩展 self ：

a = ['a', 'b', 'c', 'd']
a.fill(:X, 5, 0) # => ["a", "b", "c", "d", nil]
a = ['a', 'b', 'c', 'd']
a.fill(:X, 5, 2) # => ["a", "b", "c", "d", nil, :X, :X]

如果 length 为零或负数，则不替换任何元素：

a = ['a', 'b', 'c', 'd']
a.fill(:X, 1, 0) # => ["a", "b", "c", "d"]
a.fill(:X, 1, -1) # => ["a", "b", "c", "d"]

使用参数 obj 和 Range range ，并且没有给出块，根据给定的范围替换元素。

如果范围为正且递增 (0 < range.begin <= range.end)，则将元素从 range.begin 替换为 range.end ：

a = ['a', 'b', 'c', 'd']
a.fill(:X, (1..1)) # => ["a", :X, "c", "d"]

如果 range.first 为负数，则不替换任何元素：

a = ['a', 'b', 'c', 'd']
a.fill(:X, (-1..1)) # => ["a", "b", "c", "d"]

如果 range.last 为负数，则从末尾开始计数：

a = ['a', 'b', 'c', 'd']
a.fill(:X, (0..-2)) # => [:X, :X, :X, "d"]
a = ['a', 'b', 'c', 'd']
a.fill(:X, (1..-2)) # => ["a", :X, :X, "d"]

如果 range.last 和 range.last 都是负数，则都从数组末尾开始计数：

a = ['a', 'b', 'c', 'd']
a.fill(:X, (-1..-1)) # => ["a", "b", "c", :X]
a = ['a', 'b', 'c', 'd']
a.fill(:X, (-2..-2)) # => ["a", "b", :X, "d"]

在没有参数和给定块的情况下，使用每个索引调用块；用块的返回值替换相应的元素：

a = ['a', 'b', 'c', 'd']
a.fill { |index| "new_#{index}" } # => ["new_0", "new_1", "new_2", "new_3"]

使用参数start 和给定的块，调用具有从偏移量start 到末尾的每个索引的块；用块的返回值替换相应的元素：

如果开始在范围内(0 <= start < array.size)，则从偏移量 start 替换到结束：

a = ['a', 'b', 'c', 'd']
a.fill(1) { |index| "new_#{index}" } # => ["a", "new_1", "new_2", "new_3"]

如果start 太大(start >= array.size)，什么也不做：

a = ['a', 'b', 'c', 'd']
a.fill(4) { |index| fail 'Cannot happen' } # => ["a", "b", "c", "d"]
a = ['a', 'b', 'c', 'd']
a.fill(4) { |index| fail 'Cannot happen' } # => ["a", "b", "c", "d"]

如果 start 为负数，则从末尾开始计数：

a = ['a', 'b', 'c', 'd']
a.fill(-2) { |index| "new_#{index}" } # => ["a", "b", "new_2", "new_3"]

如果 start 太小( start <= -array.size ，替换所有元素：

a = ['a', 'b', 'c', 'd']
a.fill(-6) { |index| "new_#{index}" } # => ["new_0", "new_1", "new_2", "new_3"]
a = ['a', 'b', 'c', 'd']
a.fill(-50) { |index| "new_#{index}" } # => ["new_0", "new_1", "new_2", "new_3"]

使用参数 start 和 length 以及给定的块，为开始长度指定的每个索引调用块；用块的返回值替换相应的元素。

如果 start 在范围内，则替换从偏移量 start 开始的 length 元素：

a = ['a', 'b', 'c', 'd']
a.fill(1, 1) { |index| "new_#{index}" } # => ["a", "new_1", "c", "d"]

如果 start 为负数，则从末尾开始计数：

a = ['a', 'b', 'c', 'd']
a.fill(-2, 1) { |index| "new_#{index}" } # => ["a", "b", "new_2", "d"]

如果 start 很大 ( start >= array.size )，则使用 nil 扩展 self ：

a = ['a', 'b', 'c', 'd']
a.fill(5, 0) { |index| "new_#{index}" } # => ["a", "b", "c", "d", nil]
a = ['a', 'b', 'c', 'd']
a.fill(5, 2) { |index| "new_#{index}" } # => ["a", "b", "c", "d", nil, "new_5", "new_6"]

如果 length 为零或更小，则不替换任何元素：

a = ['a', 'b', 'c', 'd']
a.fill(1, 0) { |index| "new_#{index}" } # => ["a", "b", "c", "d"]
a.fill(1, -1) { |index| "new_#{index}" } # => ["a", "b", "c", "d"]

使用参数 obj 和 range 以及给定的块，调用具有给定范围内的每个索引的块；用块的返回值替换相应的元素。

如果范围为正且递增( range 0 < range.begin <= range.end ，则将元素从 range.begin 替换为 range.end ：

a = ['a', 'b', 'c', 'd']
a.fill(1..1) { |index| "new_#{index}" } # => ["a", "new_1", "c", "d"]

如果 range.first 为负数，则不执行任何操作：

a = ['a', 'b', 'c', 'd']
a.fill(-1..1) { |index| fail 'Cannot happen' } # => ["a", "b", "c", "d"]

如果 range.last 为负数，则从末尾开始计数：

a = ['a', 'b', 'c', 'd']
a.fill(0..-2) { |index| "new_#{index}" } # => ["new_0", "new_1", "new_2", "d"]
a = ['a', 'b', 'c', 'd']
a.fill(1..-2) { |index| "new_#{index}" } # => ["a", "new_1", "new_2", "d"]

如果 range.first 和 range.last 都是负数，则都从末尾开始计数：

a = ['a', 'b', 'c', 'd']
a.fill(-1..-1) { |index| "new_#{index}" } # => ["a", "b", "c", "new_3"]
a = ['a', 'b', 'c', 'd']
a.fill(-2..-2) { |index| "new_#{index}" } # => ["a", "b", "new_2", "d"]