Rubin ist eine dynamische, reflektierende, objektorientierte Mehrzweckprogrammiersprache, die Syntax verbindet, die von Perl mit einem Plausch ähnlichen Eigenschaften begeistert ist. Es war auch unter Einfluss Eiffel und Lisp. Rubin wurde zuerst entworfen und hat sich Mitte der 1990er Jahre durch Yukihiro "Matz" Matsumoto in Japan entwickelt.

Rubin unterstützt vielfache Programmierparadigmen, einschließlich des funktionellen, Gegenstand orientiert, befehlend und reflektierend. Es hat auch ein dynamisches Typ-System und automatisches Speichermanagement; es ist deshalb im Verändern der Hinsicht zu Plausch, Pythonschlange, Perl, Lispeln, Dylan, Hecht und CLU ähnlich.

Die 1.8.7 Standarddurchführung wird in C geschrieben, weil ein einzelner Pass Sprache interpretiert hat. Die Sprachspezifizierungen für Ruby wurden durch das Offene Standardpromotionszentrum der Informationstechnologie-Promotionsagentur (eine japanische Regierungsstelle) für die Vorlage zum japanischen Industriestandardkomitee und dann zur Internationalen Organisation für die Standardisierung entwickelt. Es wurde als ein japanischer Industriestandard (JIS X 3017) 2011 und ein internationaler Standard (ISO/IEC 30170) 2012 akzeptiert., es gibt mehrere ganze oder kommende alternative Durchführungen von Ruby, einschließlich YARV, JRuby, Rubinius, IronRuby, MacRubys und HotRuby. Jeder nimmt eine verschiedene Annäherung, mit IronRuby, JRuby, MacRuby und Rubinius, der gerade rechtzeitig Kompilation und MacRuby auch zur Verfügung stellt, der vorzeitig Kompilation zur Verfügung stellt. Der offizielle 1.9 Zweiggebrauch-YARV, wie 2.0 (Entwicklung) wird, und schließlich die langsamere Ruby MRI ersetzen wird.

Geschichte

Rubin wurde am 24. Februar 1993 von Yukihiro Matsumoto konzipiert, der eine neue Sprache hat schaffen wollen, die funktionelle Programmierung mit der befehlenden Programmierung erwogen hat. Matsumoto hat gesagt, "Ich habe eine scripting Sprache gewollt, die stärker als Perl und mehr objektorientiert war als Pythonschlange. Deshalb habe ich mich dafür entschieden, meine eigene Sprache zu entwerfen."

Bei einem Google Technologischen Gespräch 2008 hat Matsumoto weiter festgesetzt, "Ich hoffe, Ruby zu sehen, jedem Programmierer in der Welt helfen, produktiv zu sein, und daran Freude zu haben, zu programmieren und glücklich zu sein. Das ist der primäre Zweck der Sprache von Ruby."

Wahl des Namens "Rubin"

Für den Namen "Rubin" wurde während einer Online-Chat-Sitzung zwischen Matsumoto und Keiju Ishitsuka am 24. Februar 1993 entschieden, bevor jeder Code für die Sprache geschrieben worden war. Am Anfang wurden zwei Namen vorgeschlagen: "Koralle" und "Rubin", mit den Letzteren, die durch Matsumoto in einer späteren E-Mail zu Ishitsuka wählen werden. Matsumoto hat später bemerkt, dass ein Faktor in der Auswahl des Namens "Rubin" war, weil es der Monatsstein von einem seiner Kollegen war.

Die erste Veröffentlichung

Die erste öffentliche Ausgabe von Ruby 0.95 wurde auf japanischem häuslichem newsgroups am 21. Dezember 1995 bekannt gegeben. Nachher wurden noch drei Versionen von Ruby in zwei Tagen veröffentlicht. Die Ausgabe ist mit dem Start der japanisch-sprachigen Adressenliste der rubinroten Liste zusammengefallen, die die erste Adressenliste für die neue Sprache war.

Bereits anwesend in dieser Bühne der Entwicklung waren viele der Eigenschaften, die in späteren Ausgaben von Ruby, einschließlich des objektorientierten Designs, der Klassen mit Erbe, mixins, iterators, Verschlüssen, dem Ausnahme-Berühren und der Müll-Sammlung vertraut sind.

Rubinrote 1.0

Rubin hat Version 1.0 am 25. Dezember 1996 erreicht.

Im Anschluss an die Ausgabe von Ruby 1.3 1999 hat das erste englische Sprachadressenliste-rubinrote Gespräch begonnen, der einem wachsenden Interesse an der Sprache außerhalb Japans Zeichen gegeben hat. Im September 2000 wurde das erste englische Sprachbuch, Ruby Programmierend, gedruckt, der später zum Publikum weiter das Verbreitern der Adoption von Ruby unter englischen Sprechern frei veröffentlicht wurde.

