Todos menos el último elemento de la matriz Ruby

Digamos que tengo una matriz Ruby

a = [1, 2, 3, 4]

Si quiero todo menos el primer elemento, puedo escribir a.drop(1), lo cual es genial. Sin embargo, si quiero todo menos el último elemento, solo puedo pensar de esta manera

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

pero ninguno de estos parece tan limpio como el uso drop. ¿Alguna otra forma incorporada que me falta?

Quizás...

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

o

a.take 3

o

a.first 3

o

a.pop

que devolverá el último y dejará la matriz con todo lo anterior

o hacer que la computadora funcione para la cena:

a.reverse.drop(1).reverse

o

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 curiosidad, ¿por qué no te gusta? a[0...-1] ? Desea obtener un segmento de la matriz, por lo que el operador de segmento parece la opción idiomática.

Pero si necesita llamar a esto por todas partes, siempre tiene la opción de agregar un método con un nombre más amigable a la clase Array, como sugiere DigitalRoss. Quizás así:

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

Otro truco genial

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

Si desea realizar una pop()operación en una matriz (que dará como resultado el último elemento eliminado), pero está interesado en obtener la matriz en lugar de un elemento emergente, puede usar tap(&:pop):

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

Lo hago así:

my_array[0..-2]

¿Qué tal aumentar el método de caída en sí mismo, por ejemplo así?

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

Luego puede usar un tamaño negativo para eliminar elementos del final, así:

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

a[0...-1]Parece la mejor manera. La sintaxis de corte de matriz se creó exactamente para este propósito ...

Alternativamente, si no le importa modificar la matriz en su lugar, simplemente puede llamar a.pop:

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

Para deshacerse del último elemento en una línea con el resto regresando

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

Hablando en serio,

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

Esta es la forma:

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

Pero expliquemos cómo funciona esto:

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

El siguiente ejemplo devolverá todos los registros, desde la posición 0 hasta el último

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

El siguiente ejemplo devolverá los registros de 1 posición al último

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

Y aquí tienes lo que necesitas. El siguiente ejemplo devolverá los registros de la posición 0 a last-1

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

¿Has intentado "tomar"

a.take(3) 

Respuesta: a.τwτ pero primero debes instalar Pyper ...

Introducción de Pyper: ¿Conoces a Lispy cary cdrdevuelve "primero" y "resto" de la matriz? Solo para las necesidades como la suya, hice una extensión de este mecanismo Lispy. Se llama pypery le permite acceder también a la 2da, descansar de la 2da, 3ra, descansar de la 3d y también la última, todo excepto la última, etc. Eso no sería mucho sobre lo que escribir, pero también permite la composición de letras, al igual que caar, cadr, cdadaretc. conocido de 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)

y finalmente, la respuesta a tu pregunta:

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

Hay más:

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

Composiciones

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

También hay más caracteres de comando que solo a..f, u..zy 0..9, más notablemente m, significa mapa:

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

Pero otros caracteres de comando son demasiado calientes y no muy fáciles de usar en este momento.

Esto crea una nueva matriz con todos menos los últimos elementos del original:

ary2 = ary.dup
ary2.pop

Tenga en cuenta que algunos otros han sugerido usar #pop. Si está bien modificando la matriz en su lugar, está bien. Si no está de acuerdo con eso, duplique la matriz primero, como en este ejemplo.

A menudo me encuentro con ganas de todos menos los últimos n elementos de una matriz. He preparado mi propia función para hacer esto de una manera que me parece más legible que otras soluciones:

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

Ahora puedes hacer lo siguiente:

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

Deliberadamente he permitido el ArgumentError para que la persona que llama sea responsable de cómo usan este método. Me encantaría escuchar comentarios / críticas de este enfoque.

a = [1,2,3,4]

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