Die Programmiersprache Ruby (German Edition)

Sequenz zurückzuliefern
def length
    return 0 if @from > @to # Beachten: if als Anweisungs-Modifier
    Integer((@to-@from)/@by) + 1 # Sequenzlänge berechnen und zurückgeben
end
# Einen weiteren Namen für dieselbe Methode definieren
# Es kommt oft vor, dass Methoden in Ruby mehrere Namen haben.
alias size length # size ist nun ein Synonym für length
# Array-Zugriffsoperator für freien Zugriff auf die Sequenz überschreiben
def[](index)
    return nil if index < 0 # nil für negative Indizes zurückgeben
    v = @from + index*@by # Den Wert berechnen
    if v <= @to # Wenn er Teil der Sequenz ist,
     v # zurückgeben
    else # Andernfalls ...
     nil # nil zurückgeben
    end
end
# Arithmetische Operatoren überschreiben, um neue Sequence-
# Objekte zurückzugeben
def *(factor)
    Sequence.new(@from*factor, @to*factor, @by*factor)
end
def +(offset)
    Sequence.new(@from+offset, @to+offset, @by)
end
end
    Hier ein wenig Code, der diese
Sequence
-Klasse verwendet:
s = Sequence.new(1, 10, 2) # Von 1 bis 10 in 2er-Schritten
s.each {|x| print x } # Gibt "13579" aus
print s[s.size-1] # Gibt 9 aus
t = (s+1)*2 # Von 4 bis 22 in 4er-Schritten
    Das wichtigste Feature unserer
Sequence
-Klasse ist ihr
each
-Iterator. Wenn wir nur an der Iteratormethode interessiert sind, besteht kein Bedarf, die ganze Klasse zu definieren. Stattdessen können wir einfach eine Iteratormethode schreiben, die die Parameter
from
,
to
und
by
akzeptiert. Anstatt eine globale Funktion daraus zu machen, wollen wir sie in einem eigenen Modul definieren:
module Sequences # Ein neues Modul beginnen
def self.fromtoby(from, to, by) # Eine Singleton-Methode des Moduls
    x = from
    while x <= to
     yield x
     x += by
    end
end
end
    Mit einer auf diese Weise definierten Iteratormethode können wir Code wie diesen schreiben:
Sequences.fromtoby(1, 10, 2) {|x| print x } # Gibt "13579" aus
    Ein Iterator wie dieser macht die Erstellung eines
Sequence
-Objekts zur Iteration über eine Zahlensequenz unnötig. Aber der Name der Methode ist recht lang, und ihre Aufrufsyntax ist unbefriedigend. Was wir wirklich wollen, ist eine Möglichkeit, mit anderen Schritten als 1 über numerische
Range
-Objekte zu iterieren. Eines der erstaunlichsten Features der Sprache Ruby ist, dass ihre Klassen – selbst die eingebauten Kernklassen – offen sind: Jedes Programm kann Methoden zu ihnen hinzufügen. Deshalb können wir wirklich eine neue Iteratormethode für Bereiche definieren:
class Range # Eine bestehende Klasse zum Erweitern öffnen
def by(step) # Einen Iterator namens by definieren
    x = self.begin # Bei einem Endpunkt des Bereichs beginnen
    if exclude_end? # ...-Bereiche, die das Ende ausschließen,
     while x < self.end # mit dem Operator < testen
     yield x
     x += step
     end
    else # Andernfalls ..-Bereiche, die das Ende einschließen,
     while x <= self.end # mit dem Operator <= testen
     yield x
     x += step
     end
    end
end # Ende der Methodendefinition
end # Ende der Klassenänderung
# Examples
(0..10).by(2) {|x| print x} # Gibt "0246810" aus
(0...10).by(2) {|x| print x} # Gibt "02468" aus
    Diese Methode ist bequem, aber unnötig; die Klasse
Range
definiert bereits einen Iterator namens
step
, der denselben Zweck erfüllt. Die Ruby-Kern-API ist reichhaltig, und es lohnt sich, sich Zeit zu nehmen, um die Plattform zu studieren (siehe Kapitel 9 ), damit Sie keine Zeit damit verschwenden, Methoden zu schreiben, die bereits für Sie implementiert wurden!
    1.1.9 Ruby-Überraschungen
    In jeder Sprache können bestimmte Features Programmierern, die neu damit anfangen, ein Bein stellen. Hier beschreiben wir zwei überraschende Features von Ruby.
    Ruby-Strings sind veränderbar, was besonders für Java-Programmierer überraschend sein könnte. Der Operator
[]=
ermöglicht Ihnen, die Zeichen eines Strings zu ändern oder Teilstrings einzufügen, zu löschen und zu ersetzen. Der Operator
<<
ermöglicht Ihnen, etwas an einen String anzufügen, und die Klasse
String
definiert diverse weitere Methoden, die bestehende Strings ändern. Da Strings veränderbar sind, sind Stringliterale in einem Programm keine eindeutigen Objekte. Wenn Sie ein Stringliteral in eine Schleife einfügen, wird es in jedem Schleifendurchlauf als neues Objekt ausgewertet. Rufen Sie die Methode
freeze
für einen String (oder irgendein anderes Objekt) auf, um alle weiteren Änderungen dieses Objekts zu verhindern.
    Rubys Fallentscheidungen und Schleifen (wie
if
und
while
) werten Bedingungsausdrücke aus, um zu entscheiden,