Rubin auf Schienen

2005 hat das Interesse an der Sprache von Ruby im Tandem mit Ruby auf Schienen, ein populäres in Ruby geschriebenes Webanwendungsfachwerk gedrängt. Schienen wird oft das Bilden von "berühmter" Ruby zugeschrieben.

Rubinrote 1.8

Ruby 1.8 war seit langem stabil. Obwohl missbilligt, gibt es noch darauf gestützten Code. Ruby 1.8 ist mit Ruby 1.9 unvereinbar.

Rubinrote 1.9

Die letzte stabile Version der Bezugsdurchführung ist 1.9.3 und wird laut der Rubinroten Lizenz und einer BSD-Lizenz doppellizenziert.

Rubinrote 1.9 führen viele bedeutende Änderungen über die 1.8 Reihen ein. Beispiele:

• Blockieren Sie lokale Variablen (Variablen, die zum Block lokal sind, in dem sie erklärt werden)
• Eine zusätzliche Lambda-Syntax
• Charakter pro Schnur encodings wird unterstützt
• Neue Steckdose-API (IPv6 Unterstützung)
• require_relative importieren Sicherheit

Rubinrote 2.0

Ruby 1.9 wird von Ruby 2.0 gefolgt.

Ruby 2.0 wird verbreitet um", mit Ruby 1.9.3 "um 100 % vereinbar zu sein.

, der Plan ist, Codestopp-Oktober 2012 und Ausgabe-Februar 2013 zu haben.

Philosophie

Matsumoto hat gesagt, dass Ruby für die Programmierer-Produktivität und den Spaß im Anschluss an die Grundsätze des guten Benutzerschnittstelle-Designs entworfen wird. Er betont, dass Systemdesign Menschen, aber nicht Computer, Bedürfnisse betonen muss:

Wie man

sagt, folgt Ruby dem Grundsatz von kleinstem Erstaunen (POLA), meinend, dass sich die Sprache auf solche Art und Weise benehmen sollte, um Verwirrung für erfahrene Benutzer zu minimieren. Matsumoto hat gesagt, dass seine primäre Designabsicht war, eine Sprache zu machen, die er selbst daran Freude gehabt hat zu verwenden, indem er Programmierer-Arbeit und mögliche Verwirrung minimiert hat. Er hat gesagt, dass er den Grundsatz von kleinster Überraschung zum Design von Ruby nicht angewandt hatte, aber dennoch ist der Ausdruck gekommen, um mit der Programmiersprache von Ruby nah vereinigt zu werden. Der Ausdruck ist selbst eine Quelle der Überraschung gewesen, weil Anfänger-Benutzer es nehmen können, um zu bedeuten, dass die Handlungsweisen von Ruby versuchen, aus anderen Sprachen vertraute Handlungsweisen nah zu vergleichen. In einem Mai 2005, Diskussion über den newsgroup comp.lang.ruby, hat Matsumoto versucht, Ruby von POLA überzuholen, erklärend, dass, weil jede Designwahl zu jemandem überraschend sein wird, er einen persönlichen Standard im Auswerten der Überraschung verwendet. Wenn dieser persönliche Standard konsequent bleibt, würde es wenige Überraschungen für diejenigen geben, die mit dem Standard vertraut sind.

Matsumoto hat es dieser Weg in einem Interview definiert:

Eigenschaften

• Völlig objektorientiert mit dem Erbe, mixins und metaclasses
• Das dynamische Schreiben und die Ente, die tippt
• Alles ist ein Ausdruck (sogar Behauptungen), und alles wird befehlend (sogar Behauptungen) durchgeführt
• Kurz gefasste und flexible Syntax, die syntaktisches Geräusch minimiert und als ein Fundament für bereichsspezifische Sprachen dient
• Dynamisches Nachdenken und Modifizierung von Gegenständen, metaprogramming zu erleichtern
• Lexikalische Verschlüsse, iterators und Generatoren, mit einer einzigartigen Block-Syntax
• Wörtliche Notation für Reihe, Kuddelmuddel, regelmäßige Ausdrücke und Symbole
• Das Einbetten des Codes in Schnuren (Interpolation)
• Verzug-Argumente
• Vier Niveaus des variablen Spielraums (global, Klasse, Beispiel, und lokal) angezeigt durch sigils oder Mangel haben davon
• Müll-Sammlung
• Erstklassige Verlängerungen
• Strenge boolean Zwang-Regeln (ist alles außer und wahr)
• Ausnahme, die behandelt
• Maschinenbediener, der überlädt
• Eingebaute Unterstützung für rationale Zahlen, komplexe Zahlen und Arithmetik der willkürlichen Präzision
• Kundenspezifisches Absendungsverhalten (durch und)
• Heimische Fäden und kooperative Fasern
• Anfängliche Unterstützung für Unicode und vielfachen Charakter encodings (noch verwanzt bezüglich der Version 1.9)
• Heimische Einfügefunktions-API in C
• Interaktiver Rubin Shell (ein REPL)
• Zentralisiertes Paket-Management durch RubyGems
• Durchgeführt auf allen Hauptplattformen
• Große Standardbibliothek

