class Array

Ein Array-Objekt ist eine geordnete, ganzzahlig indizierte Sammlung von Objekten, die als Elemente bezeichnet werden; das Objekt stellt eine Array-Datenstruktur dar.

Ein Element kann jedes Objekt sein (sogar ein anderes Array); Elemente können jede Mischung von Objekten unterschiedlicher Typen sein.

Wichtige Datenstrukturen, die Arrays verwenden, sind:

Es gibt auch Array-ähnliche Datenstrukturen:

Array-Indizes

Die Array-Indizierung beginnt bei 0, wie in C oder Java.

Ein nicht-negativer Index ist ein Offset vom ersten Element.

Ein negativer Index ist ein Offset, rückwärts, vom Ende des Arrays.

In- und Out-of-Range-Indizes

Ein nicht-negativer Index ist im Bereich, wenn und nur wenn er kleiner ist als die Größe des Arrays. Für ein 3-Element-Array:

Ein negativer Index ist im Bereich, wenn und nur wenn sein Absolutwert nicht größer ist als die Größe des Arrays. Für ein 3-Element-Array:

Effektiver Index

Obwohl der effektive Index in ein Array immer eine Ganzzahl ist, akzeptieren einige Methoden (sowohl innerhalb der Klasse Array als auch anderswo) ein oder mehrere nicht-ganzzahlige Argumente, die integer-konvertierbare Objekte sind.

Arrays erstellen

Sie können ein Array-Objekt explizit erstellen mit:

Eine Reihe von Ruby-Methoden, sowohl im Kern als auch in der Standardbibliothek, bieten die Instanzmethode to_a, die ein Objekt in ein Array konvertiert.

Beispielverwendung

Zusätzlich zu den Methoden, die es über das Enumerable-Modul einbindet, verfügt die Klasse Array über eigene Methoden zum Zugriff, zur Suche und zur sonstigen Manipulation von Arrays.

Einige der gebräuchlichsten werden unten veranschaulicht.

Zugriff auf Elemente

Elemente in einem Array können mit der Methode Array#[] abgerufen werden. Sie kann ein einzelnes Ganzzahlargument (einen numerischen Index), ein Argumentpaar (Start und Länge) oder einen Bereich annehmen. Negative Indizes zählen vom Ende, wobei -1 das letzte Element ist.

arr = [1, 2, 3, 4, 5, 6]
arr[2]    #=> 3
arr[100]  #=> nil
arr[-3]   #=> 4
arr[2, 3] #=> [3, 4, 5]
arr[1..4] #=> [2, 3, 4, 5]
arr[1..-3] #=> [2, 3, 4]

Eine weitere Möglichkeit, auf ein bestimmtes Array-Element zuzugreifen, ist die Verwendung der Methode at.

arr.at(0) #=> 1

Die Methode slice funktioniert identisch mit Array#[].

Um einen Fehler für Indizes außerhalb des Array-Bereichs auszulösen oder einen Standardwert bereitzustellen, wenn dies geschieht, können Sie fetch verwenden.

arr = ['a', 'b', 'c', 'd', 'e', 'f']
arr.fetch(100) #=> IndexError: index 100 outside of array bounds: -6...6
arr.fetch(100, "oops") #=> "oops"

Die speziellen Methoden first und last geben das erste bzw. letzte Element eines Arrays zurück.

arr.first #=> 1
arr.last  #=> 6

Um die ersten n Elemente eines Arrays zurückzugeben, verwenden Sie take.

arr.take(3) #=> [1, 2, 3]

drop macht das Gegenteil von take, indem es die Elemente zurückgibt, nachdem n Elemente verworfen wurden.

arr.drop(3) #=> [4, 5, 6]

Informationen über ein Array erhalten

Ein Array verfolgt seine eigene Länge jederzeit. Um ein Array nach der Anzahl der darin enthaltenen Elemente abzufragen, verwenden Sie length, count oder size.

browsers = ['Chrome', 'Firefox', 'Safari', 'Opera', 'IE']
browsers.length #=> 5
browsers.count #=> 5

Um zu prüfen, ob ein Array überhaupt Elemente enthält:

browsers.empty? #=> false

Um zu prüfen, ob ein bestimmter Eintrag im Array enthalten ist:

browsers.include?('Konqueror') #=> false

Elemente zu einem Array hinzufügen

Elemente können am Ende eines Arrays hinzugefügt werden, indem entweder push oder << verwendet wird.

arr = [1, 2, 3, 4]
arr.push(5) #=> [1, 2, 3, 4, 5]
arr << 6    #=> [1, 2, 3, 4, 5, 6]

unshift fügt ein neues Element am Anfang eines Arrays hinzu.

arr.unshift(0) #=> [0, 1, 2, 3, 4, 5, 6]

Mit insert können Sie ein neues Element an jeder beliebigen Position in ein Array einfügen.

arr.insert(3, 'apple')  #=> [0, 1, 2, 'apple', 3, 4, 5, 6]

Mithilfe der Methode insert können Sie auch mehrere Werte auf einmal einfügen.

