Die Programmiersprache Ruby (German Edition)

@x,@y = x,y; end # Instanzvariablen definieren
@@classvar = 1 # Eine Klassenvariable definieren
ORIGIN = Point.new(0,0) # Eine Konstante definieren
end
Point::ORIGIN.instance_variables # => ["@y", "@x"]
Point.class_variables # => ["@@classvar"]
Point.constants # => ["ORIGIN"]
    Die Methoden
global_variables
,
instance_variables
,
class_variables
und
constants
geben in Ruby 1.8 Arrays mit Strings und in Ruby 1.9 Arrays mit Symbolen zurück. Die Methode
local_variables
gibt in beiden Versionen der Sprache ein Array mit Strings zurück.
    8.3.1 Variablen lesen, setzen und überprüfen
    Neben den Methoden zum Auflisten der definierten Variablen und Konstanten definieren die Ruby-Klassen
Object
und
Module
auch reflektive Methoden zum Lesen, Setzen und Entfernen von Instanzvariablen, Klassenvariablen und Konstanten. Es gibt keine spezifischen Methoden zum Lesen oder Setzen von lokalen oder globalen Variablen, aber Sie können die Methode
eval
zu diesem Zweck nutzen:
x = 1
varname = "x"
eval(varname) # => 1
eval("varname = '$g'") # varname auf "$g" setzen
eval("#{varname} = x") # $g auf 1 setzen
eval(varname) # => 1
    Beachten Sie, dass
eval
seinen Code in einem temporären Gültigkeitsbereich auswertet.
eval
kann den Wert von Instanzvariablen ändern, die bereits existieren. Aber jegliche neuen Instanzvariablen, die es definiert, sind lokal für den Aufruf von
eval
und hören auf zu existieren, wenn es zurückkehrt. (Es ist, als würde der ausgewertete Code im Rumpf eines Blocks ausgeführt — lokale Variablen eines Blocks existieren außerhalb des Blocks nicht.)
    Sie können die Instanzvariablen jedes Objekts lesen, setzen und ihre Existenz überprüfen; dasselbe gilt für die Klassenvariablen und Konstanten jeder Klasse und jedes Moduls:
o = Object.new
o.instance_variable_set(:@x, 0) # Pflicht-Präfix @ beachten
o.instance_variable_get(:@x) # => 0
o.instance_variable_defined?(:@x) # => true
Object.class_variable_set(:@@x, 1) # Privat in Ruby 1.8
Object.class_variable_get(:@@x) # Privat in Ruby 1.8
Object.class_variable_defined?(:@@x) # => true; Ruby 1.9 und neuer
Math.const_set(:EPI, Math::E*Math::PI)
Math.const_get(:EPI) # => 8.53973422267357
Math.const_defined? :EPI # => true
    In Ruby 1.9 können Sie als zweites Argument von
const_get
and
const_defined?
den Wert
false
übergeben, um anzugeben, dass diese Methoden nur die aktuelle Klasse oder das aktuelle Modul, aber keine geerbten Konstanten betrachten sollen.
    Die Methoden zum Lesen und Setzen von Klassenvariablen sind in Ruby 1.8 privat. In dieser Version können Sie sie mit
class_eval
aufrufen:
String.class_eval { class_variable_set(:@@x, 1) } # 8x in String setzen
String.class_eval { class_variable_get(:@@x) } # => 1
    Object
und
Module
definieren private Methoden, um die Definition von Instanzvariablen, Klassenvariablen und Konstanten aufzuheben. Sie alle geben den Wert der entfernten Variablen beziehungsweise Konstanten zurück. Da diese Methoden privat sind, können Sie sie nicht direkt für ein Objekt, eine Klasse oder ein Modul aufrufen, sondern müssen eine
eval
-Methode oder die (weiter unten in diesem Kapitel beschriebene) Methode
send
verwenden:
o.instance_eval { remove_instance_variable :@x }
String.class_eval { remove_class_variable(:8x) }
Math.send :remove_const, :EPI # send für Aufruf privater Methode verwenden
    Die Methode
const_missing
eines Moduls wird – falls vorhanden – aufgerufen, wenn eine undefinierte Konstante referenziert wird. Sie können diese Methode definieren, um den Namen der genannten Konstante zurückzugeben. (Dieses Feature kann zum Beispiel genutzt werden, um eine Autoload-Funktionalität in Klassen oder Module, die auf Wunsch geladen werden, zu implementieren.)
def Symbol.const_missing(name)
name # Den Namen der Konstante als Symbol zurückgeben
end
Symbol::Test # => :Test: Undefinierte Konstante ergibt ein Symbol.

8.4 Methoden
    Die Klassen
Object
und
Module
definieren eine Reihe von Methoden zum Auflisten, Ermitteln, Aufrufen und Definieren von Methoden. Wir betrachten diese Kategorien der Reihe nach.
    8.4.1 Methoden auflisten und prüfen
    Object
definiert Methoden, die die Namen der von dem Objekt definierten Methoden auflisten. Diese Methoden geben Arrays von Methodennamen zurück. Diese Namen sind in Ruby 1.8 Strings und in Ruby 1.9 Symbole:
o = "ein String"
o.methods # => [ Namen aller Public-Methoden ]
o.public_methods # => dasselbe
o.public_methods(false) # Geerbte Methoden ausschließen
o.protected_methods # => []: Es