Todos, exceto o último elemento da matriz Ruby

Digamos que eu tenho uma matriz Ruby

a = [1, 2, 3, 4]

Se eu quiser tudo, menos o primeiro item, posso escrever a.drop(1), o que é ótimo. Se eu quero tudo menos o último item, só consigo pensar dessa maneira

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

mas nenhum deles parece tão limpo quanto o uso drop. Falta alguma outra maneira embutida?

Possivelmente...

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

ou

a.take 3

ou

a.first 3

ou

a.pop

que retornará o último e deixará a matriz com tudo antes

ou faça o computador funcionar para o jantar:

a.reverse.drop(1).reverse

ou

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]

Por curiosidade, por que você não gosta a[0...-1]? Você deseja obter uma fatia da matriz, para que o operador de fatia pareça a escolha idiomática.

Mas se você precisar chamar isso em todo o lugar, sempre terá a opção de adicionar um método com um nome mais amigável à classe Array, como sugeriu o DigitalRoss. Talvez assim:

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

Outro truque legal

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

Se você deseja executar uma pop()operação em uma matriz (o que resultará no último item excluído), mas está interessado em obter a matriz em vez de um elemento pop-up, você pode usar tap(&:pop):

> arr = [1, 2, 3, 4, 5]
> arr.pop
=> 5
> arr
=> [1, 2, 3, 4]
> arr.tap(&:pop)
=> [1, 2, 3]

Eu faço assim:

my_array[0..-2]

Que tal aumentar o próprio método drop, por exemplo, como este?

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

Em seguida, você pode usar um tamanho negativo para remover elementos do final, da seguinte maneira:

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

a[0...-1]parece ser o melhor caminho. A sintaxe de divisão da matriz foi criada exatamente para esse fim ...

Como alternativa, se você não se importa em modificar a matriz, basta chamar a.pop:

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

Para se livrar do último elemento em uma linha com o restante retornando

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

Sério, porém,

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

Este é o caminho:

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

Mas vamos explicar como isso funciona:

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

O próximo exemplo retornará todos os registros, da posição 0 à última

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

O próximo exemplo retornará registros da 1 posição para a última

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

E aqui você tem o que precisa. O próximo exemplo retornará registros da posição 0 para a última-1

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

Você já tentou "levar"

a.take(3) 

Resposta :,a.τwτ mas você precisa instalar o Pyper primeiro ...

Introdução ao Pyper: você conhece Lispy care cdrretorna "primeiro" e "resto" da matriz? Apenas para necessidades como a sua, fiz uma extensão desse mecanismo Lispy. É chamado pypere permite acessar também o 2º, o restante do 2º, o 3º, o restante do 3d e também o último, tudo, exceto o último etc. Isso não seria muito para se escrever, mas também permite a composição de letras, assim como caar, cadr, cdadaretc conhecido a partir Lisp:

# 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)

e, finalmente, a resposta para sua pergunta:

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

Há mais:

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

Composições:

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

Há também mais caracteres de comando do que apenas a..f, u..ze 0..9, mais notavelmente m, significando mapa:

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

Mas outros caracteres de comando são muito quentes e não são muito fáceis de usar no momento.

Isso cria uma nova matriz com todos, exceto os últimos elementos do original:

ary2 = ary.dup
ary2.pop

Observe que alguns outros sugeriram o uso de #pop. Se você está bem, modificando a matriz no local, tudo bem. Se você não concorda com isso, duplique a matriz primeiro, como neste exemplo.

Costumo encontrar-me querendo todos, exceto os últimos n elementos de uma matriz. Eu montei minha própria função para fazer isso de uma maneira que eu acho mais legível que outras soluções:

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

Agora você pode fazer o seguinte:

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

Eu permiti deliberadamente o ArgumentError para que o responsável pela chamada seja responsável por como eles usam esse método. Eu adoraria ouvir comentários / críticas dessa abordagem.

a = [1,2,3,4]

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