Wszystko oprócz ostatniego elementu tablicy Ruby

Powiedzmy, że mam tablicę Ruby

a = [1, 2, 3, 4]

Jeśli chcę wszystko oprócz pierwszej, mogę napisać a.drop(1), co jest świetne. Jeśli jednak chcę wszystko oprócz ostatniego , mogę myśleć tylko w ten sposób

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

ale żaden z nich nie wydaje się tak czysty jak używanie drop. Brakuje mi jakichś innych wbudowanych sposobów?

Być może...

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

lub

a.take 3

lub

a.first 3

lub

a.pop

co zwróci ostatnią i pozostawi tablicę ze wszystkim przed nią

lub spraw, aby komputer działał na obiad:

a.reverse.drop(1).reverse

lub

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]

Z ciekawości, dlaczego nie lubisz a[0...-1]? Chcesz uzyskać wycinek tablicy, więc operator wycinka wydaje się idiomatycznym wyborem.

Ale jeśli chcesz wywoływać to wszędzie, zawsze masz możliwość dodania metody o bardziej przyjaznej nazwie do klasy Array, jak zasugerował DigitalRoss. Może tak:

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

Kolejna fajna sztuczka

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

Jeśli chcesz wykonać pop()operację na tablicy (co spowoduje usunięcie ostatniego elementu), ale jesteś zainteresowany uzyskaniem tablicy zamiast elementu wyskakującego, możesz użyć tap(&:pop):

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

Robię to tak:

my_array[0..-2]

A co powiesz na rozszerzenie samej metody upuszczania, na przykład w ten sposób?

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

Następnie możesz użyć rozmiaru ujemnego, aby usunąć elementy z końca, na przykład:

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

a[0...-1]wydaje się najlepszym sposobem. Składnia wycinania tablic została stworzona właśnie w tym celu ...

Alternatywnie, jeśli nie masz nic przeciwko modyfikowaniu tablicy w miejscu, możesz po prostu wywołać a.pop:

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

Pozbyć się ostatniego elementu w jednej linii, a reszta wraca

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

Ale naprawdę,

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

To jest sposób:

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

Ale wyjaśnijmy, jak to działa:

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

Następny przykład zwróci wszystkie rekordy, od pozycji 0 do ostatniej

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

Następny przykład zwróci rekordy od 1 pozycji do ostatniej

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

I tutaj masz to, czego potrzebujesz. Następny przykład zwróci rekordy od pozycji 0 do ostatniej-1

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

Czy próbowałeś „wziąć”

a.take(3) 

Odpowiedź: a.τwτ ale najpierw musisz zainstalować Pypera ...

Pyper intro: Czy znasz Lispy cari zwracasz cdr„pierwszy” i „reszta” tablicy? Tylko dla potrzeb takich jak Twoje, stworzyłem rozszerzenie tego mechanizmu Lispy. Nazywa się pyperi pozwala na dostęp również do 2, reszta od 2, 3, reszta z 3d, a także ostatnia, wszystko oprócz ostatniego itp. Nie byłoby o czym pisać, ale pozwala również na składanie liter, tak jak caar, cadr, cdadaritd. wiadomo od Lispie:

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

i na koniec odpowiedź na Twoje pytanie:

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

Jest więcej:

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

Kompozycje:

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

Istnieje również więcej znaków niż tylko polecenie a..f, u..zi 0..9, przede wszystkim m, czyli mapa:

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

Ale inne postacie poleceń są w tej chwili zbyt gorące i niezbyt łatwe w użyciu.

To tworzy nową tablicę zawierającą wszystkie elementy oryginału oprócz ostatnich:

ary2 = ary.dup
ary2.pop

Zwróć uwagę, że kilka innych osób zasugerowało użycie #pop. Jeśli możesz modyfikować tablicę w miejscu, w porządku. Jeśli nie jesteś z tym w porządku, najpierw duplikuj tablicę, jak w tym przykładzie.

Często okazuje się, że chcę mieć wszystkie elementy tablicy oprócz ostatnich n. Skonfigurowałem własną funkcję, aby robić to w sposób, który uważam za bardziej czytelny niż inne rozwiązania:

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

Teraz możesz wykonać następujące czynności:

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

Celowo dopuściłem ArgumentError, aby wywołujący był odpowiedzialny za sposób, w jaki używają tej metody. Chciałbym usłyszeć komentarze / krytykę tego podejścia.

a = [1,2,3,4]

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