Semantik

Rubin ist objektorientiert: Jeder Wert ist ein Gegenstand, einschließlich Klassen und Beispiele von Typen, die viele andere Sprachen als Primitive (wie ganze Zahlen, booleans, und "Null") benennen. Variablen halten immer Verweisungen auf Gegenstände. Jede Funktion ist eine Methode, und Methoden werden immer auf einem Gegenstand genannt. Am Spitzenniveau-Spielraum definierte Methoden werden Mitglieder der Gegenstand-Klasse. Da diese Klasse ein Vorfahr jeder anderen Klasse ist, können solche Methoden auf jedem Gegenstand genannt werden. Sie sind auch in allen Spielraumen sichtbar, effektiv als "globale" Verfahren dienend. Rubin unterstützt Erbe mit der dynamischen Absendung, mixins und den Singleton-Methoden (und definiert für, ein einzelnes Beispiel gehörend, anstatt auf der Klasse definiert zu werden). Obwohl Rubin Mehrfachvererbung nicht unterstützt, können Klassen Module als mixins importieren.

Rubin ist als eine Mehrparadigma-Programmiersprache beschrieben worden: Es erlaubt Verfahrensprogrammierung (Funktionen/Variablen außerhalb Klassen definierend macht sie einen Teil der Wurzel, 'selbst' Gegenstand), mit der Gegenstand-Orientierung (alles ist ein Gegenstand), oder funktionelle Programmierung (es hat anonyme Funktionen, Verschlüsse und Verlängerungen; Behauptungen alle haben Werte und Funktionen, geben die letzte Einschätzung zurück). Es hat Unterstützung für Selbstbeobachtung, Nachdenken und metaprogramming, sowie Unterstützung für Dolmetscher-basierte Fäden. Rubin zeigt das dynamische Schreiben, und unterstützt parametrischen polymorphism.

Gemäß den häufig gestellten Fragen von Ruby "Wenn Sie Perl mögen, werden Sie Ruby mögen und werden zuhause mit seiner Syntax richtig sein. Wenn Sie Plausch mögen, werden Sie Ruby mögen und sind zuhause mit seiner Semantik richtig. Wenn Sie Pythonschlange mögen, können Sie oder dürfen durch den riesigen Unterschied in der Designphilosophie zwischen Pythonschlange und Ruby/Perl nicht beiseite gelegt werden."

Syntax

Die Syntax von Ruby ist Perl und Python weit gehend ähnlich. Klasse und Methode-Definitionen wird durch Schlüsselwörter Zeichen gegeben. Im Gegensatz zu Perl werden Variablen mit einem sigil nicht obligatorisch vorbefestigt. Wenn verwendet, ändert der sigil die Semantik des Spielraums der Variable. Ein Unterschied zu C und Perl ist, dass Schlüsselwörter normalerweise verwendet werden, um logische Codeblöcke, ohne geschweifte Klammern (d. h., Paar {und}) zu definieren. Zu praktischen Zwecken gibt es keine Unterscheidung zwischen Ausdrücken und Behauptungen. Linienbrechungen sind bedeutend und als das Ende einer Behauptung genommen; ein Strichpunkt kann gleichwertig verwendet werden. Verschieden von der Pythonschlange ist Einrückung nicht bedeutend.

Einer der Unterschiede von Ruby im Vergleich zu Python und Perl ist, dass Ruby alle seine Beispiel-Variablen völlig privat zur Klasse hält und sie nur durch Zugriffsberechtigter-Methoden (usw.) ausstellt. Verschieden von den "Hauer-" und "Setter"-Methoden anderer Sprachen wie C ++ oder Java werden Zugriffsberechtigter-Methoden in Ruby mit einer einzelnen Linie des Codes über metaprogramming geschaffen. Da die Beschwörung dieser Methoden den Gebrauch von Parenthesen nicht verlangt, ist es trivial, um eine Beispiel-Variable in eine volle Funktion zu ändern, ohne eine einzelne Linie des Codes zu modifizieren oder jedes Wiederfactoring tun zu müssen, das ähnliche Funktionalität zu C# und VB.NET Eigentumsmitglieder erreicht.

