Mit Arrays arbeiten

Über Arrays als Ganzes kann man Folgendes erfahren:

e.size        #-> 5
e.length      #-> 5
e.nitems      #-> 4
e.eql?(d)     #-> false
e.eql?(a+b)   #-> true

Mit nitems erhält man die Zahl der von nil verschiedenen Elemente des Arrays. Die Methode eql? überprüft die beteiligten Arrays elementweise auf Gleichheit, es müssen also die Längen übereinstimmen und jedes Element muss zu seinem Gegenstück eql? sein.

f.clear         #-> []
f               #-> []
d.compact       #-> [1, "2"]
e.uniq          #-> [nil, 1, "2"]
e[1..3]         #-> [1, "2", 1]
e.slice(1, 4)   #-> [1, "2", 1, "2"]
b.reverse       #-> ["2", 1]
[3, 2, 1].sort  #-> [1, 2, 3]
d.to_s          #-> "12"
d.join('.')     #-> ".1.2"

clear löscht alle vorhandenen Elemente aus dem Array, während compact nur nil-Elemente entfernt und uniq nur noch eindeutige Einträge übrig lässt. Mit slice wird ein Teil des Arrays ausgeschnitten, die hier gezeigte Variante erhält Startposition und Länge als Argument. to_s erzeugt einen String, in dem die einzelnen Elemente direkt aneinander gehängt sind. Bei join kann ein Trenntext angegeben werden, der zwischen den einzelnen Elementen eingefügt wird.

Wenn man bei der Sortierung die Groß- und Kleinschreibung ignorieren möchte, bieten sich folgende Möglichkeiten an:

array = %w( z bB Bb BB bb Aa aA AA aa a )
puts array.sort { |a,b| 
  a.downcase <=> b.downcase
}   #-> a aa AA aA Aa bb BB bB Bb z

oder auch

puts array.sort { |a,b|
  (a.downcase <=> b.downcase).nonzero? ||
    a <=> b
}   #-> a AA Aa aA aa BB Bb bB bb z

Arrays können selbst wieder Arrays enthalten. Mit der Methode flatten wird eine beliebig tief verschachtelte Array-Struktur ``platt'' gemacht, so dass alle Elemente in einem einzigen Array stehen.

[0, [1, 2], [3, [4, 5]], 6].flatten
  #-> [0, 1, 2, 3, 4, 5, 6]

Arrays können sich wie Stapel verhalten, dafür bietet Ruby die Methoden push und pop an, die am Ende des Arrays neue Elemente anfügen bzw. entfernen. Analog zur Shell-Programmierung unter Unix-Varianten können mit shift Elemente vom Anfang des Arrays entfernt werden bzw. mit unshift dort eingefügt werden. Schließlich gibt es auch noch die Möglichkeit, das Array an einer bestimmten Stelle zu modifizieren:

a = ["a", "b", "c"]
a.pop             #-> "c"
a                 #-> ["a", "b"]
a.push(2)         #-> ["a", "b", 2]
a.shift           #-> "a"
a                 #-> ["b", 2]
a.unshift(3)      #-> [3, "b", 2]
a[1] = 4
a                 #-> [3, 4, 2]
a[1..2] = [5, 4, 3]
a                 #-> [3, 5, 4, 3]
a[1...1] = [4]
a                 #-> [3, 4, 5, 4, 3]

Im vorletzten Beispiel wird ein Teilarray nahtlos durch ein anderes Array ersetzt, während mit einem ``leeren Bereich'' im letzten Beispiel ein Array - ebenfalls nahtlos - eingefügt wird.

Um den Unterschied zwischen der ..- und ...-Notation zu veranschaulichen, seien die folgenden Beispiele aufgeführt:

b = [1, 2, 3, 4]
b[1..3]     #-> [2, 3, 4]
b[1..1]     #-> [2]
b[1...3]    #-> [2, 3]
b[1...1]    #-> []

Im Gegensatz zu ...- schließt die ..-Notation die Endposition mit ein.

Array-Elemente können auch einzeln gelöscht werden. delete entfernt alle Vorkommen des angegebenen Objekts, delete_at entfernt die angegebene Stelle aus dem Array.

a                 #-> [3, 4, 5, 4, 3]
a.delete(4)       #-> 4
a                 #-> [3, 5, 3]
a.delete_at(0)    #-> 3
a                 #-> [5, 3]

Neben der üblichen Schreibweise, ein Array-Element über seinen Index anzusprechen, bietet Ruby noch weitere Möglichkeiten, mit denen eleganter und kompakter Code geschrieben werden kann:

a = [4, 3, 2, 1]
a[2]             #-> 2
a.at(2)          #-> 2
a.first          #-> 4
a.last           #-> 1
a.include?(3)    #-> true
a.index(4)       #-> 0
a.index(5)       #-> nil
a.indexes(3, 1)  #-> [1, 3]

Um auf ein einzelnes Element zuzugreifen, sollte man at verwenden, da dies schneller ist. Dafür kann [] mit Bereichen umgehen.

include? gibt an, ob das Argument im Array enthalten ist, index liefert zusätzlich noch die Position, an der das Element zum ersten Mal auftritt. Mit indexes können mehrere Elemente in einer beliebigen Reihenfolge aus dem Array herausgezogen und in ein neues Array kopiert werden.

Ruby implementiert die aus Lisp bekannten Assoziationen als Array von Arrays. Mit assoc und rassoc können einzelne Elemente aufgespürt werden. Assoziationslisten sind Hashtabellen ähnlich, haben aber gleichwertige Zugriffskosten für Schlüssel und Werte, während bei Hashtabellen das Finden eines Schlüssels zu einem Wert ungleich länger dauert als das Finden eines Wertes zu einem Schlüssel.

al = [[1, 2], [3, 4], [5, 6]]
al.assoc(3)      #-> [3, 4]
al.assoc(4)      #-> nil
al.rassoc(4)     #-> [3, 4]

Footnotes

... index

rindex beginnt hinten

... indexes

indexes == indices