Cover image for Die Programmiersprache Ruby

Book description

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.

Table of Contents

  1. Die Programmiersprache Ruby
  2. Vorwort
    1. Danksagungen
      1. David Flanagan
      2. Yukihiro Matsumoto
    2. In diesem Buch verwendete Konventionen
    3. Verwendung der Codebeispiele
  3. 1. Einführung
    1. 1.1 Eine Tour durch Ruby
      1. 1.1.1 Ruby ist objektorientiert
      2. 1.1.2 Blöcke und Iteratoren
      3. 1.1.3 Ausdrücke und Operatoren in Ruby
      4. 1.1.4 Methoden
      5. 1.1.5 Wertzuweisung
      6. 1.1.6 Zeichensetzungssuffixe und -präfixe
      7. 1.1.7 Reguläre Ausdrücke und Bereiche
      8. 1.1.8 Klassen und Module
      9. 1.1.9 Ruby-Überraschungen
    2. 1.2 Ruby ausprobieren
      1. 1.2.1 Der Ruby-Interpreter
      2. 1.2.2 Ausgaben anzeigen
      3. 1.2.3 Interaktives Ruby mit irb
      4. 1.2.4 Die Ruby-Dokumentation mit ri lesen
      5. 1.2.5 Ruby-Paketmanagement mit gem
      6. 1.2.6 Weitere Ruby-Tutorials
      7. 1.2.7 Ruby-Ressourcen
    3. 1.3 Über dieses Buch
      1. 1.3.1 Wie man dieses Buch lesen sollte
    4. 1.4 Ein Sudoku-Löser in Ruby
  4. 2. Die Struktur und Ausführung von Ruby-Programmen
    1. 2.1 Lexikalische Struktur
      1. 2.1.1 Kommentare
        1. 2.1.1.1 Eingebettete Dokumente
        2. 2.1.1.2 Dokumentationskommentare
      2. 2.1.2 Literale
      3. 2.1.3 Zeichensetzung
      4. 2.1.4 Bezeichner
        1. 2.1.4.1 Groß- und Kleinschreibung
        2. 2.1.4.2 Unicode-Zeichen in Bezeichnern
        3. Zeichensetzung in Bezeichnern
      5. 2.1.5 Schlüsselwörter
      6. 2.1.6 Whitespace
        1. 2.1.6.1 Zeilenumbrüche als Anweisungstrenner
        2. 2.1.6.2 Leerzeichen und Methodenaufrufe
    2. 2.2 Syntaktische Struktur
      1. 2.2.1 Blockstruktur in Ruby
    3. 2.3 Dateistruktur
    4. 2.4 Programmkodierung
      1. 2.4.1 Die Programmkodierung festlegen
      2. 2.4.2 Quellkodierung und externe Standardkodierung
    5. 2.5 Programmausführung
  5. 3. Datentypen und Objekte
    1. 3.1 Zahlen
      1. 3.1.1 Integer-Literale
      2. 3.1.2 Fließkomma-Literale
      3. 3.1.3 Arithmetik in Ruby
      4. 3.1.4 Binärfließkomma und Rundungsfehler
    2. 3.2 Text
      1. 3.2.1 String-Literale
        1. 3.2.1.1 String-Literale in einfachen Anführungszeichen
        2. 3.2.1.2 String-Literale in doppelten Anführungszeichen
        3. 3.2.1.3 Unicode-Escapes
        4. 3.2.1.4 Weitere Begrenzungen für String-Literale
        5. 3.2.1.5 Hier-Dokumente
        6. 3.2.1.6 Backtick-Kommandoausführung
        7. 3.2.1.7 String-Literale und Veränderlichkeit
        8. 3.2.1.8 Die Methode String.new
      2. 3.2.2 Zeichenliterale
      3. 3.2.3 String-Operatoren
      4. 3.2.4 Zugriff auf Zeichen und Teil-Strings
      5. 3.2.5 Über Strings iterieren
      6. 3.2.6 String-Kodierungen und Multibyte-Zeichen
        1. 3.2.6.1 Mehrbyte-Zeichen in Ruby 1.9
        2. 3.2.6.2 Die Klasse Encoding
        3. 3.2.6.3 Mehr-Byte-Zeichen in Ruby 1.8
    3. 3.3 Arrays
    4. 3.4 Hashes
      1. 3.4.1 Hash-Literale
      2. 3.4.2 Hash-Codes, Gleichheit und veränderliche Schlüssel
    5. 3.5 Bereiche
      1. 3.5.1 Zugehörigkeit zu einem Bereich prüfen
    6. 3.6 Symbole
    7. 3.7 True, False und Nil
    8. 3.8 Objekte
      1. 3.8.1 Objektreferenzen
        1. 3.8.1.1 Unmittelbare Werte
      2. 3.8.2 Objektlebenszyklus
      3. 3.8.3 Objektidentität
      4. 3.8.4 Objektklasse und Objekttyp
      5. 3.8.5 Objektgleichheit
        1. 3.8.5.1 Die Methode equal?
        2. 3.8.5.2 Der Operator ==
        3. 3.8.5.3 Die Methode eql?
        4. 3.8.5.4 Der Operator ===
        5. 3.8.5.5 Der Operator =~
      6. 3.8.6 Objektreihenfolge
      7. 3.8.7 Objektkonvertierung
        1. 3.8.7.1 Explizite Konvertierung
        2. 3.8.7.2 Implizite Konvertierung
        3. 3.8.7.3 Konvertierungsfunktionen
        4. 3.8.7.4 Typ-Erzwingung für arithmetische Operatoren
        5. 3.8.3.5 Boolean-Typkonvertierung
      8. 3.8.8 Objekte kopieren
      9. 3.8.9 Objekt-Marshaling
      10. 3.8.10 Objekte einfrieren
      11. 3.8.11 Taint-Objekte
  6. 4. Ausdrücke und Operatoren
    1. 4.1 Literale und Schlüsselwortliterale
    2. 4.2 Variablen
      1. 4.2.1 Uninitialisierte Variablen
    3. 4.3 Konstanten
    4. 4.4 Methodenaufrufe
    5. 4.5 Wertzuweisung
      1. 4.5.1 Wertzuweisung an Variablen
      2. 4.5.2 Wertzuweisung an Konstanten
      3. 4.5.3 Wertzuweisung an Attribute und Array-Elemente
      4. 4.5.4 Abgekürzte Wertzuweisung
      5. 4.5.5 Parallele Wertzuweisung
        1. 4.5.5.1 Dieselbe Anzahl von Lvalues und Rvalues
        2. 4.5.5.2 Ein Lvalue, mehrere Rvalues
        3. 4.5.5.3 Mehrere Lvalues, ein einzelner Array-Rvalue
        4. 4.5.5.4 Unterschiedliche Anzahl von Lvalues und Rvalues
        5. 4.5.5.5 Der Splat-Operator
        6. 4.5.5.6 Klammern in der parallelen Wertzuweisung
        7. 4.5.5.7 Der Wert der parallelen Wertzuweisung
    6. 4.6 Operatoren
      1. 4.6.1 Unäres + und -
      2. 4.6.2 Potenz: **
      3. 4.6.3 Arithmetik: +, −, *, / und %
      4. 4.6.4 Verschieben und Anhängen: << und >>
      5. 4.6.5 Komplement, Vereinigungs- und Schnittmenge: ~, &, |, und ^
      6. 4.6.6 Vergleich: <, <=, >, >= und <=>
      7. 4.6.7 Gleichheit: ==, !=, =~, !~ und ===
      8. 4.6.8 Boolean-Operatoren: &&, ||, !, and, or, not
      9. 4.6.9 Bereiche und Flip-Flops: .. und ...
        1. 4.6.9.1 Boolean-Flip-Flops
      10. 4.6.10 Bedingungsprüfung: ?:
      11. 4.6.11 Wertzuweisungsoperatoren
      12. 4.6.12 Der Operator defined?
      13. 4.6.13 Anweisungsmodifizierer
      14. 4.6.14 Nicht-Operatoren
  7. 5. Anweisungen und Kontrollstrukturen
    1. 5.1 Fallentscheidungen
      1. 5.1.1 if
        1. 5.1.1.1 else
        2. 5.1.1.2 elsif
        3. 5.1.1.3 Rückgabewert
      2. 5.1.2 if als Modifier
      3. 5.1.3 unless
      4. 5.1.4 case
      5. 5.1.5 Der Operator ?:
    2. 5.2 Schleifen
      1. 5.2.1 while und until
      2. 5.2.2 while und until als Modifier
      3. 5.2.3 Die for/in-Schleife
    3. 5.3 Iteratoren und Aufzählungsobjekte
      1. 5.3.1 Numerische Iteratoren
      2. 5.3.2 Enumerable-Objekte
      3. 5.3.3 Benutzerdefinierte Iteratoren schreiben
      4. 5.3.4 Enumeratoren
      5. 5.3.5 Externe Iteratoren
      6. 5.3.6 Iteration und konkurrierende Modifikation
    4. 5.4 Blöcke
      1. 5.4.1 Blocksyntax
      2. 5.4.2 Der Wert eines Blocks
      3. 5.4.3 Blöcke und Gültigkeitsbereiche von Variablen
      4. 5.4.4 Argumente an einen Block übergeben
    5. 5.5 Den Steuerungsablauf modifizieren
      1. 5.5.1 return
      2. 5.5.2 break
        1. 5.5.2.1 break mit einem Wert
      3. 5.5.3 next
        1. 5.5.3.1 next und der Blockwert
      4. 5.5.4 redo
      5. 5.5.5 retry
      6. 5.5.6 throw und catch
    6. 5.6 Ausnahmen und Ausnahmebehandlung
      1. 5.6.1 Ausnahmeklassen und Ausnahmeobjekte
        1. 5.6.1.1 Die Methoden von Ausnahmeobjekten
        2. 5.6.1.2 Ausnahmeobjekte erzeugen
        3. 5.6.1.3 Neue Ausnahmeklassen definieren
      2. 5.6.2 Ausnahmen mit raise auslösen
      3. 5.6.3 Ausnahmebehandlung mit rescue
        1. 5.6.3.1 Die Bezeichnung des Ausnahmeobjekts
        2. 5.6.3.2 Ausnahmen nach Typ behandeln
        3. 5.6.3.3 Weitergabe von Ausnahmen
        4. 5.6.3.4 Ausnahmen während der Ausnahmebehandlung
        5. 5.6.3.5 retry in einer rescue-Klausel
      4. 5.6.4 Die else-Klausel
      5. 5.6.5 Die ensure-Klausel
      6. 5.6.6 rescue mit Methoden-, Klassen- und Moduldefinitionen
      7. 5.6.7 rescue als Anweisungs-Modifier
    7. 5.7 BEGIN und END
    8. 5.8 Threads, Fiber und Continuations
      1. 5.8.1 Threads zur Nebenläufigkeit
      2. 5.8.2 Fiber für Coroutinen
        1. 5.8.2.1 Fiber-Argumente und -Rückgabewerte
        2. 5.8.2.2 Generatoren durch Fiber implementieren
        3. 5.8.2.3 Fortgeschrittene Fiber-Features
      3. 5.8.2 Continuations
  8. 6. Methoden, Procs, Lambdas und Closures
    1. 6.1 Einfache Methoden definieren
      1. 6.1.1 Methodenrückgabewert
      2. 6.1.2 Methoden und Ausnahmebehandlung
      3. 6.1.3 Eine Methode für ein Objekt aufrufen
      4. 6.1.4 Singleton-Methoden definieren
      5. 6.1.5 Methodendefinitionen aufheben
    2. 6.2 Methodennamen
      1. 6.2.1 Operatormethoden
      2. 6.2.2 Methoden-Aliase
    3. 6.3 Methoden und Klammern
      1. 6.3.1 Optionale Klammern
      2. 6.3.2 Notwendige Klammern
    4. 6.4 Methodenargumente
      1. 6.4.1 Parameterstandardwerte
      2. 6.4.2 Argumentlisten mit variabler Länge und Arrays
        1. 6.4.2.1 Arrays an Methoden übergeben
      3. 6.4.3 Parametern Argumente zuweisen
      4. 6.4.4 Hashes für benannte Argumente
      5. 6.4.5 Blockargumente
        1. 6.4.5.1 & im Methodenaufruf verwenden
    5. 6.5 Procs und Lambdas
      1. 6.5.1 Procs erzeugen
        1. 6.5.1.1 Proc.new
        2. 6.5.1.2 Kernel.lambda
        3. 6.5.1.3 Kernel.proc
        4. 6.5.1.4 Lambda-Literale
      2. 6.5.2 Procs und Lambdas aufrufen
      3. 6.5.3 Die Stelligkeit einer Proc
      4. 6.5.4 Proc-Gleichheit
      5. 6.5.5 Wie Lambdas sich von Procs unterscheiden
        1. 6.5.5.1 Return in Blöcken, Procs und Lambdas
        2. 6.5.5.2 Break in Blöcken, Procs und Lambdas
        3. 6.5.5.3 Andere Steuerungsablaufanweisungen
        4. 6.5.5.4 Argumentübergabe an Procs oder Lambdas
    6. 6.6 Closures
      1. 6.6.1 Closures und gemeinsame Variablen
      2. 6.6.2 Closures und Bindungen
    7. 6.7 Method-Objekte
      1. 6.7.1 UnboundMethod-Objekte
    8. 6.8 Funktionale Programmierung
      1. 6.8.1 Eine Funktion auf ein Enumerable anwenden
      2. 6.8.2 Funktionen verknüpfen
      3. 6.8.3 Funktionen partiell anwenden
      4. 6.8.4 Memoisationsfunktionen
      5. 6.8.5 Symbole, Methoden und Procs
  9. 7. Klassen und Module
    1. 7.1 Definieren einer einfachen Klasse
      1. 7.1.1 Erstellen der Klasse
      2. 7.1.2 Instanziieren eines Point
      3. 7.1.3 Initialisieren eines Point
      4. 7.1.4 Definieren einer Methode to_s
      5. 7.1.5 Akzessoren und Attribute
      6. 7.1.6 Definieren von Operatoren
      7. 7.1.7 Array- und Hash-Zugriff mit []
      8. 7.1.8 Koordinaten enumerieren
      9. 7.1.9 Point und Gleichheit
      10. 7.1.10 Punkte ordnen
      11. 7.1.11 Ein veränderbarer Point
      12. 7.1.12 Veränderbare Klassen auf die Schnelle
      13. 7.1.13 Eine Klassenmethode
      14. 7.1.14 Konstanten
      15. 7.1.15 Klassenvariablen
      16. 7.1.16 Klassen-Instanzvariablen
    2. 7.2 Sichtbarkeit von Methoden: public, protected, private
    3. 7.3 Subklassen und Vererbung
      1. 7.3.1 Methoden erben
      2. 7.3.2 Methoden überschreiben
        1. 7.3.2.1 Überschreiben privater Methoden
      3. 7.3.3 Erweitertes Verhalten durch Verkettung
      4. 7.3.4 Vererbung von Klassenmethoden
      5. 7.3.5 Vererbung und Instanzvariablen
      6. 7.3.6 Vererbung und Klassenvariablen
      7. 7.3.7 Vererbung von Konstanten
    4. 7.4 Erzeugen und Initialisieren von Objekten
      1. 7.4.1 new, allocate und initialize
      2. 7.4.2 Fabrikmethoden
      3. 7.4.3 dup, clone und initialize_copy
      4. 7.4.4 marshal_dump und marshal_load
      5. 7.4.5 Das Singleton-Muster
    5. 7.5 Module
      1. 7.5.1 Module als Namensräume
        1. 7.5.1.1 Verschachtelte Namensräume
      2. 7.5.2 Module als Mixins
      3. 7.5.3 Einbindbare Namensraummodule
    6. 7.6 Laden von Modulen
      1. 7.6.1 Der Load-Pfad
      2. 7.6.2 Geladenen Code ausführen
        1. 7.6.2.1 Umhülltes Laden
      3. 7.6.3 Module automatisch laden
    7. 7.7 Singleton-Methoden und die Eigenklasse
    8. 7.8 Methoden-Lookup
      1. 7.8.1 Lookup von Klassenmethoden
    9. 7.9 Lookup von Konstanten
  10. 8. Reflexion und Metaprogrammierung
    1. 8.1 Typen, Klassen und Module
      1. 8.1.1 Vorfahren und Module
      2. 8.1.2 Klassen und Module definieren
    2. 8.2 Strings und Blöcke auswerten
      1. 8.2.1 Bindungen und eval
      2. 8.2.2 instance_eval und class_eval
      3. 8.2.3 instance_exec und class_exec
    3. 8.3 Variablen und Konstanten
      1. 8.3.1 Variablen lesen, setzen und überprüfen
    4. 8.4 Methoden
      1. 8.4.1 Methoden auflisten und prüfen
      2. 8.4.2 Method-Objekte erhalten
      3. 8.4.3 Methoden aufrufen
      4. 8.4.4 Methoden definieren, ihre Definitionen aufheben und Aliase erstellen
      5. 8.4.5 Undefinierte Methoden behandeln
      6. 8.4.6 Die Methodensichtbarkeit setzen
    5. 8.5 Hooks
    6. 8.6 Tracing
    7. 8.7 ObjectSpace und GC
    8. 8.8 Benutzerdefinierte Kontrollstrukturen
      1. 8.8.1 Die Ausführung verzögern und wiederholen: after und every
      2. 8.8.2 Thread-Sicherheit mit synchronisierten Blöcken
    9. 8.9 Fehlende Methoden und fehlende Konstanten
      1. 8.9.1 Unicode-Codepunktkonstanten mit const_missing
      2. 8.9.2 Tracing von Methodenaufrufen mit method_missing
      3. 8.9.3 Synchronisierte Objekte durch Delegation
    10. 8.10 Methoden dynamisch erzeugen
      1. 8.10.1 Methoden mit class_eval definieren
      2. 8.10.2 Methoden mit define_method definieren
    11. 8.11 Alias-Verkettung
      1. 8.11.1 Das Laden von Dateien und die Definition von Klassen überwachen
      2. 8.11.2 Methodenverkettung zur Thread-Sicherheit
      3. 8.11.3 Methodenverkettung für Tracing
    12. 8.12 Domänenspezifische Sprachen
      1. 8.12.1 Einfache XML-Ausgabe mit method_missing
      2. 8.12.2 Validierte XML-Ausgabe durch Methodenerzeugung
  11. 9. Die Ruby-Plattform
    1. 9.1 Strings
      1. 9.1.1 Text bearbeiten
      2. 9.1.2 Packen und Entpacken binärer Strings
      3. 9.1.3 Strings und Kodierung
    2. 9.2 Reguläre Ausdrücke
      1. 9.2.1 Regexp-Literale
      2. 9.2.2 Regexp-Fabrikmethoden
      3. 9.2.3 Syntax regulärer Ausdrücke
      4. 9.2.4 Pattern Matching mit regulären Ausdrücken
        1. 9.2.4.1 Globale Variablen für Match-Daten
        2. 9.2.4.2 Pattern Matching mit Strings
        3. 9.2.4.3 Suchen und Ersetzen
        4. 9.2.4.4 Kodierung regulärer Ausdrücke
    3. 9.3 Zahlen und Berechnungen
      1. 9.3.1 Numerische Methoden
      2. 9.3.2 Das Modul Math
      3. 9.3.3 Dezimalarithmetik
      4. 9.3.4 Komplexe Zahlen
      5. 9.3.5 Rationale Zahlen
      6. 9.3.6 Vektoren und Matrizen
      7. 9.3.7 Zufallszahlen
    4. 9.4 Datums- und Uhrzeitwerte
    5. 9.5 Collections
      1. 9.5.1 Enumerierbare Objekte
        1. 9.5.1.1 Iterieren und Konvertieren von Collections
        2. 9.5.1.2 Enumeratoren und externe Iteratoren
        3. 9.5.1.3 Collections sortieren
        4. 9.5.1.4 Collections durchsuchen
        5. 9.5.1.5 Subcollections auswählen
        6. 9.5.1.6 Collections reduzieren
      2. 9.5.2 Arrays
        1. 9.5.2.1 Arrays erstellen
        2. 9.5.2.2 Array-Größe und Elemente
        3. 9.5.2.3 Array-Elemente verändern
      3. 9.5.2 Arrays iterieren, durchsuchen und sortieren
        1. 9.5.2.5 Array-Vergleich
        2. 9.5.2.6 Arrays als Stacks und Queues
        3. 9.5.2.7 Arrays als Mengen
        4. 9.5.2.8 Methoden für assoziative Arrays
        5. 9.5.2.9 Weitere Array-Methoden
      4. 9.5.3 Hashes
        1. 9.5.3.1 Hashes erzeugen
        2. 9.5.3.2 Hashes indexieren und Vorhandensein von Elementen prüfen
        3. 9.5.3.3 Schlüssel und Werte in einem Hash speichern
        4. 9.5.3.4 Hash-Einträge entfernen
        5. 9.5.3.5 Arrays aus Hashes
        6. 9.5.3.6 Hash-Iteratoren
        7. 9.5.3.7 Standardwerte
        8. 9.5.3.8 Hashcodes, Schlüsselgleichheit und veränderbare Schlüssel
        9. 9.5.3.9 Verschiedene Hash-Methoden
      5. 9.5.4 Sets
        1. 9.5.4.1 Sets erstellen
        2. 9.5.4.2 Testen, vergleichen und kombinieren von Sets
        3. 9.5.4.3 Hinzufügen und Entfernen von Setelementen
        4. 9.5.4.4 Setiteratoren
        5. 9.5.4.5 Verschiedene Setmethoden
    6. 9.6 Dateien und Verzeichnisse
      1. 9.6.1 Datei- und Verzeichnisnamen
      2. 9.6.2 Verzeichnisinhalte
      3. 9.6.3 Dateien prüfen
      4. 9.6.4 Erzeugen, Löschen und Umbenennen von Dateien und Verzeichnissen
    7. 9.7 Ein-/Ausgabe
      1. 9.7.1 Streams öffnen
        1. 9.7.1.1 Dateien öffnen
        2. 9.7.1.2 Kernel.open
        3. 9.7.1.3 StringIO
        4. 9.7.1.4 Vordefinierte Streams
      2. 9.7.2 Streams und Kodierungen
      3. 9.7.3 Lesen aus einem Stream
        1. 9.7.3.1 Zeilen lesen
        2. 9.7.3.2 Ganze Dateien lesen
        3. 9.7.3.3 Bytes und Zeichen einlesen
      4. 9.7.4 In einen Stream schreiben
      5. 9.7.5 Methoden für freien Zugriff (Random Access)
      6. 9.7.6 Streams schließen, flushen und prüfen
    8. 9.8 Netzwerk-Handling
      1. 9.8.1 Ein sehr einfacher Client
      2. 9.8.2 Ein sehr einfacher Server
      3. 9.8.3 Datagramme
      4. 9.8.4 Ein komplexerer Client
      5. 9.8.5 Ein Multiplex-Server
      6. 9.8.6 Webseiten holen
    9. 9.9 Threads und Parallelität
      1. 9.9.1 Thread-Lebenszyklus
        1. 9.9.1.1 Der Haupt-Thread
        2. 9.9.1.2 Threads und unbehandelte Exceptions
      2. 9.9.2 Threads und Variablen
        1. 9.9.2.1 Thread-private Variablen
        2. 9.9.2.2 Thread-lokale Variablen
      3. 9.9.3 Thread Scheduling
        1. 9.9.3.1 Thread-Prioritäten
        2. 9.9.3.2 Thread-Präemptivität und Thread.pass
      4. 9.9.4 Thread-Zustände
        1. 9.9.4.1 Thread-Zustände abfragen
        2. 9.9.4.2 Zustand ändern: Pausieren, Aufwecken und Abschießen von Threads
      5. 9.9.5 Threads und Thread-Gruppen auflisten
      6. 9.9.6 Threading-Beispiele
        1. 9.9.6.1 Dateien parallel lesen
        2. 9.9.6.2 Ein Multithread-Server
        3. 9.9.6.3 Parallele Iteratoren
      7. 9.9.7 Thread Exclusion und Deadlock
        1. 9.9.7.1 Deadlock
      8. 9.9.8 Queue und SizedQueue
      9. 9.9.9 Bedingungsvariablen und Queues
  12. 10. Die Ruby-Umgebung
    1. 10.1 Den Ruby-Interpreter aufrufen
      1. 10.1.1 Gängige Optionen
      2. 10.1.2 Warnungen und Informationsoptionen
      3. 10.1.3 Kodierungs-Optionen
      4. 10.1.4 Textverarbeitungsoptionen
      5. 10.1.5 Weitere Optionen
    2. 10.2 Die Top-Level-Umgebung
      1. 10.2.1 Vordefinierte Module und Klassen
      2. 10.2.2 Top-Level-Konstanten
      3. 10.2.3 Globale Variablen
        1. 10.2.3.1 Globale Einstellungen
        2. 10.2.3.2 Globale Ausnahmebehandlung
        3. 10.2.3.3 Datenströme und globale Textverarbeitungsvariablen
        4. 10.2.3.4 Globale Mustervergleichsvariablen
        5. 10.2.3.5 Globale Kommandozeilenoptionsvariablen
      4. 10.2.4 Vordefinierte globale Funktionen
      5. 10.2.4.1 Schlüsselwortfunktionen
        1. 10.2.4.2 Texteingabe-, -ausgabe-, und -manipulationsfunktionen
        2. 10.2.4.3 Betriebssystemmethoden
        3. 10.2.4.4 Warnungen, Fehler und Programmabbrüche
        4. 10.2.4.5 Reflexionsfunktionen
        5. 10.2.4.6 Konvertierungsfunktionen
        6. 10.2.4.7 Sonstige Kernel-Funktionen
      6. 10.2.5 Benutzerdefinierte globale Funktionen
    3. 10.3 »Practical Extraction and Report«-Arbeitserleichterungen
      1. 10.3.1 Eingabefunktionen
      2. 10.3.2 Veraltete Extraktionsfunktionen
      3. 10.3.3 Reportfunktionen
      4. 10.3.4 Einzeilige Skriptabkürzungen
    4. 10.4 Das Betriebssystem aufrufen
      1. 10.4.1 Betriebssystemkommandos aufrufen
      2. 10.4.2 Forking und Prozesse
      3. 10.4.3 Signale abfangen
      4. 10.4.4 Programme beenden
    5. 10.5 Sicherheit
      1. 10.5.1 Taint-Daten
      2. 10.5.2 Eingeschränkte Ausführung und Sicherheitsstufen
        1. 10.5.2.1 Sicherheitsstufe 0
        2. 10.5.2.2 Sicherheitsstufe 1
        3. 10.5.2.3 Sicherheitsstufe 2
        4. 10.5.2.4 Sicherheitsstufe 3
        5. 10.5.2.5 Sicherheitsstufe 4
  13. Impressum