Die Eigentumsdeskriptoren der Pythonschlange sind ähnlich, aber kommen mit einem Umtausch im Entwicklungsprozess. Wenn man in der Pythonschlange beginnt, indem man eine öffentlich ausgestellte Beispiel-Variable und spätere Änderungen die Durchführung verwendet, um eine private durch einen Eigentumsdeskriptor ausgestellte Beispiel-Variable zu verwenden, muss zur Klasse innerer Code eventuell angepasst werden, um die private Variable aber nicht das Volkseigentum zu verwenden. Das Design von Ruby zwingt alle Beispiel-Variablen, privat zu sein, sondern auch stellt eine einfache Weise zur Verfügung zu erklären und Methoden. Das ist in Übereinstimmung mit der Idee, die in Ruby, ein nie direkt auf die inneren Mitglieder einer Klasse von der Außenseite seiner zugreift; eher passiert man eine Nachricht an die Klasse und erhält eine Antwort.

Sieh die Beispiel-Abteilung für Proben des Codes, der Syntax von Ruby demonstriert.

Abweichungen vom Verhalten anderswohin

Einige Eigenschaften, die sich namentlich von Sprachen wie C oder Perl unterscheiden:

• Die Sprachsyntax ist zur Kapitalisierung von Bezeichnern in den meisten Fällen empfindlich, die kapitalisierte Variablen als Konstanten behandeln.
• Die sigils und zeigen variablen Datentyp als in Perl nicht an, aber fungieren eher als Spielraum-Entschlossenheitsmaschinenbediener.
• Um einen Schwimmpunkt ohne einen dezimalen Bestandteil anzuzeigen, muss man mit einer Nullziffer oder eine ausführliche Konvertierung folgen. Es ist ungenügend, um einen Punkt anzuhängen , da Zahlen gegen die Methode-Syntax empfindlich sind.
• Die Einschätzung von Boolean von non-boolean Daten ist streng: Und werden alle zum wahren bewertet. In C bewertet der Ausdruck zu 0 (d. h. falsch). In Ruby, jedoch, trägt es 1, weil alle Zahlen zum wahren bewerten; nur und bewerten Sie zum falschen. Eine Folgeerscheinung zu dieser Regel ist, dass Methoden von Ruby durch die Tagung — zum Beispiel, Suchen des regelmäßigen Ausdrucks — Zahlen, Schnuren, Listen oder andere nichtfalsche Werte auf dem Erfolg, aber auf dem Misserfolg zurückgeben. Diese Tagung wird auch im Plausch verwendet, wo nur die speziellen Gegenstände und in einem boolean Ausdruck verwendet werden können.
• Versionen vor 1.9 ganzen Gebrauch-Ebene-Zahlen, um einzelne Charaktere viel wie C zu vertreten. Das kann Überraschungen verursachen, wenn es Schnuren aufschneidet: Erträge 97 (der ASCII Code des ersten Charakters in der Schnur); Gebrauch (eine Teilkette der Länge 1) zu erhalten, oder.
• Die Notation, wie Perl, aber verschieden von den gleichwertigen Behauptungen anderer Sprachen (z.B in C/C ++/...), führt wirklich nie die Behauptung, wenn der Ausdruck bereits wahr ist. Das ist, weil wirklich syntaktischer zu Ende Zucker ist, dessen Entsprechung in C/C ++ ist, wie dazu gleichwertig ist. Jedoch wird die Notation in Ruby tatsächlich die Behauptung einmal führen, selbst wenn der Ausdruck bereits wahr ist, tut das Handeln ähnlich "-während" anderer Sprachen. (Matz hat einen Wunsch ausgedrückt, das spezielle Verhalten dessen zu entfernen, aber es besteht noch bezüglich Rubys 1.9.)
• Weil Konstanten Verweisungen auf Gegenstände sind, ändernd, worauf sich eine Konstante bezieht, erzeugt eine Warnung, aber das Ändern des Gegenstands selbst tut nicht. Zum Beispiel,

Einige Eigenschaften, die sich namentlich von anderen Sprachen unterscheiden:

• Die üblichen Maschinenbediener für bedingte Ausdrücke, und, folgen den normalen Regeln der Priorität nicht: Bindet dichter nicht als. Rubin hat auch Ausdruck-Maschinenbediener, und die, wie erwartet, arbeiten.

Eine Liste von so genanntem gotchas kann im Buch von Hal Fulton Die Ruby Weg, 2. Hrsg. (internationale Standardbuchnummer 0-672-32884-4), Abschnitt 1.5 gefunden werden. Eine ähnliche Liste in der 1. Ausgabe hat einer älteren Version von Ruby (Version 1.6) gehört, deren einige Probleme inzwischen befestigt worden sind. zum Beispiel, jetzt Arbeiten mit, und, sowie iterators.

Wechselwirkung

Der Rubinrote offizielle Vertrieb schließt auch ein",", ein interaktiver Dolmetscher der Befehl-Linie, der verwendet werden kann, um Code schnell zu prüfen. Das folgende Codebruchstück vertritt ein Beispielsitzungsverwenden:

