在Ruby中填充数组的方法

以下是我现在所拥有的，它在某种程度上起作用：

def padding(a, b, c=nil)
  until a[b-1]
    a << c
  end
end

但当我没有为“c”输入值时，它崩溃了

我应该如何附加这个以避免崩溃？ 此外，您建议如何更改此方法以使用它，如下所示：

[1,2,3].padding(10)
=>[1,2,3,nil,nil,nil,nil,nil,nil,nil]
[1,2,3].padding(10, "YES")
=>[1, 2, 3, "YES", "YES", "YES", "YES", "YES", "YES", "YES"]

我见过其他的填充方法，但它们似乎并没有按照作者的意图工作。所以，我决定给自己一个机会。

你知道这个方法吗：-

它确实是你想要的。如果它存在，为什么你想要你自己的

arup@linux-wzza:~> pry
[1] pry(main)> a=[1,2,3]
=> [1, 2, 3]
[2] pry(main)> a.fill('YES', 3...10)
=> [1, 2, 3, "YES", "YES", "YES", "YES", "YES", "YES", "YES"]
[3] pry(main)>

您可以用任何方式填充数组。这是一个很酷的实现。试试看

在控制台中阅读：

arup@linux-wzza:~> ri Array#fill

= Array#fill

(from ruby site)
------------------------------------------------------------------------------
  ary.fill(obj)                                 -> ary
  ary.fill(obj, start [, length])               -> ary
  ary.fill(obj, range )                         -> ary
  ary.fill { |index| block }                    -> ary
  ary.fill(start [, length] ) { |index| block } -> ary
  ary.fill(range) { |index| block }             -> ary

------------------------------------------------------------------------------

The first three forms set the selected elements of self (which may be the
entire array) to obj.

A start of nil is equivalent to zero.

A length of nil is equivalent to the length of the array.

The last three forms fill the array with the value of the given block, which
is passed the absolute index of each element to be filled.

Negative values of start count from the end of the array, where -1 is the last
element.

  a = [ "a", "b", "c", "d" ]
  a.fill("x")              #=> ["x", "x", "x", "x"]
  a.fill("z", 2, 2)        #=> ["x", "x", "z", "z"]
  a.fill("y", 0..1)        #=> ["y", "y", "z", "z"]
  a.fill { |i| i*i }       #=> [0, 1, 4, 9]
  a.fill(-2) { |i| i*i*i } #=> [0, 1, 8, 27]

---

要在数组上具体实现

填充

方法，请执行以下操作：

module Padding
  refine Array do
    def padding(new_length, element=nil)
      if self.size < new_length
        self.concat(Array.new(new_length - self.size, element))
      end
    end
  end
end

using Padding
puts [1,2,3].padding(10).inspect
# => [1, 2, 3, nil, nil, nil, nil, nil, nil, nil]
puts [1,2,3].padding(10, "YES").inspect
# => [1, 2, 3, "YES", "YES", "YES", "YES", "YES", "YES", "YES"]

模块填充
优化数组do
def填充（新长度，元素=nil）
如果自身尺寸<新长度
self.concat（Array.new（new_length-self.size，element））
结束
结束
结束
结束
使用填充物
放置[1,2,3]。填充（10）。检查
#=>[1,2,3，无，无，无，无，无，无，无，无，无]
放置[1,2,3]。填充（10，“是”）。检查
#=>[1,2,3，“是”，“是”，“是”，“是”，“是”，“是”，“是”，“是”，“是”]

---

编辑：忘记了

数组#填充

。奥雅纳的回答很酷（即使你需要说

fill（3,7）

而不是

fill（-1,10）

，因为后者给出了错误的结果）。最好使用它而不是

concat（Array.new（…）

。嗯)

问题在于，nil的计算结果为false，因此当[b-1]包含nil时，

直到[b-1]

才为true。。。所以你会一直循环直到你的记忆耗尽

最好是

def padding(a, b, c=nil)
  until a.size >= b
    a << c
  end
end

def填充（a、b、c=nil）
直到a.size>=b
a它被杀死，因为您正在进入无限循环<代码>直到[b-1]

将不会完成，因为当您向数组中添加nils时，您将得到：

a == [1, 2, 3, nil, nil, nil, nil, nil, nil, nil]

经过几次迭代后，a[b-1]将为

nil

，这是错误的。直到永远不会停止

关于第二个问题，很容易扩展现有的数组类：

class Array
  def padding(i, value=nil)
    (i - length).times { self << value }
    self
  end
end

请注意，关于的方法修改了现有数组（因此，由于Ruby约定，应称为

填充！

）：

---

当然，您可以轻松地创建不修改的方法版本。我假设您想修改数组，因为您原来的方法已经修改了。

Arup已经解决了这个问题，但这里有另一种方法：

def padding(a,b,c)
  [*a, *[c]*b]
end

a=[1,2,3]
padding(a,5,"YES")
  #=> [1, 2, 3, "YES", "YES", "YES", "YES", "YES"]

---

好办法。如果您用

[1,2,3]表示OP要求的内容。用
#fill
=>
[1,2,3]填充（10，“是”）
。fill（'YES'，3…10）

其中3可以替换为

数组#长度

@Nishu无异议：-）这是非常全面的。非常感谢您的回答！谢谢你指出这一点！我完全忘记了零这个词与生俱来的谬误。

a == [1, 2, 3, nil, nil, nil, nil, nil, nil, nil]

class Array
  def padding(i, value=nil)
    (i - length).times { self << value }
    self
  end
end

[1,2,3].padding(10)
#=> [1, 2, 3, nil, nil, nil, nil, nil, nil, nil]
[1,2,3].padding(10, "YES")
#=> [1, 2, 3, "YES", "YES", "YES", "YES", "YES", "YES", "YES"]

a = [1,2,3]
#=> [1, 2, 3]
a.padding(10, "YES")
#=> [1, 2, 3, "YES", "YES", "YES", "YES", "YES", "YES", "YES"]
a
#=> [1, 2, 3, "YES", "YES", "YES", "YES", "YES", "YES", "YES"]

def padding(a,b,c)
  [*a, *[c]*b]
end

a=[1,2,3]
padding(a,5,"YES")
  #=> [1, 2, 3, "YES", "YES", "YES", "YES", "YES"]