Die Programmiersprache Ruby (German Edition)

Differenzmenge auszuführen. Zudem definiert sie
include?
, um die Anwesenheit eines Wertes in einem Array zu testen. Es werden sogar
uniq
und
uniq!
definiert, um doppelte Werte aus einem Array zu entfernen (Mengen erlauben keine Duplikate).
Array
bietet keine sehr effiziente Mengenimplementierung (dafür können Sie die Klasse
Set
aus der Standardbibliothek nutzen), aber es ist ausreichend für kleine Mengen:
[1,3,5] & [1,2,3] # => [1,3]: Schnittmenge
[1,1,3,5] & [1,2,3] # => [1,3]: doppelte Einträge entfernt
[1,3,5] | [2,4,6] # => [1,3,5,2,4,6]: Vereinigungsmenge
[1,3,5,5] | [2,4,6,6] # => [1,3,5,2,4,6]: doppelte Einträge entfernt
[1,2,3] - [2,3] # => [1]: Differenzmenge
[1,1,2,2,3,3] - [2, 3] # => [1,1]: nicht alle doppelten Einträge entfernt
small = 0..10.to_a # Eine Menge kleiner Zahlen
even = 0..50.map {|x| x*2} # Eine Menge mit geraden Zahlen
smalleven = small & even # Vereinigungsmenge
smalleven.include?(8) # => true: Wert vorhanden?
[1, 1, nil, nil].uniq # => [1, nil]: entferne doppelte Einträge. Auch uniq!
    Beachten Sie, dass die Operatoren
&
,
|
und
-
nicht die Reihenfolge der Elemente des Array festlegen, das sie zurückgeben. Verwenden Sie diese Operatoren nur, wenn Ihr Array tatsächlich eine ungeordnete Menge von Werten repräsentiert.
    In Ruby 1.9 definiert die Klasse
Array
Kombinatorikmethoden für das Ermitteln von Permutationen, Kombinationen und kartesischen Produkten:
a = [1,2,3]
# Iteriere alle möglichen Zwei-Element-Untermengen (Reihenfolge ist wichtig)
a.permutation(2) {|x| print x } # Ausgabe "[1,2][1,3][2,1][2,3][3,1][3,2]"
# Iteriere alle möglichen Zwei-Element-Untermengen (Reihenfolge unwichtig)
a.combination(2) {|x| print x } # Ausgabe "[1, 2][1, 3][2, 3]"
# Liefere das kartesische Produkt der beiden Mengen
a.product(['a','b']) # => [[1,"a"],[1,"b"],[2,"a"],[2,"b"],[3,"a"],[3,"b"]]
[1,2].product([3,4],[5,6]) # => [[1,3,5],[1,3,6],[1,4,5],[1,4,6], usw. ... ]
    9.5.2.8 Methoden für assoziative Arrays
    Die Methoden
assoc
und
rassoc
ermöglichen es Ihnen, ein Array als assoziatives Array oder Hash zu betrachten. Dazu muss das Array ein Array aus Arrays sein, zum Beispiel:
[[key1, value1], [key2, value2], [key3, value3], ...]
    Die Klasse
Hash
definiert Methoden, die einen Hash in ein verschachteltes Array dieser Form umwandeln. Die Methode
assoc
sucht nach einem verschachtelten Array, dessen erstes Element dem angegebenen Argument entspricht. Es liefert das erste passende verschachtelte Array zurück. Die Methode
rassoc
macht dasselbe, liefert aber das erste verschachtelte Array zurück, dessen zweites Element passt:
h = { :a => 1, :b => 2} # Beginne mit einem Hash
a = h.to_a # => [[:b,2], [:a,1]]: assoziatives Array
a.assoc(:a) # => [:a,1]: Subarray für Schlüssel :a
a.assoc(:b).last # => 2: Wert für Schlüssel :b
a.rassoc(1) # => [:a,1]: Subarray für Schlüssel 1
a.rassoc(2).first # => :b: Schlüssel für Wert 2
a.assoc(:c) # => nil
a.transpose # => [[:a, :b], [1, 2]]: vertausche Zeilen und Spalten
    9.5.2.9 Weitere Array-Methoden
    Array
definiert noch ein paar weitere Methoden, die in keine der obigen Kategorien passen:
# Umwandlung in Strings
[1,2,3].join # => "123": Wandelt Elemente in Strings um und fügt sie
     # zusammen
[1,2,3].join(", ") # => "1, 2, 3": optionaler Trenner
[1,2,3].to_s # => "[1, 2, 3]" in Ruby 1.9
[1,2,3].to_s # => "123" in Ruby 1.8
[1,2,3].inspect # => "[1, 2, 3]": besser zu Debuggen in 1.8

# Binärumwandlung mit pack. Siehe auch String.unpack.
[1,2,3,4].pack("CCCC") # => "\001\002\003\004"
[1,2].pack('s2') # => "\001\000\002\000"
[1234].pack("i") # => "\322\004\000\000"

# Andere Methoden
[0,1]*3 # => [0,1,0,1,0,1]: *-Operator wiederholt
[1, [2, [3]]].flatten # => [1,2,3]: rekursives Flachklopfen; auch flatten!
[1, [2, [3]]].flatten(1) # => [1,2,[3]]: Anzahl der Level; Ruby 1.9
[1,2,3].reverse # => [3,2,1]: auch reverse!
a=[1,2,3].zip([:a,:b,:c]) # => [[1,:a],[2,:b],[3,:c]]: Enumerable-Methode
a.transpose # => [[1,2,3],[:a,:b,:c]]: vertausche Zeilen/Spalten
    9.5.3 Hashes
    Hashes wurden in „3.4 Hashes“ vorgestellt, wo Literale für Hashes und die Operatoren
[]
und
[]=
für das Lesen und Speichern von Schlüssel/Wert-Paaren in einem Hash erklärt wurden. Dieser Abschnitt behandelt die
Hash
-API detaillierter. Hashes verwenden dieselben Operatoren mit eckigen Klammern wie Arrays, und Sie werden feststellen, dass viele
Hash
-Methoden den
Array
-Methoden gleichen.
    9.5.3.1 Hashes erzeugen
    Hashes können mit Literalen, der Methode
Hash.new
oder dem