$ irb

irb (haupt)-:001:0> stellt "Hallo, Welt"

Hallo, Welt

> Null

irb (haupt)-:002:0> 1+2

> 3

</Quelle>

Beispiele

Die folgenden Beispiele können in einer Schale von Ruby wie Interaktive Ruby Shell geführt oder in einer Datei und Lauf von der Befehl-Linie durch das Schreiben gespart werden

Klassiker Hallo Weltbeispiel:

stellt "Hallo Welt!"

</Quelle>

Ein grundlegender Code von Ruby:

1. Alles, einschließlich eines Druckfehlers, ist ein Gegenstand, so arbeitet das:

- 199.abs # 199

"Eis ist".length # 11 nett

"Rubin ist kühl.". Index ("u") # 1

"Netter Tag nicht wahr?".downcase.split ("").uniq.sort.join # "'? acdeinsty"

</Quelle>

Konvertierungen:

stellt "Wie ist Ihre Lieblingszahl?"

Zahl = gets.chomp

output_number = Zahl to_i + 1

stellt output_number.to_s + 'ist eine größere und bessere Lieblingszahl.'

</Quelle>

Schnuren

Es gibt eine Vielfalt von Methoden, um Schnuren in Ruby zu definieren.

Die folgenden Anweisungen sind gleichwertig und unterstützen Variable Interpolation:

a = "\nThis ist ein doppelt angesetzter string\n"

a = %Q {\\nThis ist ein doppelt angesetzter string\n }\

a = % {\\nThis ist ein doppelt angesetzter string\n }\

a = %/\nthis ist ein doppelt angesetzter string\n /

a =

Die folgenden Anweisungen sind gleichwertig und erzeugen rohe Schnuren:

a = 'Das ist eine einzeln angesetzte Schnur'

a = %q {ist Das eine einzeln angesetzte Schnur }\

</Quelle>

Sammlungen

Das Konstruieren und das Verwenden einer Reihe:

a = [1, 'hallo', 3.14, 1, 2, [4, 5]]

stellt [2] # 3.14

stellt a. [] (2) # 3.14

stellt a.reverse # 4, 5], 2, 1, 3.14, 'hallo', 1]

stellt a.flatten.uniq # [1, 'hallo', 3.14, 2, 4, 5]

</Quelle>

Das Konstruieren und das Verwenden einer assoziativen Reihe (genannt Kuddelmuddel in Ruby):

Kuddelmuddel = {: Wasser => 'nass': Schießen Sie => 'heißer' }\

stellt Kuddelmuddel [: Feuer] # Drucke: heißer

Kuddelmuddel each_pair tut |key, schätzt | # Oder: Hash.each tun |key, value|

stellt "# {Schlüssel} ist # {Wert}"

Ende

1. Drucke: Wasser ist nasser

1. Feuer ist heißer

hash.delete: Wasser # Löscht: Wasser => 'nasser'

Schlüssel des Kuddelmuddels delete_if Wert | Löscht Wert == 'heiß'} #: Schießen Sie => 'heißer'

</Quelle>

Blöcke und iterators

Die zwei Syntaxen, für einen Codeblock zu schaffen:

{stellt "Hallo, Welt!"} # klammert Zeichen {}\

oder

tun Sie

stellt "Hallo, Welt!"

Ende</Quelle>

Wenn ein Codeblock geschaffen wird, wird er immer einer Methode als ein fakultatives Block-Argument beigefügt.

Parameter-Übergang ein Block, um ein Verschluss zu sein:

1. In einer Gegenstand-Beispiel-Variable (angezeigt mit), erinnern Sie sich an einen Block.

def erinnern sich (&a_block)

@block = a_block

Ende

1. Rufen Sie die obengenannte Methode an, ihm einen Block gebend, der einen Namen nimmt.

erinnern Sie sich, dass Name | "Hallo, # {Name} stellt!" }\

1. Wenn es wäre Zeit (für den Gegenstand) - den Verschluss nennen!

@block.call ("Jon")

1. => "Hallo, Jon!"

</Quelle>

Das Schaffen einer anonymen Funktion:

proc arg | drucken arg }\

Proc.new arg | drucken arg }\

Lambda arg | druckt arg }\

1. eingeführt in Ruby 1.9

-> (arg) {drucken arg }\

</Quelle>

Das Zurückbringen von Verschlüssen von einer Methode:

def create_set_and_get (initial_value=0) # Zeichen der Verzug-Wert von 0

closure_value = initial_value

geben Sie Proc.new x | closure_value = x\, Proc.new {closure_value }\zurück

Ende

Setter, Hauer = create_set_and_get # d. h. Umsatz zwei Werte

