Neu: Das englische Ruby on Rails 4.0 Buch.

2.6. Variablen

Sie wissen bereits, dass in Ruby alles ein Objekt ist. Also muss auch eine Variable ein Objekt sein.

Namenskonventionen

Normale Variablen werden kleingeschrieben. Konstanten fangen mit einem Großbuchstaben an.

Wichtig

Eine Konstante kann in Ruby auch mit einem neuen Wert überschrieben werden (allerdings wird dabei eine Warnung ausgegeben). Man sollte sich also nicht auf Unveränderlichkeit einer Konstanten verlassen.
Auf der sicheren Seite ist man, wenn man nur ASCII-Zeichen verwendet. Allerdings könnten Sie mit Ruby 1.9 und der richtigen Kodierung auch mehr oder weniger problemlos Sonderzeichen und Umlaute in einem Variablennamen verwenden. Die Höflichkeit gegenüber anderen (evtl. ausländischen) Programmierern, die diese Zeichen vielleicht nicht fix und fertig auf der Tastatur haben, ist aber Grund genug, nur reines ASCII zu benutzen.

Strings

Probieren wir mal ein wenig im irb aus. Die Methode .class gibt uns dabei an, um welche Klasse es sich handelt.
sw@debian:~/sandbox$ irb
1.9.3p194 :001:0> a = 'Ein Test.'
=> "Ein Test."
1.9.3p194 :002:0> a.class
=> String
Das war einfach. Ruby erschafft also automagisch ein Objekt der Klasse String. Das ginge auch mit einem expliziten Aufruf der Methode new:
1.9.3p194 :003:0> b = String.new('Noch ein Test.')
=> "Noch ein Test."
1.9.3p194 :004:0> b.class
=> String
Wenn wir String.new ohne einen Parameter aufrufen, dann wird ebenfalls ein Objekt der Klasse String erstellt. Nur ist das dann ein leerer String:
1.9.3p194 :005:0> c = String.new
=> ""
1.9.3p194 :006:0> c.class
=> String
1.9.3p194 :007:0> exit

Einfache und doppelte Anführungszeichen

Anmerkung

