Question

假设我有一个Ruby数组

a = [1, 2, 3, 4]

如果我想要除第一项以外的所有项目，我可以写a.drop(1)，这很棒。但是，如果我想要除 last 项之外的所有项目，我只能想到这种方式

a[0..-2]   # or
a[0...-1]

但这些都不像使用drop一样干净。还有其他任何我想念的内置方法吗？

Answer 1

...也许

a = t               # => [1, 2, 3, 4]
a.first a.size - 1  # => [1, 2, 3]

或

a.take 3

或

a.first 3

或

a.pop

将返回最后一个并将数组保留在它之前的所有内容

或使计算机正常工作：

a.reverse.drop(1).reverse

或

class Array
  def clip n=1
    take size - n
  end
end
a          # => [1, 2, 3, 4]
a.clip     # => [1, 2, 3]
a = a + a  # => [1, 2, 3, 4, 1, 2, 3, 4]
a.clip 2   # => [1, 2, 3, 4, 1, 2]

Answer 2

出于好奇，你为什么不喜欢a[0...-1]？你想得到一个数组切片，所以切片运算符似乎是惯用的选择。

但是如果你需要在整个地方调用它，你总是可以选择向Array类添加一个更友好名称的方法，就像DigitalRoss建议的那样。也许是这样的：

class Array
    def drop_last
        self[0...-1]
    end
end

Answer 3

另一个很酷的技巧

>> *a, b = [1,2,3]
=> [1, 2, 3]
>> a
=> [1, 2]
>> b
=> 3

Answer 4

如果要对数组执行pop()操作（这将导致删除最后一项），但您有兴趣获取数组而不是弹出元素，则可以使用{ {1}}：

tap(&:pop)

Answer 5

我这样做：

my_array[0..-2]

Answer 6

如何增加drop方法本身，例如像这样？

class Array
  def drop(n)
    n < 0 ? self[0...n] : super
  end
end

然后您可以使用负大小从末尾删除元素，如下所示：

[1, 2, 3, 4].drop(-1) #=> [1, 2, 3]
[1, 2, 3, 4].drop(-2) #=> [1, 2]

Answer 7

a[0...-1]似乎是最好的方式。为此目的创建了数组切片语法......

或者，如果您不介意修改阵列，可以拨打a.pop：

>> a = [1, 2, 3, 4]
>> a.pop
>> a
=> [1, 2, 3]

Answer 8

要删除一行中的最后一个元素，其余部分返回

[1, 2, 4, 5, 6].reverse.drop(1).reverse

说真的，

[1,2,3,4][0..-2]
#=> [1,2,3]

Answer 9

这是方式：

[1,2,3,4,5][0..-1-1]

但是让我们解释一下这是如何工作的：

a = [1,2,3,4,5]

下一个示例将返回所有记录，从0位置到最后

a[0..-1]
=> [1, 2, 3, 4, 5]

下一个示例会将记录从1个位置返回到最后

a[1..-1]
=> [2, 3, 4, 5]

在这里，你有你需要的东西。下一个示例将记录从0位置返回到最后1位

a[0..-1-1]
=> [1, 2, 3, 4]

Answer 10

你试过“拿”

a.take(3)

Answer 11

这使得一个新数组包含原始的所有元素：

ary2 = ary.dup
ary2.pop

请注意，其他一些人建议使用#pop。如果您可以正确修改阵列，那很好。如果您对此不满意，请先复制数组，如本例所示。

Answer 12

答案： a.τwτ，但您必须先安装Pyper ...

Pyper简介：你知道Lispy car和cdr返回数组的“第一个”和“休息”吗？只是为了满足你的需求，我对这个Lispy机制进行了扩展。它被称为pyper，它允许你访问第二个，休息从第二个，第三个，休息从三维，也是最后一个，除了最后等等。这不会写太多，但它也允许字母组成，就像Lisp所知的caar，cadr，cdadar等一样：

# First, gem install pyper
require 'pyper'
include Pyper
a = %w/lorem ipsum dolor sit amet/
# To avoid confusion with other methods, and also because it resembles a rain gutter,
# Greek letter τ is used to delimit Pyper methods:
a.τaτ #=> "lorem"
a.τdτ #=> ["ipsum", "dolor", "sit", "amet"]
a.τbτ #=> "ipsum"
a.τeτ #=> ["dolor", "sit", "amet"]
a.τcτ #=> "dolor" (3rd)
a.τzτ #=> "amet" (last)
a.τyτ #=> "sit" (2nd from the end)
a.τxτ #=> "dolor" (3rd from the end)

最后，回答你的问题：

a.τwτ #=> ["lorem", "ipsum", "dolor", "sit"] (all except last)

还有更多：

a.τuτ #=> ["lorem", "ipsum", "dolor"] (all except last 2)
a.τ1τ #=> ["lorem", "ipsum"] (first 2)
a.τ8τ #=> (last 2)
a.τ7τ #=> (last 3)

组合物：

a.τwydτ #=> "olor" (all except 1st letter of the last word of all-except-last array)

还有更多的命令字符，而不仅仅是a..f，u..z和0..9，最值得注意的是m，这意味着地图：

a.τwmbτ #=> ["o", "p", "o", "i"] (second letters of all-except-last array)

但是其他命令字符太热了，目前还不是很容易使用。

Answer 13

我经常发现自己想要除了数组的最后n个元素之外的所有元素。我已经完成了自己的功能，以一种我发现比其他解决方案更具可读性的方式：

class Array
  def all_but_the_last(n)
    self.first(self.size - n)
  end
end

现在您可以执行以下操作：

arr = ["One", "Two", "Three", "Four", "Five"]
# => ["One", "Two", "Three", "Four", "Five"]

arr.all_but_the_last(1)
# => ["One", "Two", "Three", "Four"]

arr.all_but_the_last(3)
# => ["One", "Two"]

arr.all_but_the_last(5)
# => []

arr.all_but_the_last(6)
# ArgumentError: negative array size

我故意允许ArgumentError，以便调用者负责他们如何使用此方法。我很想听到对这种方法的评论/批评。

Answer 14

a = [1,2,3,4]

a[0..(a.length - 2)]
=> [1,2,3]

Ruby数组的最后一个元素

14 个答案: