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