Ruby'de bir dizinin bir parçası nasıl döndürülür?

Python'da bir liste ile, aşağıdaki kodu kullanarak bir kısmını iade edebilirim:

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

Ruby dizilerdeki her şeyi yaptığından, buna benzer bir şey olup olmadığını merak ediyorum.

Evet, Ruby, Python'a çok benzer dizi dilimleme sözdizimine sahiptir. İşte ridizi dizini yöntemi için belgeleri:

--------------------------------------------------------------- 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]               #=> []

Diziyi bir i dizininde bölmek / kesmek istiyorsanız,

arr = arr.drop(i)

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

Bunun için dilim () kullanabilirsiniz :

>> 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]

Bu arada, bildiğim kadarıyla, Python "listeleri" sadece verimli bir şekilde dinamik olarak büyüyen dizilerdir. Başlangıçta ekleme O (n), sondaki ekleme amortisman O (1), rastgele erişim O (1).

başka bir yol da aralık yöntemini kullanmaktır

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 Başlangıçsız / Sonsuz Aralıklar

(..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"]

Bunun için aralıkları seviyorum:

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

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

Ancak, uç noktanın aralığınıza dahil edilip edilmediğine çok dikkat edin. Ortayı nerede kıracağınızı seçmeniz gereken garip uzunluklu bir listede bu kritik hale gelir. Aksi takdirde ortadaki öğeyi iki kez sayarsınız.

Yukarıdaki örnek, orta elemanı tutarlı bir şekilde son yarıya koyacaktır.