Die Programmiersprache Ruby

Blog| Forum| Wiki  

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.

Inhaltsverzeichnis

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

  1. Einzige Ausnahme bilden die Immediate Values, damit sichergestellt werden kann, dass sie wirklich einzigartig im Programm sind.

Siehe auch