Die Programmiersprache Ruby (German Edition)

zu bind
alias [] bind
end
    Nach der Definition dieses Alias, zusammen mit dem bestehenden Alias
[]
für den Aufruf einer Methode, wird dieser Code zu:
String[:reverse]["Hallo"][] # => "ollaH"
    Das erste Klammernpaar indexiert die Methode, das zweite Paar bindet sie und das dritte Paar ruft sie auf.
    Da wir den Operator
[]
zum Nachschlagen der Instanzmethoden einer Klasse verwenden, können wir als Nächstes
[]=
zum Definieren von Instanzmethoden verwenden:
class Module
# Eine Instanzmethode mit dem Namen sym und dem Rumpf f erzeugen
# Beispiel: String[:backwards] = lambda { reverse }
def []=(sym, f)
    self.instance_eval { define_method(sym, f) }
end
end
    Die Definition dieses
[]=
-Operators könnte verwirrend erscheinen – das ist fortgeschrittenes Ruby.
define_method
ist eine private Methode von
Module
. Wir verwenden
instance_eval
(eine öffentliche Methode von
Object
), um einen Block (einschließlich des Aufrufs einer privaten Methode) auszuführen, als befände er sich innerhalb des Moduls, für das die Methode definiert wird. Wir werden
instance_eval
und
define_method
in Kapitel 8 wiedersehen.
    Lassen Sie uns diesen neuen
[]=
-Operator verwenden, um eine
Enumerable.average
-Methode zu definieren:
Enumerable[:average] = lambda do
sum, n = 0.0, 0
self.each {|x| sum += x; n += 1 }
if n == 0
    nil
else
    sum/n
end
end
    Hier haben wir die Operatoren
[]
und
[]=
verwendet, um Instanzmethoden einer Klasse oder eines Moduls zu lesen beziehungsweise zu setzen. Etwas Ähnliches können wir mit den Singleton-Methoden eines Objekts tun (zu denen die Klassenmethoden einer Klasse oder eines Moduls gehören). Jedes Objekt kann eine Singleton-Methode haben, aber es ist sinnlos, einen
[]
-Operator für die Klasse
Object
zu definieren, da so viele Unterklassen diesen Operator definieren. Für Singleton-Methoden könnten wir deshalb den umgekehrten Ansatz wählen und Operatoren für die Klasse
Symbol
definieren:
#
# Operatoren [] und []= zur Klasse Symbol hinzufügen, um Singleton-Methoden
# von Objekten zu lesen und zu setzen. Lies : als "Methode" und [] als "von".
# Also bedeutet :m[o] "Methode m von o".
#
class Symbol
# Die durch dieses Symbol benannte Methode von obj zurückgeben. Dies kann
# eine Singleton-Methode von obj (etwa eine Klassenmethode) oder eine Instanz-
# methode sein, die in obj.class definiert oder von einer Oberklasse übernommen
# wurde.
# Beispiele:
# creator = :new[Object] # Klassenmethode Object.new
# doubler = :*[2] # *-Methode der Fixnum 2
#
def [](obj)
    obj.method(self)
end
# Eine Singleton-Methode für Objekt o definieren und Proc oder Method f
# als Rumpf verwenden. Dieses Symbol dient als Name der Methode.
# Beispiele:
#
# :singleton[o] = lambda { puts "Dies ist eine Singleton-Methode von o" }
# :class_method[String] = lambda { puts "Dies ist eine Klassenmethode" }
#
# Beachten: Sie können so keine Instanzmethoden erzeugen. Siehe Module.[]=
#
def []=(o,f)
    # Wir können im Block unten nicht self verwenden, da er im Kontext
    # eines anderen Objekts ausgewertet wird. Deshalb müssen wir self
    # einer Variablen zuweisen.
    sym = self
    # Dies ist das Objekt, für das wir Singleton-Methoden definieren.
    eigenclass = (class << o; self end)
    # define_method ist privat, so dass wir instance_eval zur Ausführung
    # verwenden müssen.
    eigenclass.instance_eval { define_method(sym, f) }
end
end
    Nach der Definition der Methode
Symbol.[]
können Sie zusammen mit dem weiter oben beschriebenen Modul
Functional
cleveren (und unleserlichen) Code wie diesen schreiben:
dashes = :*['-'] # Methode * von '-'
puts dashes[10] # Gibt "----------" aus
y = (:+[1]*:*[2])[x] # Eine andere Schreibweise für y = 2*x + 1
    Die Definition von
[]=
für
Symbol
entspricht insofern derjenigen von
[]=
für
Module
, als sie
instance_eval
verwendet, um die Methode
define_method
aufzurufen. Der Unterschied besteht darin, dass Singleton-Methoden nicht wie Instanzen innerhalb einer Klasse definiert werden, sondern in der Eigenclass des Objekts. Der Eigenclass werden wir in Kapitel 7 wieder begegnen.
    ----
    [ 26 ] Wir verwenden für Methodenparameter mit dem Präfix
&
den Begriff »Blockargument« statt »Blockparameter«. Das liegt daran, dass der Begriff »Blockparameter« sich auf die Parameterliste des Blocks selbst (etwa
|x|
) bezieht.

Kapitel 7. Klassen und Module
    Ruby ist eine objektorientierte Sprache im eigentlichen Sinn: Jeder Wert ist in Ruby ein Objekt (oder er verhält sich zumindest so). Jedes