Ruby에서 어레이의 일부를 반환하려면 어떻게 해야 합니까?

Ruby에서 어레이의 일부를 반환하려면 어떻게 해야 합니까?

Python 목록에서는 다음 코드를 사용하여 일부를 반환할 수 있습니다.

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

Ruby가 어레이로 모든 것을 하기 때문에, 그것과 같은 것이 있는지 궁금합니다.

네, Ruby는 Python과 매우 유사한 배열 슬라이싱 구문을 가지고 있습니다.여기 있습니다ri어레이 인덱스 방법에 대한 매뉴얼:

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

인덱스 i의 어레이를 분할/절단하려면

arr = arr.drop(i)

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

여기에는 slice()를 사용할 수 있습니다.

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

참고로 Python의 "목록"은 동적으로 증가하는 어레이를 효율적으로 구현한 것입니다.첫 번째 삽입은 O(n), 끝 삽입은 O(1), 랜덤 액세스는 O(1)입니다.

Ruby 2.6 시작/끝없는 범위

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

또 다른 방법은 범위 방법을 사용하는 것입니다.

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]

이 범위는 다음과 같습니다.

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

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

그러나 엔드포인트가 범위에 포함되어 있는지 여부에 대해서는 매우 주의해야 합니다.이것은 중간을 깰 곳을 선택해야 하는 홀수 길이의 리스트에서 매우 중요합니다.그렇지 않으면 중간 요소를 이중으로 세게 됩니다.

위의 예에서는 중간 요소가 항상 마지막 절반에 배치됩니다.

언급URL : https://stackoverflow.com/questions/695290/how-to-return-a-part-of-an-array-in-ruby