Ruby

-Was ist Ruby
-Datentypen
-Variablen
-Klassen und Methoden
-Dynamik der Sprache

Was ist Ruby

Wie aus dem Namen „Ruby on Rails" ersichtlich ist, baut das Framework auf der Scriptsprache Ruby auf. Ruby wurde zwischen 1993 und 1995 von Yukihiro Matsumoto in Japan entwickelt, Anstoß hierzu war der Frust über inkonsistente Programmiersprachen. Daher folgt Ruby dem Prizip der geringsten überraschung und versucht so möglichst intuitiv zu sein. Bekannt wurde Ruby in den USA und Europa aber erst ab ca. 2000, da erst zu diesem Zeitpunkt die ersten englischen Dokumentationen verfügbar waren.
Ruby ist eine vollständig objektorientierte Interpretersprache, deren Syntax an C++ und Eifel angelehnt wurde. Ebenso wie C++ ist Ruby eine „Multiparadigmen-Sprache" und unterstützt somit die objektorientierte, prozedurale und funktionale Programmierung. Mittlerweilse lassen sich Rubyprogramme durch JRuby in Java verwenden.
Um die folgende kurze Einführung in die Sprache nachzuvollziehen zu können, empfehle ich einen Besuch der Webseite tryruby.hobix.com. Auf dieser Webseite steht eine interaktive Rubyshell im Webbrowser zur Verfügung.
[top]

Datentypen

In Ruby sind alle Datentypen Objekte. Es gibt keine spezielle Datenstruktur für primitve Typen wie in Java. Zusätzlich ist Ruby, ähnlich wie PHP, dynamisch typisiert.
Beispiele: var = 42 var.class ==> FixNum var = "string" var.class ==> String
[top]

Variablen

Ruby hat fünf Typen von Variablen:

Globale Variablen

Sie sind durch den Präfix „$" gekennzeichnet und zeigen vor der Inizialisierung immer auf „nil"

Instanz Variablen

Instanz Variablen sind nur innerhalb einer Instanz einer Klasse gültig und haben das Präfix „@"

Klassen Variablen

Klassen Variablen sind für eine Klasse definiert und jede Instanz dieser Klasse greift auf die selbe Variable zu. Klassen Variabeln haben „@@" als Präfix.

Lokale Variablen

Sie sind nur in einem Block gültig, also zwischen class|modul|def und end. Sie bestehen per Definition nur aus Kleinbuchstaben.

Konstanten

Konstanten beginnen in Ruby immer mit einem Großbuchstaben. Ihre Gültigkeit beschränkt sich auf den jeweiligen Kontext in dem sie angelegt wurden, d.h. eine Konstante, die innerhalb einer Klasse definiert ist, ist auch nur innerhalb dieser Klasse definiert.
[top]

Klassen und Methoden

Die Definition von eigenen Klassen und Methoden sollte durch das folgende Beispiel deutlich werden:
class Name #Klassen definition attr_writer :name #erzeugt einen Setter für "name" protected :name #setzt die Variable "name" auf protected def initialize(name = „World") #Methodendefinition mit einem Parameter (default-Wert: World) @name = name #setzt die Instanz-Variable "name" end end class Greeter < Name #Definition der Klasse Greeter, welche von der Klasse "Name" erbt def initialize(name) super(@name) #ruft die init der vererbenden Klasse auf end def say_hi puts "Hallo #{@name}!” #direkte ausgabe der Var. @name end end ---------------------------------------------------------------------------------------------------- hw = Greeter.new() hw.say_hi ==> "Hallo World!” g = Greeter.new("Leser”) g.say_hi ==> "Hallo Leser!” g.name = "Setter” g.say_hi ==> "Hallo Setter!”
[top]

Dynamik der Sprache

In Ruby existiert die Möglichkeit einer Methode einen Code-Block zu übergeben. Innerhalb dieser Methode kann jetzt mittels des Schüsselworts „yield” der Code ausgeführt werden. So lassen sich sehr einfach z.B: dynamische Iteratoren erzeugen.
def MYWHILE (cond) return if not cond #Wenn cond nicht erfüllt ist, springe nicht aus der Methode yield #Rufe den externen Block auf retry #Führe MYWHILE erneut aus end ----------------------------------------------------------------------------------- i=0 MYWHILE(i<3) {print I, " "; i+=1} ==> 0 1 2
[top]