Semua kecuali elemen terakhir dari array Ruby

Katakanlah saya memiliki array Ruby

a = [1, 2, 3, 4]

Jika saya ingin semua kecuali item pertama, saya bisa menulis a.drop(1), yang bagus. Jika saya ingin semua kecuali item terakhir , saya hanya bisa memikirkan cara ini

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

tapi tak satu pun dari ini tampak sebersih menggunakan drop. Adakah cara bawaan lain yang saya lewatkan?

Mungkin...

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

atau

a.take 3

atau

a.first 3

atau

a.pop

yang akan mengembalikan yang terakhir dan meninggalkan array dengan segalanya sebelumnya

atau buat komputer berfungsi untuk makan malamnya:

a.reverse.drop(1).reverse

atau

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]

Karena penasaran, mengapa Anda tidak suka a[0...-1]? Anda ingin mendapatkan sepotong array, sehingga operator slice sepertinya pilihan idiomatik.

Tetapi jika Anda perlu memanggil ini di mana-mana, Anda selalu memiliki opsi untuk menambahkan metode dengan nama yang lebih ramah ke kelas Array, seperti yang disarankan DigitalRoss. Mungkin seperti ini:

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

Trik keren lainnya

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

Jika Anda ingin melakukan pop()operasi pada array (yang akan menghasilkan item terakhir dihapus), tetapi Anda tertarik untuk mendapatkan array daripada elemen yang muncul, Anda dapat menggunakan tap(&:pop):

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

Saya melakukannya seperti ini:

my_array[0..-2]

Bagaimana kalau menambah metode drop itu sendiri, misalnya seperti ini?

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

Kemudian Anda dapat menggunakan ukuran negatif untuk menghapus elemen dari ujung, seperti:

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

a[0...-1]sepertinya cara terbaik. Sintaks pengiris array diciptakan untuk tujuan ini ...

Atau, jika Anda tidak keberatan memodifikasi array di tempat, Anda bisa memanggil a.pop:

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

Untuk menghilangkan elemen terakhir dalam satu baris dengan sisanya kembali

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

Serius,

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

Begini caranya:

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

Tapi mari kita jelaskan bagaimana ini bekerja:

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

Contoh berikutnya akan mengembalikan semua catatan, dari 0 posisi ke terakhir

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

Contoh berikutnya akan mengembalikan catatan dari 1 posisi ke posisi terakhir

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

Dan di sini Anda memiliki apa yang Anda butuhkan. Contoh berikutnya akan mengembalikan catatan dari 0 posisi ke 1 terakhir

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

Sudahkah Anda mencoba "ambil"

a.take(3) 

Jawab :,a.τwτ tetapi Anda harus menginstal Pyper terlebih dahulu ...

Pyper intro: Apakah Anda tahu Lispy cardan cdrmengembalikan "pertama" dan "sisanya" dari array? Hanya untuk kebutuhan seperti kebutuhan Anda, saya membuat perpanjangan mekanisme Lispy ini. Ini disebut pyper, dan memungkinkan Anda untuk mengakses juga ke-2, istirahat dari ke-2, ke-3, istirahat dari 3d, dan juga yang terakhir, semuanya kecuali yang terakhir dll. Itu tidak akan banyak untuk ditulis, tetapi juga memungkinkan komposisi huruf, seperti caar, cadr, cdadardll diketahui dari 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)

dan akhirnya, jawaban untuk pertanyaan Anda:

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

Masih ada lagi:

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

Komposisi:

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

Ada juga lebih banyak karakter perintah dari sekadar a..f, u..zdan 0..9, yang paling penting m, yang berarti peta:

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

Tetapi karakter perintah lainnya terlalu panas dan tidak mudah digunakan saat ini.

Ini membuat array baru dengan semua kecuali elemen terakhir dari aslinya:

ary2 = ary.dup
ary2.pop

Perhatikan bahwa beberapa orang lain menyarankan untuk menggunakan #pop. Jika Anda ok memodifikasi array di tempatnya, tidak apa-apa. Jika Anda tidak setuju dengan itu, dup duplikat array terlebih dahulu, seperti dalam contoh ini.

Saya sering menemukan diri saya menginginkan semua kecuali elemen terakhir dari array. Saya telah memperjelas fungsi saya sendiri untuk melakukan ini dengan cara yang menurut saya lebih mudah dibaca daripada solusi lain:

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

Sekarang Anda dapat melakukan hal berikut:

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

Saya sengaja mengizinkan ArgumentError sehingga penelepon bertanggung jawab atas cara mereka menggunakan metode ini. Saya ingin mendengar komentar / kritik terhadap pendekatan ini.

a = [1,2,3,4]

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