Tutti tranne l'ultimo elemento dell'array Ruby

Diciamo che ho un array Ruby

a = [1, 2, 3, 4]

Se voglio tutto tranne il primo elemento, posso scrivere a.drop(1), il che è fantastico. Se voglio tutto tranne l' ultimo articolo, però, posso solo pensare a questo modo

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

ma nessuno di questi sembra pulito come l'utilizzo drop. Mi mancano altri modi integrati?

Forse...

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

che restituirà l'ultimo e lascerà l'array con tutto ciò che lo precede

o fai funzionare il computer per la sua 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]

Per curiosità, perché non ti piace a[0...-1]? Si desidera ottenere una porzione dell'array, quindi l'operatore sezione sembra la scelta idiomatica.

Ma se hai bisogno di chiamarlo ovunque, hai sempre la possibilità di aggiungere un metodo con un nome più amichevole alla classe Array, come suggerito da DigitalRoss. Forse così:

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

Un altro trucco interessante

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

Se desideri eseguire pop()un'operazione su un array (che comporterà l'eliminazione dell'ultimo elemento), ma sei interessato a ottenere l'array anziché un elemento spuntato, puoi utilizzare tap(&:pop):

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

Lo faccio così:

my_array[0..-2]

Che ne dici di aumentare il metodo drop stesso, ad esempio in questo modo?

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

Quindi puoi utilizzare una dimensione negativa per rimuovere gli elementi dall'estremità, in questo modo:

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

a[0...-1]sembra il modo migliore. La sintassi di suddivisione in array è stata creata proprio per questo scopo ...

In alternativa, se non ti dispiace modificare l'array in atto, puoi semplicemente chiamare a.pop:

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

Per sbarazzarsi dell'ultimo elemento in una riga con il resto che ritorna

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

Seriamente però,

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

Questo è il modo:

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

Ma spieghiamo come funziona:

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

Il prossimo esempio restituirà tutti i record, dalla posizione 0 all'ultimo

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

Il prossimo esempio restituirà i record da 1 posizione all'ultima

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

E qui hai quello che ti serve. Il prossimo esempio restituirà i record dalla posizione 0 all'ultimo-1

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

Hai provato a "prendere"

a.take(3) 

Risposta:, a.τwτ ma devi prima installare Pyper ...

Introduzione di Pyper: conosci Lispy care cdrrestituisce "primo" e "resto" dell'array? Proprio per le esigenze come la tua, ho fatto un'estensione di questo meccanismo di Lispy. Si chiama pypere ti permette di accedere anche al 2o, resto dal 2o, 3o, resto da 3d, e anche ultimo, tutto tranne lo scorso ecc. Non sarebbe molto da scrivere, ma consente anche la composizione di lettere, proprio come caar, cadr, cdadarecc nota dal 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 infine, la risposta alla tua domanda:

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

C'è dell'altro:

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

composizione:

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

Ci sono anche più caratteri di comando che solo a..f, u..ze 0..9, più in particolare m, nel senso mappa:

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

Ma altri personaggi di comando sono troppo caldi e non molto facili da usare al momento.

Questo crea un nuovo array con tutti tranne gli ultimi elementi dell'originale:

ary2 = ary.dup
ary2.pop

Nota che alcuni altri hanno suggerito di usare #pop. Se stai bene modificando l'array sul posto, va bene. Se non ti va bene, duplica prima l'array, come in questo esempio.

Mi ritrovo spesso a desiderare tutto tranne gli ultimi n elementi di un array. Ho truccato la mia funzione per farlo in un modo che trovo più leggibile rispetto ad altre soluzioni:

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

Ora puoi fare quanto segue:

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

Ho deliberatamente consentito l'ArgumentError in modo che il chiamante sia responsabile dell'utilizzo di questo metodo. Mi piacerebbe sentire commenti / critiche a questo approccio.

a = [1,2,3,4]

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