Flanagan / Matsumoto Die Programmiersprache Ruby

1. Auflage 2013
ISBN: 978-3-89721-836-9
Verlag: O'Reilly
Format: PDF
Kopierschutz: Adobe DRM (»Systemvoraussetzungen)

E-Book, Deutsch, 478 Seiten

Die Programmiersprache Ruby ist das maßgebliche Handbuch zu Ruby mit einer umfassenden Beschreibung der Sprachversionen 1.8 und 1.9. Es wurde für erfahrene Programmierer geschrieben, die sich neu in Ruby einarbeiten wollen, und für Ruby-Programmierer, die ihr Wissen erweitern und Ruby besser beherrschen wollen. Dieses Buch dokumentiert Ruby umfassend, jedoch ohne den Formalismus einer Sprachspezifikation. Ruby vom Feinsten. 

Dieses Handbuch beginnt mit einem Tutorial zum Schnelleinstieg in die Sprache Ruby und erklärt sie dann detailliert auf allen Ebenen: 

- Lexikalische und syntaktische Struktur von Ruby-Programmen 
- Datentypen und Objekte 
- Ausdrücke und Operatoren - Anweisungen und Kontrollstrukturen 
- Methoden, Procs, Lambdas und Closures 
- Klassen und Module 
- Reflection und Metaprogrammierung 
- Die Ruby-Plattform API der Ruby-Plattform D

ie Programmiersprache Ruby beinhaltet eine umfassende Einführung in die mächtige API der Ruby-Plattform und stellt -- mit ausführlich kommentiertem Code - die Möglichkeiten von Ruby in Bezug auf Textbearbeitung, mathematische Berechnungen, Collections, Ein-/Ausgabe, Netzwerkverarbeitung und Concurrency vor. Wenn Sie Ruby wirklich verstehen wollen, ist dies das Buch, das Sie brauchen.

Autoren/Hrsg.

Flanagan, David

Matsumoto, Yukihiro

Inhaltsverzeichnis

1;Inhalt;5
2;Vorwort;9
3;Kapitel 1: Einführung;13
3.1;1.1 Eine Tour durch Ruby;14
3.2;1.2 Ruby ausprobieren;24
3.3;1.3 Über dieses Buch;29
3.4;1.4 Ein Sudoku-Löser in Ruby;30
4;Kapitel 2: Die Struktur und Ausführung von Ruby-Programmen;39
4.1;2.1 Lexikalische Struktur;40
4.2;2.2 Syntaktische Struktur;48
4.3;2.3 Dateistruktur;50
4.4;2.4 Programmkodierung;51
4.5;2.5 Programmausführung;54
5;Kapitel 3: Datentypen und Objekte;57
5.1;3.1 Zahlen;58
5.2;3.2 Text;62
5.3;3.3 Arrays;82
5.4;3.4 Hashes;85
5.5;3.5 Bereiche;87
5.6;3.6 Symbole;90
5.7;3.7 True, False und Nil;91
5.8;3.8 Objekte;92
6;Kapitel 4: Ausdrücke und Operatoren;107
6.1;4.1 Literale und Schlüsselwortliterale;108
6.2;4.2 Variablen;109
6.3;4.3 Konstanten;110
6.4;4.4 Methodenaufrufe;112
6.5;4.5 Wertzuweisung;114
6.6;4.6 Operatoren;124
7;Kapitel 5: Anweisungen und Kontrollstrukturen;141
7.1;5.1 Fallentscheidungen;142
7.2;5.2 Schleifen;151
7.3;5.3 Iteratoren und Aufzählungsobjekte;155
7.4;5.4 Blöcke;166
7.5;5.5 Den Steuerungsablauf modifizieren;172
7.6;5.6 Ausnahmen und Ausnahmebehandlung;182
7.7;5.7 BEGIN und END;194
7.8;5.8 Threads, Fiber und Continuations;195
8;Kapitel 6: Methoden, Procs, Lambdas und Closures;203
8.1;6.1 Einfache Methoden definieren;205
8.2;6.2 Methodennamen;208
8.3;6.3 Methoden und Klammern;211
8.4;6.4 Methodenargumente;214
8.5;6.5 Procs und Lambdas;222
8.6;6.6 Closures;231
8.7;6.7 Method-Objekte;233
8.8;6.8 Funktionale Programmierung;236
9;Kapitel 7: Klassen und Module;245
9.1;7.1 Definieren einer einfachen Klasse;246
9.2;7.2 Sichtbarkeit von Methoden: public, protected, private;265
9.3;7.3 Subklassen und Vererbung;268
9.4;7.4 Erzeugen und Initialisieren von Objekten;276
9.5;7.5 Module;282
9.6;7.6 Laden von Modulen;287
9.7;7.7 Singleton-Methoden und die Eigenklasse;292
9.8;7.8 Methoden-Lookup;294
9.9;7.9 Lookup von Konstanten;297
10;Kapitel 8: Reflexion und Metaprogrammierung;301
10.1;8.1 Typen, Klassen und Module;303
10.2;8.2 Strings und Blöcke auswerten;305
10.3;8.3 Variablen und Konstanten;307
10.4;8.4 Methoden;309
10.5;8.5 Hooks;314
10.6;8.6 Tracing;316
10.7;8.7 ObjectSpace und GC;318
10.8;8.8 Benutzerdefinierte Kontrollstrukturen;319
10.9;8.9 Fehlende Methoden und fehlende Konstanten;322
10.10;8.10 Methoden dynamisch erzeugen;326
10.11;8.11 Alias-Verkettung;328
10.12;8.12 Domänenspezifische Sprachen;335
11;Kapitel 9: Die Ruby-Plattform;341
11.1;9.1 Strings;342
11.2;9.2 Reguläre Ausdrücke;348
11.3;9.3 Zahlen und Berechnungen;360
11.4;9.4 Datums- und Uhrzeitwerte;365
11.5;9.5 Collections;367
11.6;9.6 Dateien und Verzeichnisse;392
11.7;9.7 Ein-/Ausgabe;398
11.8;9.8 Netzwerk-Handling;409
11.9;9.9 Threads und Parallelität;416
12;Kapitel 10: Die Ruby-Umgebung;433
12.1;10.1 Den Ruby-Interpreter aufrufen;434
12.2;10.2 Die Top-Level-Umgebung;439
12.3;10.3 »Practical Extraction and Report«- Arbeitserleichterungen;448
12.4;10.4 Das Betriebssystem aufrufen;451
12.5;10.5 Sicherheit;455
13;Index;461

