Tất cả trừ phần tử cuối cùng của mảng Ruby

Giả sử tôi có một mảng Ruby

a = [1, 2, 3, 4]

Nếu tôi muốn tất cả trừ mục đầu tiên, tôi có thể viết a.drop(1), thật tuyệt. Tuy nhiên, nếu tôi muốn tất cả trừ mục cuối cùng , tôi chỉ có thể nghĩ theo cách này

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

nhưng không ai trong số này có vẻ sạch như sử dụng drop. Bất kỳ cách tích hợp nào khác tôi đang thiếu?

Có lẽ...

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

hoặc là

a.take 3

hoặc là

a.first 3

hoặc là

a.pop

cái sẽ trả về cái cuối cùng và để lại mảng với mọi thứ trước nó

hoặc làm cho máy tính hoạt động cho bữa tối của nó:

a.reverse.drop(1).reverse

hoặc là

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]

Vì tò mò, tại sao bạn không thích a[0...-1]? Bạn muốn có được một lát của mảng, vì vậy toán tử lát có vẻ như là sự lựa chọn thành ngữ.

Nhưng nếu bạn cần gọi nó ở mọi nơi, bạn luôn có tùy chọn thêm một phương thức có tên thân thiện hơn với lớp Array, như DigitalRoss đề xuất. Có lẽ như thế này:

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

Một mẹo hay nữa

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

Nếu bạn muốn thực hiện một pop()thao tác trên một mảng (điều này sẽ dẫn đến mục cuối cùng bị xóa), nhưng bạn quan tâm đến việc lấy mảng thay vì một phần tử xuất hiện, bạn có thể sử dụng tap(&:pop):

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

Tôi làm như thế này:

my_array[0..-2]

Làm thế nào về việc tăng phương thức thả chính nó, ví dụ như thế này?

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

Sau đó, bạn có thể sử dụng kích thước âm để loại bỏ các phần tử từ cuối, như vậy:

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

a[0...-1]có vẻ như là cách tốt nhất Cú pháp cắt mảng được tạo ra cho chính xác mục đích này ...

Ngoài ra, nếu bạn không phiền sửa đổi mảng tại chỗ, bạn có thể gọi a.pop:

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

Để loại bỏ phần tử cuối cùng trong một dòng với phần còn lại quay lại

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

Nghiêm túc mà nói,

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

Đây là cách:

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

Nhưng hãy giải thích cách thức hoạt động của nó:

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

Ví dụ tiếp theo sẽ trả về tất cả các bản ghi, từ vị trí 0 đến cuối cùng

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

Ví dụ tiếp theo sẽ trả hồ sơ từ 1 vị trí đến cuối cùng

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

Và ở đây bạn có những gì bạn cần. Ví dụ tiếp theo sẽ trả về các bản ghi từ vị trí 0 cho đến 1

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

Bạn đã thử "lấy"

a.take(3) 

Trả lời : a.τwτ , nhưng bạn phải cài đặt Pyper trước ...

Giới thiệu Pyper: Bạn có biết Lispy carvà cdrtrả về "đầu tiên" và "phần còn lại" của mảng không? Chỉ với những nhu cầu như của bạn, tôi đã thực hiện một phần mở rộng của cơ chế Lispy này. Nó được gọi pypervà nó cho phép bạn truy cập cả thứ 2, phần còn lại từ thứ 2, thứ 3, phần còn lại từ 3d và cuối cùng, mọi thứ trừ cuối cùng, v.v. Điều đó sẽ không có gì nhiều để viết, nhưng nó cũng cho phép sáng tác chữ cái, giống như caar, cadr, cdadar, vv được biết đến từ 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)

và cuối cùng, câu trả lời cho câu hỏi của bạn:

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

Có nhiều:

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

Sáng tác:

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

Ngoài ra còn có nhiều ký tự lệnh hơn là a..f, u..zvà 0..9đáng chú ý nhất mlà bản đồ:

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

Nhưng các nhân vật lệnh khác quá nóng và không dễ sử dụng vào lúc này.

Điều này tạo ra một mảng mới với tất cả trừ các yếu tố cuối cùng của bản gốc:

ary2 = ary.dup
ary2.pop

Lưu ý rằng một vài người khác đã đề xuất sử dụng #pop. Nếu bạn đồng ý sửa đổi mảng tại chỗ, điều đó tốt. Nếu bạn không ổn với điều đó, thì hãy nhân đôi mảng trước, như trong ví dụ này.

Tôi thường thấy mình muốn tất cả trừ n phần tử cuối cùng của một mảng. Tôi đã sử dụng chức năng của riêng mình để thực hiện điều này theo cách mà tôi thấy dễ đọc hơn các giải pháp khác:

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

Bây giờ bạn có thể làm như sau:

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

Tôi đã cố tình cho phép ArgumentError để người gọi chịu trách nhiệm về cách họ sử dụng phương thức này. Tôi rất thích nghe ý kiến ​​/ phê bình về phương pháp này.

a = [1,2,3,4]

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