Question

我很好奇这是一个更好的方法吗？

这段代码显然不起作用，因为take只需要一个参数，但这就是我希望它能起作用的方式

%w(a b c).take(5, "x") # => ["a", "b", "c", "x", "x"]

Answer 1

这是一个非破坏性的解决方案：

class Array
 def pad_and_take(n, x)
   self.dup.fill(x, self.length...n).take(n)
 end
end

# then you can do:
%w(a b c).pad_and_take(5, "x") # => ["a", "b", "c", "x", "x"]

Answer 2

a = %w(a b c)
(0...5).map{|i| a[i] || "x"}

这是一个适用于包含nil值的数组的版本：

a = %w(a b c)
(0...5).map{|i| a.fetch(i,"x")}

Answer 3

class Array
  def take2 n, v
    self.fill v, n
    self.take n
  end
end

a1 = [:a, :b, :c, :d]
p a1.take2 2, 123
p a1
a2 = (1..10).to_a
p a2.take2 3, :hownow
p a2

Answer 4

另一种方式：

cs = ["a", "b", "c"]
cs_padded = cs.take(5) + ["x"] * [5 - cs.size, 0].max
#=> ["a", "b", "c", "x", "x"]

Answer 5

sawa答案的变体：

a = %w(a b c)

(0...5).map { |i| a.fetch(i, "x") }
#=> ["a", "b", "c", "x", "x"]

它也适用于虚假值：

a = ["a", nil, false]

(0...5).map { |i| a.fetch(i, "x") }
#=> ["a", nil, false, "x", "x"]

Answer 6

这是一种方法，用你想要的任何东西替换x：

(%w(a b c) << ("x,"*5).split(",")).flatten.take(5).inspect

Answer 7

(%w(a b c)+["x"]*5).take(5)

我认为sawa的答案很难 - 除非Ruby获得生成无限重复序列的函数，否则此解决方案会强制您将该数字写入两次。

Answer 8

pad thai = P

class Array
  #make array from first n elements, padding with s if n>self.size
  def pad_thai n, s='x'
    sz = self.size
    n>sz ? self+[s]*(n-sz) : self.first(n)
  end
end

ar = %w(a b c)
p ar.pad_thai 2  #["a", "b"]
p ar.pad_thai 5  #["a", "b", "c", "x", "x"]

Answer 9

看起来一些Hash魔法会很好。

# hard-coded example
array = %w[a b c]
hash  = Hash[(0...array.size).zip array]
hash.default = 'x'
hash.values_at(*0...5)
# => ["a", "b", "c", "x", "x"]

作为一项功能，

def padded_take(array, count, pad)
  hash = Hash[(0...array.size).zip array]
  hash.default = pad
  hash.values_at(*0...count)
end
padded_take(%w[a b c], 5, 'x')
# => ["a", "b", "c", "x", "x"]

Answer 10

我发布了一个快速回答，但是如果在生产系统的多个地方使用过这个问题，那么我会过度使用Enumerator。

def padded_take(array, count, pad)
  e = Enumerator.new do |y|
    array.each { |v| y << v }
    [pad].cycle { |pad| y << pad }
  end
  e.take(count)
end
padded_take(%w[a b c], 10, 'x')
# => ["a", "b", "c", "x", "x", "x", "x", "x", "x", "x"]

将此行为提取到PaddedArray类中应该非常容易。

从数组中获取N个元素，如果数组小于N，则按某个值填充剩余元素

10 个答案: