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 deklariert wurden. Ist dies nicht der Fall und man will auf sie zugreifen, gibt es einen Fehler.

def foo
 n = 12
end
 
def bar
 foo
 p n
 # n wird versucht auszugeben, liegt aber nur im Scope in foo -> Fehler
end

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

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.

# 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

Angesichts der Tatsache, dass auch Klassen und Module Instanzen sind, nämlich von der Klasse Object, ist auch das möglich:

class Test
 @var = false
end

Allerdings darf man hier nicht die Instanz von Test mit Test selbst verwechseln, wie es ab und zu von Anfängern getan wird:

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

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.

def a
 3.times do
  $test = rand(25)
 end
end
 
a
p $test

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.

KONSTANTE = 7

Da Konstanten meistens in Klassen oder Modulen eingebaut werden gibt es einen einfachen Weg, darauf zuzugreifen:

class Test
 KONST = 1
end
p Test::KONST # -> 1

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:

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"

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.

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

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.

class Test
 p self # -> Test
 def a
  p self
 end
end
 
Test.new.a # -> eine Instanz von Test

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).