arr.insert(3, 'orange', 'pear', 'grapefruit')
#=> [0, 1, 2, "orange", "pear", "grapefruit", "apple", 3, 4, 5, 6]

Elemente aus einem Array entfernen

Die Methode pop entfernt das letzte Element aus einem Array und gibt es zurück.

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

Um das erste Element abzurufen und gleichzeitig zu entfernen, verwenden Sie shift.

arr.shift #=> 1
arr #=> [2, 3, 4, 5]

Um ein Element an einem bestimmten Index zu löschen:

arr.delete_at(2) #=> 4
arr #=> [2, 3, 5]

Um ein bestimmtes Element irgendwo in einem Array zu löschen, verwenden Sie delete.

arr = [1, 2, 2, 3]
arr.delete(2) #=> 2
arr #=> [1,3]

Eine nützliche Methode, wenn Sie nil-Werte aus einem Array entfernen müssen, ist compact.

arr = ['foo', 0, nil, 'bar', 7, 'baz', nil]
arr.compact  #=> ['foo', 0, 'bar', 7, 'baz']
arr          #=> ['foo', 0, nil, 'bar', 7, 'baz', nil]
arr.compact! #=> ['foo', 0, 'bar', 7, 'baz']
arr          #=> ['foo', 0, 'bar', 7, 'baz']

Ein weiterer häufiger Bedarf ist das Entfernen von Duplikaten aus einem Array.

Es gibt das nicht-destruktive uniq und die destruktive Methode uniq!.

arr = [2, 5, 6, 556, 6, 6, 8, 9, 0, 123, 556]
arr.uniq #=> [2, 5, 6, 556, 8, 9, 0, 123]

Iteration über ein Array

Wie alle Klassen, die das Enumerable-Modul einbinden, hat die Klasse Array eine `each`-Methode, die definiert, über welche Elemente und wie iteriert werden soll. Im Fall von Array#each werden alle Elemente von self nacheinander an den übergebenen Block übergeben.

Beachten Sie, dass diese Operation das Array unverändert lässt.

arr = [1, 2, 3, 4, 5]
arr.each {|a| print a -= 10, " "}
# prints: -9 -8 -7 -6 -5
#=> [1, 2, 3, 4, 5]

Ein weiterer manchmal nützlicher Iterator ist reverse_each, der die Elemente des Arrays in umgekehrter Reihenfolge durchläuft.

words = %w[first second third fourth fifth sixth]
str = ""
words.reverse_each {|word| str += "#{word} "}
p str #=> "sixth fifth fourth third second first "

Die Methode map kann verwendet werden, um ein neues Array basierend auf dem ursprünglichen Array zu erstellen, wobei die Werte jedoch durch den übergebenen Block modifiziert werden.

arr.map {|a| 2*a}     #=> [2, 4, 6, 8, 10]
arr                   #=> [1, 2, 3, 4, 5]
arr.map! {|a| a**2}   #=> [1, 4, 9, 16, 25]
arr                   #=> [1, 4, 9, 16, 25]

Elemente aus einem Array auswählen

Elemente können aus einem Array basierend auf Kriterien, die in einem Block definiert sind, ausgewählt werden. Die Auswahl kann destruktiv oder nicht-destruktiv erfolgen. Während die destruktiven Operationen das Array, auf dem sie aufgerufen wurden, ändern, geben die nicht-destruktiven Methoden normalerweise ein neues Array mit den ausgewählten Elementen zurück, lassen das ursprüngliche Array aber unverändert.

Nicht-destruktive Auswahl

arr = [1, 2, 3, 4, 5, 6]
arr.select {|a| a > 3}       #=> [4, 5, 6]
arr.reject {|a| a < 3}       #=> [3, 4, 5, 6]
arr.drop_while {|a| a < 4}   #=> [4, 5, 6]
arr                          #=> [1, 2, 3, 4, 5, 6]

Destruktive Auswahl

select! und reject! sind die entsprechenden destruktiven Methoden zu select und reject.

Ähnlich wie bei select vs. reject haben delete_if und keep_if bei gleichem Block das exakt entgegengesetzte Ergebnis.

arr.delete_if {|a| a < 4}   #=> [4, 5, 6]
arr                         #=> [4, 5, 6]

arr = [1, 2, 3, 4, 5, 6]
arr.keep_if {|a| a < 4}   #=> [1, 2, 3]
arr                       #=> [1, 2, 3]

Was gibt es hier

Zuerst, was anderswo ist. Klasse Array

Hier bietet die Klasse Array Methoden, die nützlich sind für:

Methoden zur Erstellung eines Arrays

Siehe auch Arrays erstellen.

Methoden zum Abfragen

Methoden zum Vergleichen

Methoden zum Abrufen

Diese Methoden ändern self nicht.

Methoden zum Zuweisen

Diese Methoden fügen Elemente hinzu, ersetzen oder ordnen sie in self neu.

Methoden zum Löschen

Jede dieser Methoden entfernt Elemente aus self.

Methoden zum Kombinieren

Methoden zur Iteration

Methoden zur Konvertierung

Andere Methoden