Alle bis auf das letzte Element des Ruby-Arrays

Angenommen, ich habe ein Ruby-Array

a = [1, 2, 3, 4]

Wenn ich alle bis auf den ersten Artikel haben möchte, kann ich schreiben a.drop(1), was großartig ist. Wenn ich aber alle bis auf den letzten Punkt haben möchte , kann ich nur so denken

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

aber keines davon scheint so sauber wie das Verwenden drop. Gibt es noch andere Möglichkeiten, die mir fehlen?

Vielleicht...

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

oder

a.take 3

oder

a.first 3

oder

a.pop

Dadurch wird das letzte zurückgegeben und das Array mit allem davor belassen

oder lassen Sie den Computer für das Abendessen arbeiten:

a.reverse.drop(1).reverse

oder

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]

Warum magst du aus Neugier nicht a[0...-1]? Sie möchten ein Slice des Arrays erhalten, daher scheint der Slice-Operator die idiomatische Wahl zu sein.

Wenn Sie dies jedoch überall aufrufen müssen, haben Sie immer die Möglichkeit, der Array-Klasse eine Methode mit einem benutzerfreundlicheren Namen hinzuzufügen, wie von DigitalRoss vorgeschlagen. Vielleicht so:

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

Ein weiterer cooler Trick

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

Wenn Sie eine pop()Operation für ein Array ausführen möchten (was dazu führt, dass das letzte Element gelöscht wird), aber das Array anstelle eines geplatzten Elements erhalten möchten, können Sie Folgendes verwenden tap(&:pop):

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

So mach ich es:

my_array[0..-2]

Wie wäre es beispielsweise mit einer Erweiterung der Drop-Methode selbst?

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

Dann können Sie eine negative Größe verwenden, um Elemente vom Ende zu entfernen, wie folgt:

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

a[0...-1]scheint der beste Weg zu sein. Die Array-Slicing-Syntax wurde genau zu diesem Zweck erstellt ...

Wenn es Ihnen nichts ausmacht, das vorhandene Array zu ändern, können Sie alternativ einfach Folgendes aufrufen a.pop:

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

Das letzte Element in einer Zeile entfernen, während der Rest zurückkehrt

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

Aber im Ernst,

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

Das ist der Weg:

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

Aber lassen Sie uns erklären, wie das funktioniert:

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

Im nächsten Beispiel werden alle Datensätze von der 0-Position bis zur letzten zurückgegeben

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

Im nächsten Beispiel werden Datensätze von 1 Position bis zur letzten zurückgegeben

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

Und hier haben Sie was Sie brauchen. Im nächsten Beispiel werden Datensätze von der Position 0 bis zur letzten 1 zurückgegeben

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

Haben Sie versucht, "nehmen"

a.take(3) 

Antwort: a.τwτ aber Sie müssen zuerst Pyper installieren ...

Pyper-Intro: Kennen Sie Lispy carund geben Sie cdr"first" und "rest" des Arrays zurück? Nur für Ihre Bedürfnisse habe ich diesen Lispy-Mechanismus erweitert. Es heißt pyper, und es ermöglicht Ihnen den Zugriff auf die 2., die Pause von der 2., 3., die Pause von 3D und auch die letzte, alles außer der letzten usw. Das wäre nicht viel zu schreiben, aber es erlaubt auch die Komposition von Buchstaben, genau wie caar, cadr, cdadaretc. von Lisp bekannt:

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

und schließlich die Antwort auf Ihre Frage:

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

Es gibt mehr:

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

Kompositionen:

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

Darüber hinaus gibt es mehr als nur Befehl Zeichen a..f, u..zund 0..9, vor allem m, was bedeutet , Karte:

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

Aber andere Befehlszeichen sind zu heiß und im Moment nicht sehr einfach zu bedienen.

Dadurch wird ein neues Array mit allen bis auf die letzten Elemente des Originals erstellt:

ary2 = ary.dup
ary2.pop

Beachten Sie, dass einige andere vorgeschlagen haben, #pop zu verwenden. Wenn Sie in Ordnung sind, das Array an Ort und Stelle zu ändern, ist das in Ordnung. Wenn Sie damit nicht einverstanden sind, dupen Sie zuerst das Array, wie in diesem Beispiel.

Ich möchte oft alle bis auf die letzten n Elemente eines Arrays. Ich habe meine eigene Funktion so eingerichtet, dass ich sie besser lesbar finde als andere Lösungen:

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

Jetzt können Sie Folgendes tun:

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

Ich habe den ArgumentError absichtlich zugelassen, damit der Aufrufer dafür verantwortlich ist, wie er diese Methode verwendet. Ich würde gerne Kommentare / Kritik zu diesem Ansatz hören.

a = [1,2,3,4]

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