setter.call (21)

getter.call # => 21

1. Sie können auch eine Parameter-Variable als eine Schwergängigkeit für den Verschluss verwenden.
2. So kann der obengenannte als umgeschrieben werden...

def create_set_and_get (closure_value=0)

geben Sie proc x | closure_value = x\, proc {closure_value }\zurück

Ende</Quelle>

Das Nachgeben des Flusses des Programms kontrolliert zu einem Block, der beim Benennen der Zeit zur Verfügung gestellt wurde:

def use_hello

tragen Sie "hallo"

Ende

1. Rufen Sie die obengenannte Methode an, ihm einen Block passierend.

Use_hello-Schnur | stellt Schnur} # => 'hallo'

</Quelle>

Das Wiederholen über Enumerationen und Reihe mit Blöcken:

ordnen Sie = [1, 'hallo', 3.14]

Array.each-Artikel | stellt Artikel }\

1. => 1
2. => 'hallo'
3. => 3.14

Index der Reihe each_index | stellt "# {Index}: # {Reihe [Index]}" }\

1. => 0: 1
2. => 1: 'hallo'
3. => 2: 3.14
4. Der folgende Gebrauch eine Reihe

(3.. 6) stellt.each num | num }\

1. => 3
2. => 4
3. => 5
4. => 6

</Quelle>

Eine Methode, die einspritzen kann sowohl einen Parameter als auch einen Block akzeptieren. Spritzen Sie ein wiederholt über jedes Mitglied einer Liste, etwas Funktion darauf durchführend, während man eine Anhäufung behält. Das ist der Foldl-Funktion auf funktionellen Programmiersprachen analog. Zum Beispiel:

[1,3,5]. spritzen Sie (10) Summe, Element | Summe + Element} # => 19 ein

</Quelle>

Auf dem ersten Pass erhält der Block 10 (das Argument, um einzuspritzen), als Summe, und 1 (das erste Element der Reihe) als Element; das kehrt 11 zurück. 11 wird dann Summe auf dem folgenden Pass, der zu 3 hinzugefügt wird, um 14 zu kommen. 14 wird dann zu 5 hinzugefügt, um schließlich 19 zurückzukehren.

Blöcke arbeiten mit vielen eingebauten Methoden:

File.open ('file.txt', 'w') tun |file | # 'w' zeigt an "schreiben Weise".

file.puts 'Hat einen Text geschrieben.'

enden Sie # Datei wird hier automatisch geschlossen

File.readlines ('file.txt').each tun |line|

stellt Linie

Ende

1. => Hat einen Text geschrieben.

</Quelle>

Das Verwenden einer Enumeration und eines Blocks zum Quadrat die Nummern 1 bis 10 (eine Reihe verwendend):

(1.. 10).collect x | x*x} # => [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

</Quelle>

Klassen

Der folgende Code definiert eine Klasse genannt die Person. Zusätzlich dazu, 'initialisieren' der übliche Konstrukteur, um neue Gegenstände zu schaffen, es hat zwei Methoden: Ein, um zu überreiten

Klassenperson

attr_reader: Name: Alter

def initialisieren (Name, Alter)

@name, @age = Name, Alter

Ende

def

Alter

Ende

def to_s

"# {Name} (# {Alter})"

EndeEnde

Gruppe = [

Person.new ("Bob", 33),

Person.new ("Chris", 16),

Person.new ("Asche", 23)

]

stellt group.sort.reverse

</Quelle>

Die obengenannten Drucke drei Namen in der Rückaltersordnung:

Bob (33)

Asche (23)

Chris (16)

</Quelle>

Offene Klassen

Im Rubin werden Klassen nie geschlossen: Sie können immer Methoden zu einer vorhandenen Klasse hinzufügen. Das gilt für die Klassen, die Sie sowie die normalen, eingebauten Klassen schreiben. Alles, was Sie tun müssen, ist öffnen eine Klassendefinition für eine vorhandene Klasse, und der neue Inhalt, den Sie angeben, wird dazu hinzugefügt, dass dort ist. Ein einfaches Beispiel, eine neue Methode zur Zeitklasse der Standardbibliothek hinzuzufügen:

1. eröffnen Sie die Zeitklasse des Rubins wieder

Klassenzeit

def gestern

selbst - 86400

EndeEnde

heute = Time.now # => Donnerstag, der 14. Aug 16:51:50 Uhr +1200 2008

gestern = today.yesterday # => Wed am 13. Aug 16:51:50 Uhr +1200 2008

</Quelle>

Das Hinzufügen von Methoden zu vorher definierten Klassen wird häufig Affe-Flicken genannt. Diese Praxis kann jedoch zu möglichen Kollisionen des Verhaltens und der nachfolgenden unerwarteten Ergebnisse führen, und ist eine Sorge für die Codeskalierbarkeit, wenn durchgeführt, rücksichtslos.

