Tout sauf le dernier élément du tableau Ruby

Disons que j'ai un tableau Ruby

a = [1, 2, 3, 4]

Si je veux tout sauf le premier élément, je peux écrire a.drop(1), ce qui est génial. Si je veux tout sauf le dernier article, je ne peux penser qu'à cette façon

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

mais aucun de ceux-ci ne semble aussi propre que l'utilisation drop. Y a-t-il d'autres moyens intégrés qui me manquent?

Peut-être ...

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

qui renverra le dernier et quittera le tableau avec tout ce qui le précède

ou faire fonctionner l'ordinateur pour son dîner:

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]

Par curiosité, pourquoi n'aimez-vous pas a[0...-1]? Vous voulez obtenir une tranche du tableau, donc l'opérateur de tranche semble être le choix idiomatique.

Mais si vous avez besoin d'appeler cela partout, vous avez toujours la possibilité d'ajouter une méthode avec un nom plus convivial à la classe Array, comme DigitalRoss l'a suggéré. Peut-être comme ceci:

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

Un autre truc sympa

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

Si vous souhaitez effectuer une pop()opération sur un tableau (ce qui entraînera la suppression du dernier élément), mais que vous souhaitez obtenir le tableau au lieu d'un élément popped, vous pouvez utiliser tap(&:pop):

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

Je fais ça comme ça:

my_array[0..-2]

Que diriez-vous d'augmenter la méthode drop elle-même, par exemple comme ça?

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

Ensuite, vous pouvez utiliser une taille négative pour supprimer des éléments de la fin, comme ceci:

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

a[0...-1]semble être le meilleur moyen. La syntaxe de découpage de tableau a été créée exactement dans ce but ...

Sinon, si cela ne vous dérange pas de modifier le tableau en place, vous pouvez simplement appeler a.pop:

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

Pour se débarrasser du dernier élément d'une ligne avec le reste retournant

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

Sérieusement,

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

Ceci est le chemin:

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

Mais expliquons comment cela fonctionne:

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

L'exemple suivant retournera tous les enregistrements, de la position 0 au dernier

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

L'exemple suivant renverra les enregistrements d'une position à la dernière

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

Et ici, vous avez ce dont vous avez besoin. L'exemple suivant renverra les enregistrements de la position 0 au dernier-1

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

Avez-vous essayé de "prendre"

a.take(3) 

Réponse:, a.τwτ mais vous devez d'abord installer Pyper ...

Pyper intro: Connaissez-vous Lispy caret le cdrretour du "premier" et du "reste" du tableau? Juste pour des besoins comme les vôtres, j'ai fait une extension de ce mécanisme Lispy. Il s'appelle pyper, et il vous permet d'accéder également au 2ème, au repos du 2ème, au 3ème, au repos de 3d, et aussi au dernier, à tout sauf le dernier, etc. caar, cadr, cdadaretc. connu 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)

et enfin, la réponse à votre question:

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

Il y a plus:

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

Compositions:

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

Il y a aussi plus de caractères de commande que juste a..f, u..zet 0..9, plus particulièrement m, signifiant map:

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

Mais d'autres caractères de commande sont trop chauds et pas très faciles à utiliser pour le moment.

Cela crée un nouveau tableau avec tous les éléments de l'original sauf les derniers:

ary2 = ary.dup
ary2.pop

Notez que quelques autres ont suggéré d'utiliser #pop. Si vous êtes d'accord pour modifier le tableau en place, c'est très bien. Si cela ne vous convient pas, doublez d'abord le tableau, comme dans cet exemple.

Je me retrouve souvent à vouloir tout sauf les n derniers éléments d'un tableau. J'ai conçu ma propre fonction pour le faire d'une manière que je trouve plus lisible que d'autres solutions:

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

Vous pouvez maintenant effectuer les opérations suivantes:

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

J'ai délibérément autorisé ArgumentError afin que l'appelant soit responsable de la façon dont il utilise cette méthode. J'aimerais entendre les commentaires / critiques de cette approche.

a = [1,2,3,4]

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