Leseproben

KAPITEL 6 Methoden, Procs, Lambdas und Closures (S. 191-192)

Eine Methode ist ein benannter Block von parametrisiertem Code, der mit einem oder mehreren Objekten verknüpft ist. Ein Methodenaufruf gibt den Methodennamen an, das Objekt, für das die Methode aufgerufen wird (manchmal Empfänger oder englisch receiver genannt), sowie null oder mehr Argumentwerte, die den benannten Methodenparametern zugewiesen werden. Der Wert des zuletzt in der Methode ausgewerteten Ausdrucks wird zum Wert des Methodenaufrufausdrucks. Viele Sprachen unterscheiden zwischen Funktionen, die kein zugehöriges Objekt besitzen, und Methoden, die für ein Empfängerobjekt aufgerufen werden.

Da Ruby eine rein objektorientierte Sprache ist, sind alle Methoden echte Methoden und mindestens einem Objekt zugeordnet. Wir haben Klassendefinitionen in Ruby noch nicht besprochen, so dass die in diesem Kapitel definierten Beispielmethoden für Sie so aussehen wie globale Funktionen ohne zugehöriges Objekt. Tatsächlich werden sie in Ruby als private Methoden der Klasse Object definiert und aufgerufen. Methoden sind ein grundlegender Teil der Ruby-Syntax, aber sie sind keine Werte, mit denen Ruby-Programme operieren können. Das heißt, dass Ruby-Methoden nicht in derselben Weise Objekte sind wie Strings, Zahlen und Arrays.

Es ist jedoch möglich, ein Method-Objekt zu erhalten, das eine bestimmte Methode darstellt, und wir können Methoden indirekt durch Method-Objekte aufrufen. Methoden sind nicht die einzige Form von parametrisiertem ausführbarem Code in Ruby. Blöcke, die wir in Abschnitt 5.4 vorgestellt haben, sind ausführbare Codestücke und können Parameter haben. Anders als Methoden haben Blöcke jedoch keine Namen, und sie können nur indirekt durch eine Iterator-Methode aufgerufen werden. Blöcke sind wie Methoden keine Objekte, die Ruby manipulieren kann. Aber es ist möglich, ein Objekt zu erzeugen, das einen Block repräsentiert, und das geschieht in Ruby- Programmen tatsächlich relativ häufig.

Ein Proc-Objekt repräsentiert einen Block. Genau wie bei einem Method-Objekt können wir den Code eines Blocks durch die Proc ausführen, die ihn darstellt. Es gibt zwei Unterarten von Proc-Objekten, Procs und Lambdas genannt, die ein leicht unterschiedliches Verhalten besitzen. Sowohl Procs als auch Lambdas sind eher Funktionen als Methoden, die für ein Objekt aufgerufen werden. Ein wichtiges Feature von Procs und Lambdas ist, dass sie Closures sind: Sie erhalten Zugriff auf die lokalen Variablen, die bei ihrer Definition in ihrem Gültigkeitsbereich lagen, selbst wenn die Proc oder das Lambda aus einem anderen Gültigkeitsbereich aufgerufen wird.

Methoden besitzen in Ruby eine reichhaltige und recht komplexe Syntax, und die ersten vier Abschnitte dieses Kapitels sind ihnen gewidmet. Wir beginnen mit der Erläuterung, wie man einfache Methoden definiert, und erweitern diesen einführenden Abschnitt durch drei fortgeschrittenere Abschnitte, die Methodennamen, Methodenklammern und Methodenparameter behandeln. Beachten Sie, dass ein Methodenaufruf eine Art Ausdruck ist, was weiter oben in Abschnitt 4.4 besprochen wurde. Weitere Details über Methodenaufrufe werden in den ersten vier Abschnitten dieses Kapitels erläutert.

Nach der Behandlung der Methoden wenden wir unsere Aufmerksamkeit den Procs und Lambdas zu, erläutern, wie man sie erzeugt und aufruft, und gehen auch ins Detail, was die subtilen Unterschiede zwischen ihnen angeht. Ein separater Abschnitt behandelt den Einsatz von Procs und Lambdas als Closures. Darauf folgt ein Abschnitt über das Method- Objekt, das sich in vielerlei Hinsicht wie ein Lambda verhält. Das Kapitel schließt mit einer fortgeschrittenen Untersuchung der funktionalen Programmierung in Ruby.