Ausnahmen

Eine Ausnahme wird mit einem Anruf erhoben:

erheben Sie

</Quelle>

Eine fakultative Nachricht kann zur Ausnahme hinzugefügt werden:

erheben Sie "Das ist eine Nachricht"

</Quelle>

Sie können auch angeben, welchen Typ der Ausnahme Sie erheben wollen:

erziehen Sie ArgumentError, "Ungesetzliche Argumente!"

</Quelle>

Wechselweise können Sie ein Ausnahme-Beispiel zur erheben Methode passieren:

erheben Sie ArgumentError.new ("Ungesetzliche Argumente!")

</Quelle>

Diese letzte Konstruktion ist nützlich, wenn Sie eine kundenspezifische Ausnahme-Klasse erheben müssen, die einen Konstrukteur zeigt, der mehr als ein Argument nimmt:

Klasse ParseError

Ausnahmen werden durch die Klausel behandelt. Solch eine Klausel kann Ausnahmen fangen, die von StandardError erben. Auch unterstützt für den Gebrauch mit Ausnahmen sind und

beginnen Sie

1. Tun Sie etwas

Rettung

1. Griff-Ausnahme

sonst

1. Tun Sie das, wenn keine Ausnahme erhoben wurde

sichern Sie

1. Tun Sie das, ob eine Ausnahme erhoben wurde

Ende</Quelle>

Es ist ein häufiger Fehler zu versuchen, alle Ausnahmen mit einer einfachen Rettungsklausel zu fangen. Um alle Ausnahmen zu fangen, muss man schreiben:

beginnen Sie Tun Sie etwas

retten Sie Ausnahme

1. schreiben Sie gerade Rettung nicht - der nur StandardError, eine Unterklasse der Ausnahme fängt

Griff-AusnahmeEnde</Quelle>

Oder Fang besondere Ausnahmen:

beginnen Sie

1. ...

retten Sie RuntimeError

1. das Berühren

Ende</Quelle>

Es ist auch möglich anzugeben, dass die Ausnahme protestiert, zur Dressierer-Klausel bereitgestellt werden:

beginnen Sie ...

retten Sie RuntimeError => e

1. das Berühren, vielleicht e, wie "Druck e.to_s" einschließend

Ende</Quelle>

Wechselweise wird die neuste Ausnahme in der globalen Magie versorgt.

Sie können auch mehrere Ausnahmen fangen:

beginnen Sie ...

RettungsruntimeError, Pause:: Fehler => e

1. das Berühren, vielleicht das Beteiligen e

Ende</Quelle>

Metaprogramming

Rubinroter Code, kann an der Durchlaufzeit, den Aspekten seiner eigenen Struktur programmatisch modifizieren, die auf starreren Sprachen, wie Klasse und Methode-Definitionen befestigt würde. Diese Sorte von metaprogramming kann verwendet werden, um kürzeren Code zu schreiben und effektiv die Sprache zu erweitern.

Zum Beispiel erzeugt der folgende Code von Ruby neue Methoden für die eingebaute Schnur-Klasse, die auf einer Liste von Farben gestützt ist. Die Methoden wickeln den Inhalt der Schnur mit einem mit der jeweiligen Farbe entworfenen HTML-Anhängsel.

FARBEN = {: schwarz => "000",

:red => "f00",

:green => "0f0",

:yellow => "ff0",

:blue => "00f",

:magenta => "f0f",

:cyan => "0ff",

:white => "fff" }\

Klassenschnur

COLORS.each tun |color, code|

define_method "in_# {Farbe}" tun

""

Ende

EndeEnde</Quelle>

Die erzeugten Methoden konnten dann wie so verwendet werden:

"Hallo, Welt!".in_blue

> ""

</Quelle>

Um die Entsprechung auf vielen anderen Sprachen durchzuführen, würde der Programmierer jede Methode (in_black, in_red, in_green, usw.) mit der Hand schreiben müssen.

Ein anderer möglicher Gebrauch für Ruby metaprogramming schließt ein:

• das Abfangen und das Ändern der Methode nennen
• das Einführen neuer Erbe-Modelle
• dynamisch erzeugende Klassen von Rahmen
• automatische Gegenstand-Anordnung
• interaktive Hilfe und die Fehler beseitigend

Mehr Beispiele

Mehr Probe Code von Ruby ist als Algorithmen in den folgenden Artikeln verfügbar:

• Exponentiating durch das Quadrieren
• Algorithmus von Trabb Pardo-Knuth

Durchführungen

Die neueste Version von Ruby, die kürzlich veröffentlichte Version 1.9, hat eine einzelne Arbeitsdurchführung, die in C geschrieben ist, der eine Rubinrot-spezifische virtuelle Maschine verwertet.

