(englisch für Rubin) ist eine höhere Programmiersprache, die Mitte der 1990er Jahre vom Japaner Yukihiro Matsumoto entworfen wurde.
Ruby ist objektorientiert, unterstützt aber mehrere weitere Programmierparadigmen (unter anderem prozedurale und funktionale Programmierung sowie Nebenläufigkeit), bietet dynamische Typisierung, Reflexion und automatische Speicherbereinigung. Ein Programm in Ruby wird zur Laufzeit interpretiert. 2012 wurde die Ruby-Spezifikation als internationale Norm ISO/IEC 30170 standardisiert.iso.org
Entstehung und Geschichte mini|hochkant|Schöpfer von Ruby, Yukihiro Matsumoto (2007)
Yukihiro „Matz“ Matsumoto begann 1993 an einer eigenen Sprache zu arbeiten und gab am 21. Dezember 1995 die erste Version von Ruby, 0.95, frei.RubyConf: History of Ruby Den Namen, hergeleitet vom Edelstein Rubin, wählte er als Anspielung auf die Programmiersprache Perl.Ein Interview mit dem Schöpfer von Ruby Matsumotos Ziel bei der Erschaffung der neuen Sprache war, eine Synthese aus Elementen der von ihm geschätzten Programmiersprachen Perl, Smalltalk, Eiffel, Ada und Lisp zu bilden und funktionale und imperative Programmierparadigmen in Einklang zu bringen. Darüber hinaus sollte die Sprache objektorientierter als Python und zugleich mächtiger als Perl sein. Auch Flexibilität, Ausdrucksstärke und Einfachheit spielten bereits eine gewichtige Rolle.
Besonders wichtig, neben den technischen Eigenschaften, war Matsumoto an Ruby auch die emotionale Wirkung auf Anwender, Mitentwickler und sich selbst. Matsumotos Auffassung dazu ist folgende:
In Japan erlangte Ruby nach Erscheinen rasch an Bekanntheit. Im Westen verhalfen der Programmiersprache das Buch Programming Ruby (2000) (bekannt als Pickaxe book als Anspielung auf die Illustration auf dem Buchdeckel) und das Webframework Ruby on Rails (2004) zum Durchbruch. In den folgenden Jahren mehrte sich auch die englisch- und deutschsprachige Dokumentation sowie Literatur. Die Verkehrssprache der Kern-Entwickler wechselte von Japanisch zu Englisch. Heute wird die Sprache als Open-Source-Projekt weitergepflegt und ist Gegenstand diverser Publikationen und Kurse. Veröffentlichungen mit neuen Funktionen geschehen üblicherweise im Jahresrhythmus zur Weihnachtszeit.
Ein Meilenstein in der Entwicklung von Ruby war die Version 1.9 im Jahr 2007, welche mit vielen Änderungen ziemlich inkompatibel zu den Vorgängerversionen wurde. Die Semantik einiger Konstrukte hat sich in dieser Version geändert. Der Interpreter wurde komplett neu geschrieben, womit Rubyprogramme wesentlich schneller wurden. Zeichenketten bekamen separate Zeichenkodierungen, Variablen in Blöcken wurden block-lokal, IPv6-Unterstützung und einige syntaktische Erleichterungen fanden Einzug.
Mit Ruby 2.0 wurden Schlüsselwortparameter eingeführt (bspw.: 0.step(by: 5, to: 20)), das Vorhängen (prepend) von Modulen und Bedarfsauswertung (lazy-evaluation) von Iteratoren eingeführt. Außerdem wurde die Standardzeichenkodierung auf UTF-8 festgelegt. Ruby 2.1 führte Refinements (eine Methode um Überschreibungen von Klassen lokal zu beschränken) ein. In Ruby 2.2 wurde der vorhandene Garbage-Collector durch einen inkrementellen ersetzt. Mit Ruby 2.3 ist es möglich, alle Zeichenketten automatisch schreibgeschützt zu erstellen und ein neuer Operator &. (Safe-Navigation-Operator) zum Umgehen von Nil-Überprüfungen wurde eingeführt. In Ruby 2.4 wurden die Klassen Fixnum und Bignum vereinheitlicht. Seit Ruby 2.5 können Exceptions in do-end-Blöcken ohne separate Unterblöcke gefangen werden. Ruby 2.6 lieferte den ersten Code eines optionalen JIT-Compilers und fügte Bundler (s. u.) zur Standarddistribution hinzu. Ruby 2.7 führte ausführliches Patternmatching und einige syntaktische Erleichterungen dem Sprachkern hinzu. Jede neue Ruby-Version ab 1.9 brachte zudem Geschwindigkeitsoptimierungen verschiedenen Ausmaßes mit sich. Zusätzlich erweiterte jede Version die Standardbibliothek um nützliche Methoden. Es wurde stets auf Abwärtskompatibilität geachtet, allerdings nicht immer zu hundert Prozent erreicht.
Ruby 3.0, erschienen am 25. Dezember 2020, ist die erste Version, welche die „Ruby 3x3“ genannten Forderungen erfüllt: Dreimal höhere Ausführungsgeschwindigkeit zu Ruby 2.0 (durch JIT-Compiler), Nebenläufigkeit ohne GIL (allerdings noch experimentell) und statische Typanalyse (optional). Das eigentliche Update 3.0 stellt allerdings keinen größeren Sprung als die vorherigen jährlichen Veröffentlichungen dar und ist abwärtskompatibel zu Ruby 2.x.
Merkmale Alles ist ein Objekt Ruby ist eine Programmiersprache, die, obwohl sie auch viele andere Programmierparadigmen unterstützt, von Grund auf objektorientiert ist. Das bedeutet konkret, dass in Ruby ausnahmslos jeder Wert ein Objekt und jede Funktion eine Methode ist (d. h. einer Klasse zugeordnet ist). Ausnahmen für primitive Datentypen wie in vielen anderen objektorientierten Programmiersprachen gibt es nicht. Auch Klassen sind Objekte. Objekte speichern Instanzvariablen und haben eine Klasse. Klassen sind Objekte, die Methoden speichern und eine Vererbungshierarchie besitzen. Auf Instanzvariablen kann ausschließlich über Methoden zugegriffen werden.
class TestKlasse end test_objekt = TestKlasse.new
puts 1.class # => Integer puts "text".class # => String puts test_objekt.class # => TestKlasse puts TestKlasse.class # => Class puts Class.class # => Class
Werden in Ruby „Funktionen“ definiert, so sind das in Wirklichkeit Methoden, die dem Objekt Object hinzugefügt werden. In Ruby erben alle Objekte implizit von Object, weswegen so definierte „Funktionen“ in jedem Objekt und damit allgegenwärtig verfügbar sind. Allerdings werden diese Funktionen als private markiert, das heißt, sie können nicht von außen auf einem Objekt aufgerufen werden.
# Definiere „Funktion“ def meine_funktion puts "Hier bin ich" end
# Kann in andern Objekten wie eine Funktion benutzt werden class ABC def gib_meine_funktion_aus meine_funktion end end mein_abc = ABC.new mein_abc.gib_meine_funktion_aus # => Hier bin ich mein_abc.meine_funktion # => Fehlermeldung, private method `meine_funktion' called
Da in Ruby Objekte dynamisch sind, kann man mit Ruby auch prototypbasiert programmieren. Das bedeutet grob, dass Objekte eigene Methoden haben können (außerhalb der von der Klasse vorgegebenen) und kopiert und verändert werden können (da nur Klassen Methoden beinhalten können, wird im Hintergrund eine versteckte neue Klasse nur für das eine Objekt angelegt).
auto1 = Object.new def auto1.beschleunigen puts "brumm brumm brumm" end
auto1.beschleunigen # => "brumm brumm brumm"
auto2 = auto1.clone def auto2.bremsen puts "quietsch" end
auto2.beschleunigen # => "brumm brumm brumm" auto2.bremsen # => "quietsch"
Blöcke In den meisten höheren Programmiersprachen ist es möglich, Funktionen in irgendeiner Form zusätzlich als Parameter Logik zu übergeben, sei es durch First-Class-Funktionen oder First-Class-Objekte (deren Methoden dann die Logik bereitstellen). Das ist in Ruby nicht anders, allerdings hat Ruby den Spezialfall, dass genau eine Funktion übergeben wird, syntaktisch (und auch von der Rechenleistung) stark optimiert. Dieser Spezialfall wird Block genannt, gemeint als ein Block Programmierlogik, den die Funktion zu benutzen hat.
Blöcke werden Funktionen als separate Parameter übergeben und folgen als letztes Argument, eingegrenzt durch geschwungene Klammern oder die Schlüsselworte do und end. Im Folgenden wird die Methode times des Objekts 10 aufgerufen und ein Block übergeben. Beide Aufrufe sind identisch.
10.times { puts "Hallo Welt!" } 10.times do puts "Hallo Welt!" end
Zusätzlich können Blöcken Parameter übergeben werden und sie haben auch einen Rückgabewert. Zum Aufrufen des übergebenen Blocks wird innerhalb der aufgerufenen Methode das Schlüsselwort yield verwendet. Werden nach yield Parameter angegeben, so werden diese dem Block übergeben, der sie zu Beginn als lokale Variablen deklarieren oder ignorieren kann. Blöcke (ebenso wie Methoden) geben automatisch den letzten Ausdruck des Blockes als Rückgabewert zurück (mittels break und next kann aber auch an anderen Stellen zurückgesprungen werden).
def methode_die_block_aufruft(übergebener_parameter) eigene_variable = "Hallo" rückgabe = yield eigene_variable, übergebener_parameter if rückgabe == "ok" puts "☺" end end
# Aufruf methode_die_block_aufruft("aus Ruby") do |p1,p2| # die Blockargumente werden innerhalb || in Block-lokale Variablen umgewandelt puts p1 + " " + p2 + "!" "ok" end # Zuerst wird im Block „Hallo aus Ruby!“ ausgegeben, # dann in der Methode ☺, da der Rückgabewert „ok“ war
Blöcke können auch in Funktionsobjekte umgewandelt werden. Wird innerhalb der Parameterliste einer Methode vor den letzten Parameter ein & geschrieben, wandelt Ruby den übergebenen Block in ein Proc (ein Funktions-Objekt) um. Alternativ können Procs auch manuell durch die Schlüsselworte proc, lambda und -> angelegt werden. Aufgerufen werde diese Objekte durch die Methoden call, [] oder .(). Da Ruby runde Klammern lediglich zum Gruppieren nutzt, können Procs nicht (wie in anderen Programmiersprachen üblich) mit proc_name() aufgerufen werden.
def mache_block_zu_proc &block block # ist der Rückgabewert, da letzter Ausdruck end a = mache_block_zu_proc{|a,b| a + b} b = proc {|a,b| a - b} # ein return innerhalb des Blocks verlässt die beinhaltende Methode, break nur den Block c = lambda {|a,b| a * b} # wie proc, aber return innerhalb des lambdas verlässt nur diesen Block d = -> (a,b) {a / b} # neue Schreibweise für lambda, runde Klammern sind optional a.call(1,2) # => 3 b[1,2] # => -1 c.(1,2) # => 2
# Beispiel für funktionale Programmierung e = d.curry.(8) # neues Proc, das den (oder die) ersten Parameter (den Dividenden hier) als 8 setzt e.(2) # => 4 # mit & können Proc-Objekte (eigentlich jede Klasse, die eine "call"-Methode hat) wieder in Blöcke umgewandelt werden [8,4,2,1].map(&e) # => [1, 2, 4, 8]
Alle Blöcke sind Closures, sie speichern also z. B. den Zustand lokaler Variablen, wenn sie innerhalb des Blocks dauerhaft benötigt werden.
Mixins Ruby beherrscht bewusst keine Mehrfachvererbung, bietet stattdessen aber ein Konzept namens Mixin (deutsch: Beimischung). Mixins sind Sammlungen von Methoden, die beliebigen Klassen beigemischt werden können. Eine Klasse kann beliebig viele Mixins beinhalten. Mixins werden in der Vererbungshierarchie zwischen Klasse und Superklasse in der Reihenfolge eingehängt, in der sie geschrieben wurden. Alternativ ist es auch möglich, Mixins vor die eigentliche Klasse zu hängen (u. a. hilfreich für Aspektorientierte Programmierung). Um Mixins zu definieren, werden in Ruby Module benutzt, das sind quasi Klassen (d. h. Sammlungen von Methoden), die nicht instanziiert werden können, und Namensräume in einem.
class Tier def sagt puts "#{self.class} sagt nichts" # "text#{logik}text" ist Rubys Textinterpolation end end
module KannSchwimmen # Module, d. h. KannSchwimmen.new geht nicht def schwimmt puts "#{self.class} schwimmt" # self gibt die Instanz zurück, end # jedes Objekt hat eine Methode .class, die das Klassenobjekt zurückgibt end
module KannNichtSchwimmen def schwimmt puts "#{self.class} geht unter" end end
class Fisch < Tier # Vererbung wird durch den Kleiner-Als-Operator gekennzeichnet include KannSchwimmen # füge KannSchwimmen zwischen Fisch und Tier ein end
class Vogel < Tier include KannNichtSchwimmen def sagt # übliches Vererben, überdecke sagt-Methode von Tier puts "#{self.class}: Piep" end end
class Mensch < Tier include KannSchwimmen def sagt puts "#{self.class}: Ich kann mich besser ausdrücken" end end
class NichtSchwimmer < Mensch prepend KannNichtSchwimmen # hänge KannNichtSchwimmen vor NichtSchwimmer ein, end # dh, überdecke die schwimmt-Methode
fisch = Fisch.new mensch = Mensch.new vogel = Vogel.new nicht_schwimmer = NichtSchwimmer.new
fisch.sagt # => Fisch sagt nichts vogel.sagt # => Vogel: Piep