webentwicklung-frage-antwort-db.com.de

Wie kann ich einen Teil eines Arrays in Ruby zurückgeben?

Mit einer Liste in Python kann ich einen Teil davon mit folgendem Code zurückgeben:

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

Da Ruby alles in Arrays macht, frage ich mich, ob es etwas Ähnliches gibt.

Ja, Ruby hat eine sehr ähnliche Array-Slicing-Syntax wie Python. Hier ist die ri-Dokumentation für die Array-Index-Methode:

--------------------------------------------------------------- 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[5, 1]                #=> []
        a[5..10]               #=> []
144
Jeremy Ruten

Wenn Sie das Array auf einen Index i teilen/schneiden möchten,

arr = arr.drop(i)

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

Sie können slice () dafür verwenden:

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

Übrigens, Python "Listen" werden meines Wissens nach dynamisch wachsende Arrays effizient implementiert. Die Einfügung am Anfang ist in O (n), die Einfügung am Ende wird amortisiert O (1), der Direktzugriff ist O (1).

15
Manuel

eine andere Möglichkeit ist die Verwendung der Range-Methode

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

Ich mag Bereiche dafür:

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

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

Seien Sie jedoch sehr vorsichtig, ob der Endpunkt in Ihrem Bereich enthalten ist. Dies wird auf einer Liste mit ungerader Länge kritisch, in der Sie auswählen müssen, wo Sie die Mitte durchbrechen möchten. Andernfalls zählen Sie das mittlere Element doppelt.

Das obige Beispiel wird das mittlere Element in der letzten Hälfte durchgehend einfügen.

0
labyrinth