Version 1.8 von Ruby hat drei Hauptdurchführungen: Der Beamter-Dolmetscher von Ruby hat häufig als der Dolmetscher oder MRI von Ruby von Matz gekennzeichnet, der am weitesten verwendet ist; JRuby, eine javanische Durchführung, die auf Java virtuelle Maschine führt; und Rubinius, eine Wiederdurchführung von Ruby, die sich darauf konzentriert, so viel des Kerns in Ruby wie möglich zu schreiben.

Es gibt andere weniger bekannte oder kommende Durchführungen wie Kardinal (eine Durchführung für den Papageien virtuelle Maschine), IronRuby (Alpha-Version verfügbar seit dem 24. Juli 2008), MacRuby, MagLev, Ruby.NET, XRuby und HotRuby (führt Quellcode von Ruby auf einem WWW-Browser und Blitz).

Die Reife von Durchführungen von Ruby neigt dazu, durch ihre Fähigkeit gemessen zu werden, die Ruby auf Schienen (Schienen) Fachwerk zu führen, weil es ein kompliziertes Fachwerk ist, um durchzuführen, und es viele Rubinrot-spezifische Eigenschaften verwendet. Der Punkt, wenn eine besondere Durchführung dieses Ziel erreich, wird Die Schiene-Eigenartigkeit genannt. Die Bezugsdurchführung (MRI), JRuby und Rubinius sind alle fähig, in einer Produktionsumgebung unmodifizierte Schienen zu führen. IronRuby fängt an im Stande zu sein, Schiene-Testfälle zu führen, aber ist noch davon weit, zu der Produktion bereit zu sein.

Rubin ist auf vielen Betriebssystemen, wie Linux, Mac OS X, Windows von Microsoft, Windows Telefon 7, Windows CE und die meisten Geschmäcke nach Unix verfügbar.

Rubinrote 1.9 sind kürzlich auf Symbian OS 9.x getragen worden.

Behältnisse und Bibliotheken

Ruby Application Archive (RAA), sowie RubyForge, dient als Behältnisse für eine breite Reihe von Anwendungen von Ruby und Bibliotheken, mehr als siebentausend Sachen enthaltend. Obwohl die Zahl von verfügbaren Anwendungen das Volumen des in der Gemeinschaft von Perl oder Python verfügbaren Materials nicht vergleicht, gibt es eine breite Reihe von Werkzeugen und Dienstprogrammen, die dienen, um weitere Entwicklung auf der Sprache zu fördern.

RubyGems ist der Standardpaket-Betriebsleiter für Bibliotheken von Ruby geworden. Es ist im Zweck dem CPAN von Perl sehr ähnlich, obwohl sein Gebrauch mehr passend ähnlich ist - kommen.

Kürzlich haben viele neue und vorhandene Bibliotheken ein Haus auf GitHub gefunden, der auf den Schwachkopf eingestellt wird.

Siehe auch

• Vergleich von Programmiersprachen
• Rubinroter MRI, die Verweisung C Durchführung
• JRuby
• MacRuby
• IronRuby
• Rubinius
• XRuby
• Rubin auf Schienen
• Warum (scharfes) Handbuch zum Rubin - ein rubinrotes Online-Lehrbuch im grafischen neuartigen Format ist
• Metasploit Projekt - die größte Ruby in der Welt springt mit mehr als 700,000 Linien des Codes vor

Weiterführende Literatur

Links

• Rubinrote Dokumentationsseite
• Rubinrote Draftspezifizierung - Sep 2010
• Wiki: Rubinrote Sprache und Durchführungsspezifizierung
• Versuchen Sie Rubin! - webbasierter Rubin REPL
• Die Große Rubinrote Schießerei (Dezember 2008): Rubinroter Durchführungsvergleich.
• Collingbourne, Huw (am 17. Juni 2006), Das Kleine Buch Von Rubinrotem, freiem PDF eBook 1.1 Mb, Seiten 87
• Collingbourne, Huw (am 18. April 2009), Das Buch Von Rubinrotem, freiem PDF eBook 2.9 Mb, Seiten 425
• Ruby.on-page.net — einfaches Handbuch von Ruby mit vielen Proben
• Führer von Ruby User Durch Matz, der Schöpfer von Ruby. Übersetzt ins Englisch.
• Rubin aus anderen Sprachen
• Das Schreiben C Erweiterungen auf den Rubin (MRI 1.8)
• RubyFlow: Gemeinschaft gefilterte rubinrote Nachrichten
• Der rubinrote Reflektor automatisierte rubinrote Nachrichten
• Rubinrotes Forum - Tor zur Adressenliste des rubinroten Gespräches
• Die Ruby in Stone Ruby IDE innerhalb der Programmiersprache von FlowStone