Die Programmiersprache Ruby (German Edition)

der Elemente in einer Collection zurück, die gleich einem angegebenen Wert sind, oder die Anzahl der Elemente, für die ein übergebener Block
true
zurückgibt:
a = [1,1,2,3,5,8]
a.count(1) # => 2: zwei Elemente sind gleich 1
a.count {|x| x % 2 == 1} # => 4: vier Elemente sind ungerade
    Schließlich ist
inject
eine allgemein nutzbare Methode, um eine Collection zu reduzieren. Ruby 1.9 definiert
reduce
als Alias für
inject
. Der einem Aufruf von
inject
zugewiesene Block erwartet zwei Argumente. Das erste ist ein akkumulierter Wert, das zweite ein Element aus der Collection. Der akkumulierte Wert für die erste Iteration ist das an
inject
übergebene Argument. Der Rückgabewert des Blocks einer Iteration wird zum akkumulierten Wert für die nächste Iteration. Der Rückgabewert nach der letzten Iteration wird zum Rückgabewert von
inject
. Hier sehen Sie ein paar Beispiele:
# Wie viele negative Zahlen?
(-2..10).inject(0) {|num, x| x<0 ? num+1 : num } # => 2
# Summe der Wortlängen
%w[pea queue are].inject(0) {|total, word| total + word.length } # => 11
    Wenn
inject
kein Argument übergeben wird, werden dem Block beim ersten Aufruf die ersten beiden Elemente der Collection übergeben. (Und wenn es nur ein Element in der Collection gibt, liefert
inject
einfach dieses Element zurück.) Diese Form von
inject
ist für eine Reihe häufiger genutzer Operationen sehr hilfreich:
sum = (1..5).inject {|total,x| total + x} # => 15
prod = (1..5).inject {|total,x| total * x} # => 120
max = [1,3,2].inject {|m,x| m>x ? m : x} # => 3
[1].inject {|total,x| total + x} # => 1: Block wird nie aufgerufen
    In Ruby 1.9 können Sie an
inject
ein Symbol übergeben, das eine Methode (oder einen Operator) statt eines Blocks benennt. Jedes Element der Collection wird an die angegebene Methode des akkumulierten Werts übergeben, und deren Ergebnis wird zum neuen akkumulierten Wert. Man nutzt im Allgemeinen das Synonym
reduce
, wenn man die Methode mit einem Symbol aufruft:
sum = (1..5).reduce(:+) # => 15
prod = (1..5).reduce(:*) # => 120
letters = ('a'..'e').reduce("-", :concat) # => "-abcde"
    9.5.2 Arrays
    Arrays sind die vermutlich am häufigsten verwendete Datenstruktur in der Ruby-Programmierung. Wir haben Array-Literale und Indexierungsoperatoren in „3.3 Arrays“ behandelt. Dieser Abschnitt baut darauf auf und demonstriert die umfassende API, die durch die Array-Klasse implementiert wird.
    9.5.2.1 Arrays erstellen
    Arrays können durch Array-Literale, über die Klassenmethode
Array.new
oder über den Klassenoperator
Array.[]
erstellt werden. Hier sehen Sie ein paar Beispiele:
[1,2,3] # Einfaches Array-Literal
[] # Ein leeres Array
[] # Arrays lassen sich verändern: dieses Array ist ein anderes
%w[a b c] # => ['a', 'b', 'c']: Array mit Wörtern
Array[1,2,3] # => [1,2,3]: wie ein Array-Literal

# Erstellen eines Array mit der Methode new()
empty = Array.new # []: liefert ein neues, leeres Array
nils = Array.new(3) # [nil, nil, nil]: drei nil-Elemente
copy = Array.new(nils) # Erstelle eine neue Kopie eines bestehenden Array
zeros = Array.new(4, 0) # [0, 0, 0, 0]: vier 0-Elemente
count = Array.new(3){|i| i+1} # [1,2,3]: drei durch den Block erstellte Elemente

# Vorsicht bei wiederholten Objekten
a=Array.new(3,'a') # => ['a','a','a']: drei Referenzen auf denselben String
a[0].upcase! # Erstes Element in Großbuchstaben umwandeln
a # => ['A','A','A']: alle sind derselbe String!
a=Array.new(3){'b'} # => ['b','b','b']: drei verschiedene String-Objekte
a[0].upcase!; # Das erste in Großbuchstaben umwandeln
a # => ['B','b','b']: die anderen sind immer noch klein
    Neben den Fabrikmethoden von
Array
definiert eine Reihe von anderen Klassen eine Methode
to_a
, die ein Array zurückgibt. Insbesondere jedes
Enumerable
-Objekt, wie zum Beispiel
Range
oder
Hash
, kann mit
to_a
in ein Array umgewandelt werden. Auch Array-Operatoren, wie zum Beispiel
+
, und viele Array-Methoden, wie
slice
, erzeugen neue Arrays und geben sie zurück, statt das bestehende Array zu verändern.
    9.5.2.2 Array-Größe und Elemente
    Der folgende Code zeigt, wie man die Größe eines Array bestimmt, und stellt verschiedene Wege vor, Elemente und Subarrays aus einem Array zu extrahieren:
# Array-Größe
[1,2,3].length # => 3
[].size # => 0: Synonym für length
[].empty? # => true
[nil].empty? # => false
[1,2,nil].nitems # => 2: Anzahl an Elementen, die nicht nil sind
[1,2,3].nitems {|x| x>2} # => 1: Anzahl an Elementen, die zum Block passen (Ruby 1.9)

# Indexzugriff auf