Làm thế nào để trả về một phần của một mảng trong Ruby?

Với một danh sách trong Python tôi có thể trả về một phần của nó bằng mã sau:

foo = [1,2,3,4,5,6]
bar = [10,20,30,40,50,60]
half = len(foo) / 2
foobar = foo[:half] + bar[half:]

Vì Ruby làm mọi thứ trong mảng, tôi tự hỏi liệu có thứ gì tương tự như vậy không.

Có, Ruby có cú pháp cắt mảng rất giống với Python. Dưới đây là ritài liệu cho phương pháp chỉ mục mảng:

--------------------------------------------------------------- Array#[]
     array[index]                -> obj      or nil
     array[start, length]        -> an_array or nil
     array[range]                -> an_array or nil
     array.slice(index)          -> obj      or nil
     array.slice(start, length)  -> an_array or nil
     array.slice(range)          -> an_array or nil
------------------------------------------------------------------------
     Element Reference---Returns the element at index, or returns a 
     subarray starting at start and continuing for length elements, or 
     returns a subarray specified by range. Negative indices count 
     backward from the end of the array (-1 is the last element). 
     Returns nil if the index (or starting index) are out of range.

        a = [ "a", "b", "c", "d", "e" ]
        a[2] +  a[0] + a[1]    #=> "cab"
        a[6]                   #=> nil
        a[1, 2]                #=> [ "b", "c" ]
        a[1..3]                #=> [ "b", "c", "d" ]
        a[4..7]                #=> [ "e" ]
        a[6..10]               #=> nil
        a[-3, 3]               #=> [ "c", "d", "e" ]
        # special cases
        a[5]                   #=> nil
        a[6, 1]                #=> nil
        a[5, 1]                #=> []
        a[5..10]               #=> []

Nếu bạn muốn tách / cắt mảng trên chỉ mục i,

arr = arr.drop(i)

> arr = [1,2,3,4,5]
 => [1, 2, 3, 4, 5] 
> arr.drop(2)
 => [3, 4, 5] 

Bạn có thể sử dụng lát () cho việc này:

>> foo = [1,2,3,4,5,6]
=> [1, 2, 3, 4, 5, 6]
>> bar = [10,20,30,40,50,60]
=> [10, 20, 30, 40, 50, 60]
>> half = foo.length / 2
=> 3
>> foobar = foo.slice(0, half) + bar.slice(half, foo.length)
=> [1, 2, 3, 40, 50, 60]

Nhân tiện, theo hiểu biết tốt nhất của tôi, "danh sách" Python chỉ được triển khai một cách hiệu quả các mảng phát triển động. Chèn ở đầu là O (n), chèn ở cuối được khấu hao O (1), truy cập ngẫu nhiên là O (1).

một cách khác là sử dụng phương thức phạm vi

foo = [1,2,3,4,5,6]
bar = [10,20,30,40,50,60]
a = foo[0...3]
b = bar[3...6]

print a + b 
=> [1, 2, 3, 40, 50 , 60]

Ruby 2.6 Phạm vi vô tận / vô tận

(..1)
# or
(...1)

(1..)
# or
(1...)

[1,2,3,4,5,6][..3]
=> [1, 2, 3, 4]

[1,2,3,4,5,6][...3]
 => [1, 2, 3]

ROLES = %w[superadmin manager admin contact user]
ROLES[ROLES.index('admin')..]
=> ["admin", "contact", "user"]

Tôi thích phạm vi cho điều này:

def first_half(list)
  list[0...(list.length / 2)]
end

def last_half(list)
  list[(list.length / 2)..list.length]
end

Tuy nhiên, hãy thật cẩn thận về việc liệu điểm cuối có được bao gồm trong phạm vi của bạn hay không. Điều này trở nên quan trọng trong một danh sách có độ dài lẻ, nơi bạn cần chọn nơi bạn sẽ phá vỡ giữa chừng. Nếu không, bạn sẽ kết thúc hai lần đếm phần tử ở giữa.

Ví dụ trên sẽ liên tục đưa phần tử ở giữa vào nửa cuối.