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"]