Quelltext der Seite Ruby/Variable

==Variablen==
Variablen werden häufig mit Objekten verwechselt. 15, 12.3, "Hallo", [1, 17, 9], :lol und andere sind Objekte.
Variablen sind sozusagen die Brücke zwischen Programmierer und Objekten.
In Ruby zeigt jede Variable auf ein Objekt und rufen für uns (die Programmierer) die Methoden dieses Objektes auf.

===Lokale Variablen===
Lokale Variablen sind die am einfachsten Nutzbaren. Sie gelten nur in dem Scope, in dem sie [[Deklaration|deklariert]] wurden. Ist dies nicht der Fall und man will auf sie zugreifen, gibt es einen Fehler.
<source lang="ruby">def foo
 n = 12
end

def bar
 foo
 p n
 # n wird versucht auszugeben, liegt aber nur im Scope in foo -> Fehler
end</source>
<source lang="ruby">3.times do
 n = rand(20)
end
p n
# n liegt nur im Scope der Schleife, daher wieder ein Fehler

# so würde es funktionieren:
n = 0
3.times do
 n = rand(20)
end
p n</source>

Lokale Variablen werden normalerweise mit einem kleinen Buchstaben begonnen. Es gibt aber auch die Möglichkeit _ vorne anzusetzen (_Variable oder _variable).
Dies wird aber eher selten getan. Außerdem werden Variablen mit einem _ zu Beginn häufig als "für das System/Elternklasse wichtig" angesehen und sollten nicht einfach so geändert werden.

===Instanzvariablen===
Instanzvariablen gelten, wie der Name schon verrät, für eine Instanz. Will man auf sie zugreifen, obwohl sie nicht deklareiert wurde, gibt dies keinen Fehler. Es wird nil zurückgegeben. 
<source lang="ruby"># Gewöhnliche Verwendung von Instanzvariablen:
class Test
 def initialize
  @ham_num = 20
  @ham_type = "Gekochter Schinken"
 end

 def print_schinken
  puts "Du hast #{@ham_num} Stücke #{@ham_type}."
 end

 def iss_schinken
  @ham_num -= 1
 end
end</source>

Angesichts der Tatsache, dass auch Klassen und Module Instanzen sind, nämlich von der Klasse Object, ist auch das möglich:
<source lang="ruby">class Test
 @var = false
end</source>
Allerdings darf man hier nicht die Instanz von Test mit Test selbst verwechseln, wie es ab und zu von Anfängern getan wird:
<source lang="ruby">class Test
 @ham_verschimmelt = true
  def initialize
  @ham_num = 20
  @ham_type = "Gekochter Schinken"
 end

 def print_schinken
  if @ham_verschimmelt
   puts "Igitt!"
  else
   puts "Du hast #{@ham_num} Stücke #{@ham_type}."
  end
 end

 def iss_schinken
  @ham_num -= 1
 end
end</source>
Bei diesem Code ist in print_schinken immer "Du hast..." usw. zu erwarten. @ham_verschimmelt ist dort nämlich immer nil, da er nur für Test, die Instanz von Object, und nicht für die Instanz von Test definiert wurde.
Instanzvariablen werden dadurch gekennzeichnet, dass sie ein at-Symbol (@) am Anfang haben.

===Klassenvariablen===
Klassenvariablen gehen noch einen Schritt weiter als Instanzvariablen.
-kommt noch-

===Globale Variablen===
Globale Variablen sind eben, wie der Name sagt, global. Das heißt sie gelten überall.
Das ist auch der Grund, warum in eigentlich jeder Programmiersprache die Leute sagen "Benutzt keine globalen Variablen". Es kann schnell passieren, dass zwei Stück denselben Namen haben -> Fehler.
Wurden sie nicht deklariert und man will auf sie zugreifen, ist ihr Wert nil.
<source lang="ruby">def a
 3.times do
  $test = rand(25)
 end
end

a
p $test</source>
Sie werden dadurch gekennzeichnet, dass ein Dollarzeichen ($) zu Beginn steht.

Es gibt noch vordefinierte globale Variablen, die Ruby für verschiedene Zwecke benutzt.
Dazu gehören zB $:, $/, $1, $2 und $< . Sie hier zu erklären, wäre nicht mehr ganz der Sinn des Artikels. Man kann sie auf diversen Seiten nachlesen (Google ;).

===Konstanten===
Konstanten sind wieder, wie eigentlich alle Variablen, dank ihrem Namen gut zu identifizieren.
Sie gelten als konstant, sollten also ihren Wert nicht ändern. Es gibt durchaus Wege, das zu tun, aber ein guter Programmierstil ist es, zu einem Zeitpunkt die Konstante zu definieren und danach nie mehr irgendetwas daran ändern.
<source lang="ruby">KONSTANTE = 7</source>
Da Konstanten meistens in Klassen oder Modulen eingebaut werden gibt es einen einfachen Weg, darauf zuzugreifen:
<source lang="ruby">class Test
 KONST = 1
end
p Test::KONST # -> 1</source>
Konstanten werden durch Vererbung weitergereicht.
Sie werden gekennzeichnet, durch den großen Anfangsbuchstaben. Häufig wird auch der Rest der Buchstaben groß geschrieben, um das Lesen auf den ersten Blick leichter zu machen.
Auch Klassen und Module sind Konstanten - Meistens Konstanten von Object. Hierzu ein kleiner Test:
<source lang="ruby">module A
  def A.a()
    Kernel.print("a")
  end # eof a
end # eof class A

A.a()                    #=> "a"
Object::A.a()            #=> "a"
Object.const_get(:A).a() #=> "a"</source>
Wie bereits angemerkt wurde, kann man Konstanten ändern, was für den Normalbenutzer jedoch keines Falls sinnvoll ist. Ruby wirft außerdem eine Warnung, wenn Konstanten geändert werden. Programme wie der RGSS-Player stürzen an dieser Stelle mit einem Fehler ab.
<source lang="ruby">My_Const = 3+4
My_Const = 7-4                #=> bumms - Warnung!
Object.const_set(:My_Const,4) #=> Und wieder eine Warnung
# Sollte das Programm noch laufen, gilt nun:
Kernel.print(My_Const)        #=> 4</source>
Es ist wie gesagt davon abzuraten, Konstanten zu ändern.

===Pseudo-Variablen===
Es gibt noch 4 Variablen, die zu keinem der oben genannten Typen gehören:
*true
*false
*nil
*self
Die ersten drei sollten wirklich jedem, der das hier liest bekannt sein, die letzte eigentlich auch, aber ich erkläre sie nochmal kurz:
self ist eine scheinbare Variable, die das momentan agierende Objekt repräsentiert.
<source lang="ruby">class Test
 p self # -> Test
 def a
  p self
 end
end

Test.new.a # -> eine Instanz von Test</source>true, false, und nil hingegen sind Instanzen von TrueClass, FalseClass, und NilClass, haben jedoch insofern einen Sonderstatus, dass die unter Garantie diese Instanzen sein sollten (so, wie die 7 immer die 7 sein sollte).