Die Programmiersprache Ruby (German Edition)

einzelne Elemente
a = %w[a b c d] # => ['a', 'b', 'c', 'd']
a[0] # => 'a': erstes Element
a[-1] # => 'd': letztes Element
a[a.size-1] # => 'd': letztes Element
a[-a.size-1] # => 'a': erstes Element
a[5] # => nil: nicht vorhanden
a[-5] # => nil: nicht vorhanden
a.at(2) # => 'c': wie [] für einzelnes Integer-Argument
a.fetch(1) # => 'b': auch wie [] und at
a.fetch(-1) # => 'd': arbeitet auch mit negativen Argumenten
a.fetch(5) # => IndexError!: keine ungültigen Indizes erlaubt
a.fetch(-5) # => IndexError!: keine ungültigen Indizes erlaubt
a.fetch(5, 0) # => 0: zweites Argument zurückgeben wenn ungültiger Index
a.fetch(5){|x|x*x} # => 25: berechne Wert wenn ungültiger Index
a.first # => 'a': das erste Element
a.last # => 'd': das letzte Element
a.choice # Ruby 1.9: liefere ein zufälliges Element zurück

# Indexzugriff auf Subarrays
a[0,2] # => ['a','b']: zwei Elemente, beginnend bei 0
a[0..2] # => ['a','b','c']: Elemente mit Index im Range
a[0...2] # => ['a','b']: drei Punkte statt zwei
a[1,1] # => ['b']: einzelnes Element als Array
a[-2,2] # => ['c','d']: letzte zwei Elemente
a[4,2] # => []: leeres Array direkt am Ende
a[5,1] # => nil: nichts darüber hinaus
a.slice(0..1) # => ['a','b']: slice ist Synonym für []
a.first(3) # => ['a','b','c']: erste drei Elemente
a.last(1) # => ['d']: letztes Element als Array

# bestimmte Werte extrahieren
a.values_at(0,2) # => ['a','c']
a.values_at(4, 3, 2, 1) # => [nil, 'd','c','b']
a.values_at(0, 2..3, −1) # => ['a','c','d','d']
a.values_at(0..2,1..3) # => ['a','b','c','b','c','d']
    9.5.2.3 Array-Elemente verändern
    Der folgende Code zeigt, wie man den Wert eines einzelnen Array-Elements ändert, Werte in ein Array einfügt, daraus löscht und Werte durch andere ersetzt:
a = [1,2,3] # Beginne mit diesem Array
# Ändere den Wert von Elementen
a[0] = 0 # Ändere ein bestehendes Element: a ist [0,2,3]
a[-1] = 4 # Ändere das letzte Element: a ist [0,2,4]
a[1] = nil # Setze das zweite Element auf nil: a ist [0,nil,4]

# An ein Array anhängen
a = [1,2,3] # Beginne mit diesem Array
a[3] = 4 # Füge ein viertes Element hinzu: a ist [1,2,3,4]
a[5] = 6 # Wir können Elemente überspringen: a ist [1,2,3,4,nil,6]
a << 7 # => [1,2,3,4,nil,6,7]
a << 8 << 9 # => [1,2,3,4,nil,6,7,8,9] Operator verkettbar
a = [1,2,3] # Beginne neu mit einem kurzen Array
a + a # => [1,2,3,1,2,3]: + verkettet in ein neues Aray
a.concat([4,5]) # => [1,2,3,4,5]: verändere a direkt: kein !

# Elemente mit insert einfügen
a = ['a', 'b', 'c']
a.insert(1, 1, 2) # a ist jetzt ['a',1,2,'b','c']. Wie a[1,0] = [1,2]

# Entfernen (und Zurückgeben) einzelner Elemente per Index
a = [1,2,3,4,5,6]
a.delete_at(4) # => 5: a ist jetzt [1,2,3,4,6]
a.delete_at(-1) # => 6: a ist jetzt [1,2,3,4]
a.delete_at(4) # => nil: a ist unverändert

# Elemente aufgrund des Werts entfernen
a.delete(4) # => 4: a ist [1,2,3]
a[1] = 1 # a ist jetzt [1,1,3]
a.delete(1) # => 1: a ist jetzt [3]:beide 1er entfernt
a = [1,2,3]
a.delete_if {|x| x%2==1} # Ungerade Werte entfernen: a ist jetzt [2]
a.reject! {|x| x%2==0} # Wie delete_if: a ist jetzt []

# Elemente und Subarray durch slice! entfernen
a = [1,2,3,4,5,6,7,8]
a.slice!(0) # => 1: Element 0 entfernen: a ist [2,3,4,5,6,7,8]
a.slice!(-1,1) # => [8]: Subarray am Ende entfernen: a ist [2,3,4,5,6,7]
a.slice!(2..3) # => [4,5]: geht auch mit Bereichen: a ist [2,3,6,7]
a.slice!(4,2) # => []: leeres Array direkt am Ende: a ist unverändert
a.slice!(5,2) # => nil: a ist jetzt [2,3,6,7,nil]!

# Ersetze Subarrays mit []=
# Zum Löschen ein leeres Array zuweisen
# Zum Einfügen einen Slice mit Breite 0 zuweisen
a = ('a'..'e').to_a # => ['a','b','c','d','e']
a[0,2] = ['A','B'] # a ist jetzt ['A', 'B', 'c', 'd', 'e']
a[2...5]=['C','D','E'] # a ist jetzt ['A', 'B', 'C', 'D', 'E']
a[0,0] = [1,2,3] # Elemente am Anfang von a einfügen
a[0..2] = [] # Diese Elemente löschen
a[-1,1] = ['Z'] # Das letzte Element durch ein anderes ersetzen
a[-1,1] = 'Z' # Bei einzelnen Elementen ist das Array optional
a[1,4] = nil # Ruby 1.9: a ist jetzt ['A',nil]
     # Ruby 1.8: a ist jetzt ['A']: nil ist wie []

# Andere Methoden
a = [4,5]
a.replace([1,2,3]) # a ist jetzt [1,2,3]: eine Kopie des Arguments
a.fill(0) # a ist jetzt [0,0,0]
a.fill(nil,1,3) # a ist jetzt [0,nil,nil,nil]
a.fill('a',2..4) # a ist jetzt [0,nil,'a','a','a']
a[3].upcase! # a ist jetzt [0,nil,'A','A','A']
a.fill(2..4) { 'b' } # a ist jetzt [0,nil,'b','b','b']
a[3].upcase! # a ist jetzt [0,nil,'b','B','b']
a.compact # => [0,'b','B','b']: Kopie mit