Am Anfang war das Wort.
So wohl auch in der Programmierung. Wenn wir keine Variablen hätten, denen wir Objekte zuweisen könnten, hätten wir Programmierer vermutlich ein Problem. Zum Glück ist Ruby so zuvorkommend und gibt uns diese Möglichkeit.
Zuweisung und Entfernen
Eine Variable ist eine Referenz auf ein Objekt. Das Zuweisen eines solchen ist ein Kinderspiel, einfach das Gleichheitszeichen = verwenden, eine Deklaration ist unnötig:
|
meine_variable = "Mein Wert" |
Fertig. Die per Konvention klein geschriebene Variable meine_variable enthält jetzt den String "Mein Wert". Anhand dieses Namens kann der String nun beliebig abgerufen, verändert oder auch entfernt werden.
1
2
3
|
meine_variable = "Mein Wert"
meine_variable.sub!("M", "K")
puts meine_variable #=> Kein Wert |
Um das Objekt, auf das die Variable verweist, zu entfernen, kann man die Variable einfach auf nil setzen. nil steht für nichts, aber auch gar nichts. Wenn ein Objekt nicht existiert, ist es nil. Es gilt in einer Bedingungsabfrage dementsprechend als false.
1
2
3
4
5
6
7
8
|
meine_variable = nil
if meine_variable
#Alles außer nil und false ist true
puts "true"
else
puts "nil oder false"
end
#=> nil oder false |
Nachdem eine Variable auf nil gesetzt wurde, verfällt die Gültigkeit des gehaltenen Objektes. Um die Entsorgung dieses Objektes muss man sich nicht kümmern, Ruby besitzt einen sehr leistungsfähigen Garbage Collector.
Variablenarten
Verfällt der Gültigkeitsbereich einer Variablen, »reißen« die Seile, über welche die Objekte assoziiert sind. Die Objekte fallen daraufhin durch den Object-Space und danach in den Garbage Collector, der sie endgültig vernichtet[1]. Danach ist ein Objekt nicht mehr abrufbar (logisch, oder?).
Lokale Variable
Die normale Lokale Variable ist die wohl am häufigsten verwendete. Ihr Gültigkeitsbereich verfällt, wenn der Block, in dem sie definiert wurde, durchgelaufen ist. Dieser Block kann eine Klasse oder eine Methode sein, eine Closure oder ein begin/rescue-Block, um nur einige Beispiele zu nennen. Vorsicht geboten ist bei Iteratoren:
1
2
3
4
5
6
7
8
9
|
#Wenn bereits eine Variable ausserhalb des Gültigkeitsbereichs eines Iterators definiert ist,
#wird diese einfach vom Iterator überschrieben.
variable = 100
3.times{|variable| puts "Schleife"}
puts variable
#=>Schleife
#=>Schleife
#=>Schleife
#=>2 |
Blockvariable
Im Prinzip ist die Blockvariable nur ein Sonderfall der Lokalen Variable, sie ist eben lokal für ihren Iteratorblock.
1
2
3
4
5
6
|
3.times{|i| puts i}
puts i
#=>0
#=>1
#=>2
#=>NameError |
Instanzvariable
Diese Variablen beschränken ihren Gültigkeitsbereich auf eine Instanz. Erzeugt man ein Objekt einer Klasse, so instanziiert man - und Instanzvariablen gelten nur für diese eine Instanz, sonst für nichts. Sie werden von einem At-Zeichen @ angeführt.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
class A
def initialize(wert)
@instanzvariable = wert
end
def zeigen
puts @instanzvariable
end
end
instanz = A.new(100)
puts @instanzvariable #=> nil #Eine Besonderheit: Nicht definierte Instanzvariablen haben automatisch den "Wert" nil.
puts instanz.zeigen #=> 100
instanz2 = A.new("XY")
instanz2.zeigen #=> XY
instanz.zeigen #=> 100 |
Globale Variable
»Oh Schmerz, oh Pein«, werden wohl die meisten Rubyprogrammierer stöhnen, wenn völlig ohne Grund globale Variablen benutzt werden. Sie werden durch ein Dollarzeichen $ vor dem Namen definiert, sind uninitialisiert nil, überall verfügbar und bei der Community ausgesprochen unbeliebt. Variablen, die nie verfallen, können schnell den Speicher vollmachen, also aufpassen!
1
2
3
4
5
6
|
puts $global #=> nil
def meine_methode
$global = "nicht benutzen!"
end
meine_methode
puts $global #=> nicht benutzen! |
Klassenvariable
Diese Variablen sind ganz besondere Biester. Eigentlich ist der Begriff »Klasse« hier falsch angesetzt, diese Variablen sollten als »semi-global« bezeichnet werden. Grund: Klassenvariablen werden in der Klassenhierarchie nach oben »vererbt«. Im Gegensatz zu globalen und Instanzvariablen müssen Klassenvariablen einen Wert zugewiesen bekommen, bevor sie abrufbar sind. Klassenvariablen werden mit einem doppelten At-Zeichen @@ begonnen.
1
2
3
4
5
6
7
8
9
10
11
12
|
class A
@@klassenvariable = "ABCDEF"
end
class B < A
@@klassenvariable = "Ein Wert"
end
class A
puts @@klassenvariable
end
#=> Ein Wert |
Wo immer möglich, sollte man Instanzvariablen auf dem Objekt der Klasse verwenden:
1
2
3
|
class A
@richtige_klassen_instanz_variable = "Ein Wert"
end |
Fußnoten
- Einzige Ausnahme bilden die Immediate Values, damit sichergestellt werden kann, dass sie wirklich einzigartig im Programm sind.
Siehe auch