Ein Hinweis vorweg: Wenn hier im Zusammenhang mit Strings von einfachen oder doppelten Anführungszeichen die Rede ist, dann sind damit keine Anführungszeichen im typografisch korrekten Sinn gemeint (siehe http://de.wikipedia.org/wiki/Anführungszeichen), sondern die als Apostrophe (') bzw. Quotation Mark (") bekannten ASCII-Zeichen.
Strings können nicht nur in einfachen Anführungszeichen (single quotes), sondern auch in doppelten Anführungszeichen (double quotes) definiert werden. Bei den doppelten Anführungszeichen gibt es allerdings eine Besonderheit: Man kann Ausdrücke (Expressions) mit dem Konstrukt #{} einbinden. Das Ergebnis wird dann automatisch an die entsprechende Stelle im String eingesetzt.
Beispiel:
sw@debian:~/sandbox$ irb
1.9.3p194 :001:0> a = 'blau'
=> blau
1.9.3p194 :002:0> b = "Farbe: #{a}"
=> "Farbe: blau"
1.9.3p194 :003:0> b.class
=> String
1.9.3p194 :004:0> exit
Ist das Ergebnis des Ausdrucks kein String, versucht Ruby die Methode to_s anzuwenden, um den Wert des Objektes in einen String umzuwandeln.

Ganzzahlen (Integer)

Fixnum und Bignum

Fixnum und Bignum sind Integer-Klassen (sprich Ganzzahlen). Ein Fixnum ist ein Integer, der in einem Word gespeichert werden kann. [15] Wird ein Fixnum größer, wandelt es sich automatisch in ein Bignum um.
sw@debian:~/sandbox$ irb
1.9.3p194 :001:0> 20.class
=> Fixnum
1.9.3p194 :002:0> a = 20
=> 20
1.9.3p194 :003:0> a.class
=> Fixnum
1.9.3p194 :004:0> a = a * 555555555  # Ergebnis wird automatisch ein Bignum.
=> 11111111100
1.9.3p194 :005:0> a.class
=> Bignum
1.9.3p194 :006:0> exit

Fließkommazahlen (Float)

Float ist eine Klasse für reelle Zahlen (Fließkomma-Zahlen). Dabei wird die englische Schreibweise für das Komma (also ein Punkt) benutzt.
sw@debian:~/sandbox$ irb
1.9.3p194 :001:0> a = 20.424
=> 20.424
1.9.3p194 :002:0> a.class
=> Float
1.9.3p194 :003:0> 42.2.class
=> Float
1.9.3p194 :004:0> exit

Einfache Berechnungen

Rechnen mit Integers und Floats ist so einfach, dass man alles anhand von ein paar Zeilen Code im irb beschreiben kann:
sw@debian:~/sandbox$ irb
1.9.3p194 :001:0> a = 10
=> 10
1.9.3p194 :002:0> b = 23
=> 23
1.9.3p194 :003:0> a + b          # Addition von zwei Fixnums
=> 33
1.9.3p194 :004:0> (a + b).class  # Das Ergebnis ist ein Fixnum.
=> Fixnum
1.9.3p194 :005:0> c = a + b
=> 33
1.9.3p194 :006:0> c.class
=> Fixnum
1.9.3p194 :007:0> d = 3.14
=> 3.14
1.9.3p194 :008:0> e = a + d      # Addition Fixnum und Float
=> 13.14
1.9.3p194 :009:0> e.class        # Das Ergebnis ist ein Float.
=> Float
1.9.3p194 :010:0> a * b
=> 230
1.9.3p194 :011:0> (a * b).class
=> Fixnum
1.9.3p194 :012:0> (a * b * d).class
=> Float
1.9.3p194 :013:0> b - a
=> 13
1.9.3p194 :014:0> a += 1         # a = a + 1
=> 11
1.9.3p194 :015:0> exit

Bool'sche Werte (Booleans) und nil

Für bool'sche Werte (true und false) und für nil (kein Wert) gibt es jeweils eigene Klassen:
sw@debian:~/sandbox$ irb
1.9.3p194 :001:0> true.class
=> TrueClass
1.9.3p194 :002:0> false.class
=> FalseClass
1.9.3p194 :003:0> nil.class
=> NilClass
1.9.3p194 :004:0> exit
nil (kein Wert [16]) stammt übrigens als Kurzform vom lateinischen Wort nihil (nichts [17]) oder Programmiersprachen-historisch gesehen von not in list (nicht in der Liste) aus dem Erbe der Programmiersprache Lisp (deren Name ein Akronym für List Processing ist).

Gültigkeitsbereich (Scope) von Variablen

Variablen haben je nach Art einen unterschiedlichen Geltungsbereich (oder eine unterschiedliche Reichweite) innerhalb der Ruby- und damit auch innerhalb einer Ruby-on-Rails-Applikation. Man muss bei der Programmierung diese Reichweite immer im Hinterkopf behalten, weil sonst merkwürdige Effekte auftreten.

Lokale Variablen (aaa oder _aaa)

Lokale Variablen fangen entweder mit einem kleinen Buchstaben oder mit einem Unterstrich (_) an. Ihr Gültigkeitsbereich beschränkt sich auf die aktuelle Umgebung (z. B. auf die aktuelle Methode). Beispiel:
sw@debian:~/sandbox$ irb
1.9.3p194 :001:0> aaa = 10    # Lokale Variable aaa
=> 10
1.9.3p194 :002:0> _bbb = 20   # Lokale Variable _bbb
=> 20
1.9.3p194 :003:0> puts aaa
10
=> nil
1.9.3p194 :004:0> puts _bbb
20
=> nil
1.9.3p194 :005:0> def test       # Definition der Methode test
1.9.3p194 :006:1>   aaa = 1000   # Lokale Variable aaa
1.9.3p194 :007:1>   _bbb = 2000  # Lokale Variable _bbb
1.9.3p194 :008:1>   puts aaa     # Ausgabe von aaa
1.9.3p194 :009:1>   puts _bbb    # Ausgabe von _bbb
1.9.3p194 :010:1> end            # Ende der Methode test
=> nil
1.9.3p194 :011:0> puts aaa
10
=> nil
1.9.3p194 :012:0> puts _bbb
20
=> nil
1.9.3p194 :013:0> test        # Aufruf der Methode test
1000                         # siehe irb-Zeile 8
2000                         # siehe irb-Ziele 9
=> nil
1.9.3p194 :014:0> puts aaa
10
=> nil
1.9.3p194 :015:0> puts _bbb
20
=> nil
1.9.3p194 :016:0> exit

Globale Variablen ($aaa)

Eine globale Variable fängt mit einem $-Zeichen an und ist im gesamten Programm erreichbar. Beispiel:
sw@debian:~/sandbox$ irb
1.9.3p194 :001:0> $aaa = 10
=> 10
1.9.3p194 :002:0> puts $aaa
10
=> nil
1.9.3p194 :003:0> def test    # Definition der Methode test
1.9.3p194 :004:1>   $aaa = 20
1.9.3p194 :005:1> end
=> nil
1.9.3p194 :006:0> puts $aaa   # Ausgabe von $aaa
10
=> nil
1.9.3p194 :007:0> test        # Aufruf der Methode test
=> 20
1.9.3p194 :008:0> puts $aaa   # Ausgabe von $aaa
20
=> nil
1.9.3p194 :009:0> $aaa.class
=> Fixnum
1.9.3p194 :010:0> exit
Globale Variablen werden recht selten benutzt.

Instanz-Variablen (@aaa)

Instanz-Variablen (Attribute, daher das @) gelten nur innerhalb einer Klasse, dort aber überall – sozusagen eine Mini-Version von globalen Variablen. Im Gegensatz zu globalen Variablen findet man Instanz-Variablen in einer Rails-Applikation an jeder Ecke. Wir gehen die Sache über ein Beispielprogramm namens farbe.rb an:
class Wand
  
  def initialize
    @farbe = 'weiß'
  end
  
  def farbe
    @farbe
  end
  
  def streich_alles_rot
    @farbe = 'rot'
  end
  
  def streich_alles_gelb
    @farbe = 'gelb'
  end
  
  def streich_alles_rosa
    farbe = 'rosa'         # Achtung: Dies ist eine lokale Variable.
  end
  
end

meine_wand = Wand.new
puts meine_wand.farbe

meine_wand.streich_alles_rot
puts meine_wand.farbe

meine_wand.streich_alles_rosa
puts meine_wand.farbe
Wenn Sie dieses Programm starten, erscheint folgende Ausgabe:
sw@debian:~/sandbox$ ruby farbe.rb
weiß
rot
rot
sw@debian:~/sandbox$ 
In der Methode initialize setzen wir die Instanz-Variable @farbe auf den Wert weiß. Die Methoden streich_alles_rot und streich_alles_gelb verändern diese Instanz-Variable. Die Methode streich_alles_rosa hingegen setzt nur eine lokale Variable mit dem Namen farbe (es fehlt das @-Zeichen).
Mit der Methode farbe können wir uns außerhalb der Instanz den Wert von @farbe ausgeben lassen.


[15] Falls Sie nicht wissen, was ein Word ist: egal.