JavaScript sprechen
Homepage
Das Buch kaufen
(Werbung, bitte nicht blockieren.)

Inhaltsverzeichnis

  1. Lob für JavaScript sprechen
  2. Vorwort
    1. Was Sie über dieses Buch wissen müssen
    2. Tipps zum Lesen dieses Buches
      1. Die vier Teile dieses Buches
      2. JavaScript-Befehlszeilen
      3. Notationelle Konventionen
        1. Beschreibung der Syntax
        2. Verweis auf Methoden
        3. Befehlszeileninteraktion
        4. Tipps, Notizen und Warnungen
      4. Schnelles Finden von Dokumentation
    3. Safari® Books Online
    4. So kontaktieren Sie uns
    5. Danksagungen
      1. Vorbereitung auf JavaScript
      2. Hilfe bei JavaScript
      3. Rezensenten
  3. I. JavaScript Schnellstart
    1. 1. Grundlegendes JavaScript
      1. Hintergrund
        1. JavaScript im Vergleich zu ECMAScript
        2. Einflüsse und Natur der Sprache
      2. Syntax
        1. Überblick über die Syntax
        2. Anweisungen im Vergleich zu Ausdrücken
        3. Semikolons
        4. Kommentare
      3. Variablen und Zuweisung
        1. Zuweisung
        2. Verbundzuweisungsoperatoren
        3. Bezeichner und Variablennamen
      4. Werte
        1. Primitive Werte im Vergleich zu Objekten
        2. Primitive Werte
        3. Objekte
        4. undefined und null
        5. Kategorisierung von Werten mit typeof und instanceof
      5. Booleans
        1. Truthy und Falsy
        2. Binäre logische Operatoren
        3. Gleichheitsoperatoren
      6. Zahlen
      7. Operatoren
      8. Strings
        1. String-Operatoren
        2. String-Methoden
      9. Anweisungen
        1. Bedingte Anweisungen
        2. Schleifen
      10. Funktionen
        1. Funktionsdeklarationen werden hochgezogen
        2. Die spezielle Variable arguments
        3. Zu viele oder zu wenige Argumente
        4. Optionale Parameter
        5. Erzwingen einer Stellenzahl
        6. Argumente in ein Array konvertieren
      11. Ausnahmebehandlung
      12. Strikter Modus
      13. Variablengültigkeitsbereiche und Closures
        1. Variablen sind funktionsbezogen
        2. Variablen werden hochgezogen
        3. Closures
        4. Das IIFE-Muster: Einführung eines neuen Geltungsbereichs
      14. Objekte und Konstruktoren
        1. Einzelne Objekte
        2. Beliebige Eigenschaftsschlüssel
        3. Methoden extrahieren
        4. Funktionen innerhalb einer Methode
        5. Konstruktoren: Fabriken für Objekte
      15. Arrays
        1. Array-Literale
        2. Array-Methoden
        3. Iterieren über Arrays
      16. Reguläre Ausdrücke
        1. Methode test(): Gibt es eine Übereinstimmung?
        2. Methode exec(): Übereinstimmung und Erfassungsgruppen
        3. Methode replace(): Suchen und Ersetzen
      17. Math
      18. Weitere Funktionalität der Standardbibliothek
  4. II. Hintergrund
    1. 2. Warum JavaScript?
      1. Ist JavaScript frei verfügbar?
      2. Ist JavaScript elegant?
      3. Ist JavaScript nützlich?
        1. Grafische Benutzeroberflächen
        2. Andere Technologien, die JavaScript ergänzen
      4. Verfügt JavaScript über gute Werkzeuge?
      5. Ist JavaScript schnell genug?
      6. Wird JavaScript häufig verwendet?
      7. Hat JavaScript eine Zukunft?
      8. Schlussfolgerung
    2. 3. Die Natur von JavaScript
      1. Eigenheiten und unkonventionelle Merkmale
      2. Elegante Teile
      3. Einflüsse
    3. 4. Wie JavaScript entstanden ist
    4. 5. Standardisierung: ECMAScript
    5. 6. Historische Meilensteine von JavaScript
  5. III. JavaScript im Detail
    1. 7. Die Syntax von JavaScript
      1. Überblick über die Syntax
      2. Kommentare
      3. Ausdrücke im Vergleich zu Anweisungen
        1. Ausdrücke
        2. Anweisungen
      4. Kontrollflussanweisungen und Blöcke
      5. Regeln für die Verwendung von Semikolons
        1. Kein Semikolon nach einer Anweisung, die mit einem Block endet
        2. Die leere Anweisung
        3. Automatische Semikolon-Einfügung
      6. Gültige Bezeichner
      7. Aufrufen von Methoden auf numerischen Literalen
      8. Strikter Modus
        1. Umschalten auf strikten Modus
        2. Strikter Modus: Empfohlen, mit Vorbehalten
        3. Variablen müssen im strikten Modus deklariert werden
        4. Funktionen im strikten Modus
        5. Das Setzen und Löschen von unveränderlichen Eigenschaften führt im strikten Modus zu einer Ausnahme
        6. Nicht qualifizierte Bezeichner können im strikten Modus nicht gelöscht werden
        7. eval() ist im strikten Modus sauberer
        8. Im strikten Modus verbotene Funktionen
    2. 8. Werte
      1. Das Typsystem von JavaScript
        1. Die Typen von JavaScript
        2. Statisch im Vergleich zu Dynamisch
        3. Statische Typisierung im Vergleich zu dynamischer Typisierung
        4. Statische Typprüfung im Vergleich zu dynamischer Typprüfung
        5. Koerzession
      2. Primitive Werte im Vergleich zu Objekten
      3. Primitive Werte
      4. Objekte
      5. undefined und null
        1. Vorkommen von undefined und null
        2. Prüfung auf undefined oder null
        3. Die Geschichte von undefined und null
        4. Änderung von undefined
      6. Wrapper-Objekte für primitive Werte
        1. Wrapper-Objekte unterscheiden sich von primitiven Werten
        2. Primitive Werte wrappen und unwrappen
        3. Primitive Werte leihen sich ihre Methoden von Wrappern
      7. Typ-Koerzession
        1. Typ-Koerzession kann Fehler verbergen
        2. Funktionen zur Konvertierung in Boolean, Number, String und Object
        3. Algorithmus: ToPrimitive()—Konvertieren eines Werts in einen primitiven Wert
    3. 9. Operatoren
      1. Operatoren und Objekte
      2. Zuweisungsoperatoren
        1. Verbundzuweisungsoperatoren
      3. Gleichheitsoperatoren: === im Vergleich zu ==
        1. Strikte Gleichheit (===, !==)
        2. Normale (lenient) Gleichheit (==, !=)
        3. Es gibt keine gültigen Anwendungsfälle für ==
      4. Ordnungsoperatoren
        1. Der Algorithmus
      5. Der Plus-Operator (+)
        1. Der Algorithmus
      6. Operatoren für Booleans und Zahlen
      7. Spezialoperatoren
        1. Der ternäre Operator ( ? : )
        2. Der Komma-Operator
        3. Der void-Operator
      8. Werte kategorisieren über typeof und instanceof
        1. typeof: Primitive kategorisieren
        2. instanceof: Prüfen, ob ein Objekt eine Instanz eines gegebenen Konstruktors ist
      9. Objektoperatoren
    4. 10. Booleans
      1. Konvertierung in Boolean
        1. Manuelle Konvertierung in Boolean
        2. Wahrheitsgemäße und falsche Werte
      2. Logische Operatoren
        1. Binäre logische Operatoren: Und (&&) und Oder (||)
        2. Logisches Und (&&)
        3. Logisches Oder (||)
        4. Logisches Nicht (!)
      3. Gleichheitsoperatoren, Ordnungsoperatoren
      4. Die Funktion Boolean
    5. 11. Zahlen
      1. Zahlenliterale
        1. Exponent
        2. Methodenaufrufe auf Literalen
      2. Konvertierung in Zahl
        1. Manuelle Konvertierung in Zahl
        2. parseFloat()
      3. Spezielle Zahlenwerte
        1. NaN
        2. Infinity
        3. Zwei Nullen
      4. Die interne Darstellung von Zahlen
        1. Spezielle Exponenten
      5. Umgang mit Rundungsfehlern
      6. Ganzzahlen in JavaScript
        1. Bereiche von Ganzzahlen
        2. Ganzzahlen als Gleitkommazahlen darstellen
        3. Sichere Ganzzahlen
      7. Konvertierung in Ganzzahl
        1. Ganzzahlen über Math.floor(), Math.ceil() und Math.round()
        2. Ganzzahlen über die benutzerdefinierte Funktion ToInteger()
        3. 32-Bit-Ganzzahlen über bitweise Operatoren
        4. Ganzzahlen über parseInt()
      8. Arithmetische Operatoren
      9. Bitweise Operatoren
        1. Hintergrundwissen
        2. Bitweises Nicht-Operator
        3. Binäre bitweise Operatoren
        4. Bitweise Shift-Operatoren
      10. Die Funktion Number
      11. Number-Konstruktor-Eigenschaften
      12. Number-Prototyp-Methoden
        1. Number.prototype.toFixed(fractionDigits?)
        2. Number.prototype.toPrecision(precision?)
        3. Number.prototype.toString(radix?)
        4. Number.prototype.toExponential(fractionDigits?)
      13. Funktionen für Zahlen
      14. Quellen für dieses Kapitel
    6. 12. Strings
      1. String-Literale
      2. Escaping in String-Literalen
      3. Zeichenzugriff
      4. Konvertierung in String
        1. Manuelle Konvertierung in String
      5. Strings vergleichen
      6. Strings verketten
        1. Verkettung: Der Plus-Operator (+)
        2. Verkettung: Zusammenfügen eines Arrays von String-Fragmenten
      7. Die Funktion String
      8. String-Konstruktor-Methode
      9. String-Instanz-Eigenschaft length
      10. String-Prototyp-Methoden
        1. Teilstrings extrahieren
        2. Transformieren
        3. Suchen und Vergleichen
        4. Testen, Abgleichen und Ersetzen mit regulären Ausdrücken
    7. 13. Anweisungen
      1. Variablen deklarieren und zuweisen
      2. Die Körper von Schleifen und bedingten Anweisungen
      3. Schleifen
        1. Mechanismen zur Verwendung mit Schleifen
        2. while
        3. do-while
        4. for
        5. for-in
        6. for each-in
      4. Bedingte Anweisungen
        1. if-then-else
        2. switch
      5. Die with-Anweisung
        1. Syntax und Semantik
        2. Die with-Anweisung ist veraltet
        3. Die Begründung für die Veralterung
      6. Die debugger-Anweisung
    8. 14. Ausnahmebehandlung
      1. Was ist Ausnahmebehandlung?
      2. Ausnahmebehandlung in JavaScript
        1. throw
        2. try-catch-finally
        3. Beispiele
      3. Error-Konstruktoren
      4. Stack-Traces
      5. Implementierung eines eigenen Error-Konstruktors
    9. 15. Funktionen
      1. Die drei Rollen von Funktionen in JavaScript
      2. Terminologie: „Parameter“ im Vergleich zu „Argument“
      3. Funktionen definieren
        1. Funktionsausdrücke
        2. Funktionsdeklarationen
        3. Der Function-Konstruktor
      4. Hoisting
      5. Der Name einer Funktion
      6. Was ist besser: Eine Funktionsdeklaration oder ein Funktionsausdruck?
      7. Mehr Kontrolle über Funktionsaufrufe: call(), apply() und bind()
        1. func.apply(thisValue, argArray)
        2. func.bind(thisValue, arg1, ..., argN)
      8. Umgang mit fehlenden oder zusätzlichen Parametern
        1. Alle Parameter nach Index: Die spezielle Variable arguments
        2. Obligatorische Parameter, Erzwingen einer Mindestanzahl von Argumenten
        3. Optionale Parameter
        4. Simulation von Parameterübergabe per Referenz
        5. Fallstrick: Unerwartete optionale Parameter
      9. Benannte Parameter
        1. Benannte Parameter als Beschreibungen
        2. Optionale benannte Parameter
        3. Simulation von benannten Parametern in JavaScript
    10. 16. Variablen: Gültigkeitsbereiche, Umgebungen und Closures
      1. Eine Variable deklarieren
      2. Hintergrund: Statisch im Vergleich zu dynamisch
      3. Hintergrund: Der Geltungsbereich einer Variable
      4. Variablen sind funktionsbezogen
      5. Variablendeklarationen werden hochgezogen
      6. Einführung eines neuen Geltungsbereichs über eine IIFE
        1. IIFE-Variante: Präfixoperatoren
        2. IIFE-Variante: Bereits im Ausdruckskontext
        3. IIFE-Variante: Eine IIFE mit Parametern
        4. IIFE-Anwendungen
      7. Globale Variablen
        1. Bewährte Methode: Vermeiden Sie die Erstellung globaler Variablen
        2. Modulsysteme führen zu weniger globalen Variablen
      8. Das globale Objekt
        1. Plattformübergreifende Überlegungen
        2. Anwendungsfälle für window
      9. Umgebungen: Variablen verwalten
      10. Closures: Funktionen bleiben mit ihren Erzeugungs-Geltungsbereichen verbunden
        1. Closures über Umgebungen verwalten
        2. Fallstrick: Unbeabsichtigtes Teilen einer Umgebung
    11. 17. Objekte und Vererbung
      1. Ebene 1: Einzelne Objekte
        1. Arten von Eigenschaften
        2. Objektliterale
        3. Punktoperator (.): Zugriff auf Eigenschaften über feste Schlüssel
        4. Ungewöhnliche Eigenschaftsschlüssel
        5. Klammeroperator ([]): Zugriff auf Eigenschaften über berechnete Schlüssel
      2. Jeden Wert in ein Objekt konvertieren
      3. this als impliziter Parameter von Funktionen und Methoden
        1. Funktionen aufrufen, während this gesetzt wird: call(), apply() und bind()
        2. apply() für Konstruktoren
        3. Fallstrick: this verlieren, wenn eine Methode extrahiert wird
        4. Fallstrick: Funktionen innerhalb von Methoden überschatten this
      4. Ebene 2: Die Prototyp-Beziehung zwischen Objekten
        1. Vererbung
        2. Überschreiben
        3. Daten zwischen Objekten über einen Prototyp teilen
        4. Prototyp abrufen und setzen
        5. Die spezielle Eigenschaft __proto__
        6. Das Setzen und Löschen wirkt sich nur auf eigene Eigenschaften aus
      5. Iterieren und Erkennen von Eigenschaften
        1. Eigene Eigenschaftsschlüssel auflisten
        2. Alle Eigenschaftsschlüssel auflisten
        3. Prüfen, ob eine Eigenschaft existiert
        4. Beispiele
      6. Bewährte Methoden: Iterieren über eigene Eigenschaften
      7. Accessors (Getter und Setter)
        1. Accessors über ein Objektliteral definieren
        2. Accessors über Eigenschaftsdeskriptoren definieren
        3. Accessors und Vererbung
      8. Eigenschaftsattribute und Eigenschaftsdeskriptoren
        1. Eigenschaftsattribute
        2. Eigenschaftsdeskriptoren
        3. Eigenschaften über Deskriptoren abrufen und definieren
        4. Ein Objekt kopieren
        5. Eigenschaften: Definition im Vergleich zu Zuweisung
        6. Vererbte schreibgeschützte Eigenschaften können nicht zugewiesen werden
        7. Aufzählbarkeit: Bewährte Methoden
      9. Objekte schützen
        1. Erweiterungen verhindern
        2. Sealing
        3. Freezing
        4. Fallstrick: Schutz ist flach
      10. Ebene 3: Konstruktoren—Fabriken für Instanzen
        1. Der new-Operator, implementiert in JavaScript
        2. Terminologie: Die beiden Prototypen
        3. Die constructor-Eigenschaft von Instanzen
        4. Der instanceof-Operator
        5. Tipps zur Implementierung von Konstruktoren
      11. Daten in Prototyp-Eigenschaften
        1. Vermeiden Sie Prototyp-Eigenschaften mit Anfangswerten für Instanz-Eigenschaften
        2. Vermeiden Sie nicht-polymorphe Prototyp-Eigenschaften
        3. Polymorphe Prototyp-Eigenschaften
      12. Daten privat halten
        1. Private Daten in der Umgebung eines Konstruktors (Crockford Privacy Pattern)
        2. Private Daten in Eigenschaften mit gekennzeichneten Schlüsseln
        3. Private Daten in Eigenschaften mit reifizierten Schlüsseln
        4. Globale Daten über IIFEs privat halten
      13. Ebene 4: Vererbung zwischen Konstruktoren
        1. Instanz-Eigenschaften erben
        2. Prototyp-Eigenschaften erben
        3. Sicherstellen, dass instanceof funktioniert
        4. Eine Methode überschreiben
        5. Einen Super-Aufruf tätigen
        6. Vermeiden Sie die hartcodierte Benennung des Super-Konstruktors
        7. Beispiel: Konstruktor-Vererbung in Aktion
        8. Beispiel: Die Vererbungshierarchie von integrierten Konstruktoren
        9. Antipattern: Der Prototyp ist eine Instanz des Super-Konstruktors
      14. Methoden aller Objekte
        1. Konvertierung in primitiven Wert
        2. Object.prototype.toLocaleString()
        3. Prototyp-Vererbung und Eigenschaften
      15. Generische Methoden: Methoden von Prototypen ausleihen
        1. Zugriff auf Object.prototype und Array.prototype über Literale
        2. Beispiele für das Aufrufen von Methoden generisch
        3. Array-ähnliche Objekte und generische Methoden
        4. Eine Liste aller generischen Methoden
      16. Fallstricke: Ein Objekt als Map verwenden
        1. Fallstrick 1: Vererbung beeinflusst das Lesen von Eigenschaften
        2. Fallstrick 2: Überschreiben beeinflusst das Aufrufen von Methoden
        3. Fallstrick 3: Die spezielle Eigenschaft __proto__
        4. Das dict-Muster: Objekte ohne Prototypen sind bessere Maps
        5. Bewährte Methoden
      17. Spickzettel: Arbeiten mit Objekten
    12. 18. Arrays
      1. Übersicht
        1. Arrays sind Maps, keine Tupel
        2. Arrays können auch Eigenschaften haben
      2. Arrays erstellen
        1. Der Array-Konstruktor
        2. Mehrdimensionale Arrays
      3. Array-Indizes
        1. Der in-Operator und Indizes
        2. Array-Elemente löschen
        3. Array-Indizes im Detail
      4. length
        1. Die Länge eines Arrays manuell erhöhen
        2. Die Länge eines Arrays verringern
        3. Die maximale Länge
      5. Löcher in Arrays
        1. Löcher erzeugen
        2. Sparse Arrays im Vergleich zu dichten Arrays
        3. Welche Operationen ignorieren Löcher und welche berücksichtigen sie?
        4. Löcher aus Arrays entfernen
      6. Array-Konstruktor-Methode
      7. Array-Prototyp-Methoden
      8. Elemente hinzufügen und entfernen (destruktiv)
      9. Elemente sortieren und umkehren (destruktiv)
        1. Zahlen vergleichen
        2. Strings vergleichen
        3. Objekte vergleichen
      10. Verketten, Slicen, Zusammenfügen (nicht-destruktiv)
      11. Werte suchen (nicht-destruktiv)
      12. Iteration (nicht-destruktiv)
        1. Untersuchungsmethoden
        2. Transformationsmethoden
        3. Reduktionsmethoden
      13. Fallstrick: Array-ähnliche Objekte
      14. Bewährte Methoden: Iterieren über Arrays
    13. 19. Reguläre Ausdrücke
      1. Syntax regulärer Ausdrücke
        1. Atome: Allgemein
        2. Atome: Zeichenklassen
        3. Atome: Gruppen
        4. Quantifizierer
        5. Assertionen
        6. Disjunktion
      2. Unicode und reguläre Ausdrücke
      3. Einen regulären Ausdruck erstellen
        1. Literal im Vergleich zu Konstruktor
        2. Flags
        3. Instanz-Eigenschaften von regulären Ausdrücken
        4. Beispiele für das Erstellen von regulären Ausdrücken
      4. RegExp.prototype.test: Gibt es eine Übereinstimmung?
      5. String.prototype.search: An welchem Index gibt es eine Übereinstimmung?
      6. RegExp.prototype.exec: Erfassungsgruppen
        1. Erste Übereinstimmung (Flag /g nicht gesetzt)
        2. Alle Übereinstimmungen (Flag /g gesetzt)
      7. String.prototype.match: Erfassungsgruppen oder Rückgabe aller übereinstimmenden Teilstrings
      8. String.prototype.replace: Suchen und Ersetzen
        1. Ersetzung ist ein String
        2. Ersetzung ist eine Funktion
      9. Probleme mit dem Flag /g
      10. Tipps und Tricks
        1. Text quoten
        2. Fallstrick: Ohne Assertion (z. B. ^, $), ein regulärer Ausdruck wird überall gefunden
        3. Alles oder nichts abgleichen
        4. Lookbehind manuell implementieren
      11. Regulärer Ausdruck Spickzettel
    14. 20. Daten
      1. Der Date-Konstruktor
      2. Date-Konstruktor-Methoden
      3. Date-Prototyp-Methoden
        1. Zeit-Einheiten-Getter und -Setter
        2. Verschiedene Getter und Setter
        3. Ein Datum in einen String konvertieren
      4. Datumszeitformate
        1. Datumsformate (keine Zeit)
        2. Zeitformate (kein Datum)
        3. Datumszeitformate
      5. Zeitwerte: Daten als Millisekunden seit 1970-01-01
        1. Ein Datum in eine Zahl konvertieren
    15. 21. Math
      1. Math-Eigenschaften
      2. Numerische Funktionen
      3. Trigonometrische Funktionen
      4. Andere Funktionen
    16. 22. JSON
      1. Hintergrund
        1. Datenformat
        2. Geschichte
        3. Grammatik
      2. JSON.stringify(value, replacer?, space?)
        1. Von JSON.stringify() ignorierte Daten
        2. Die toJSON()-Methode
      3. JSON.parse(text, reviver?)
      4. Daten über Node-Besucher transformieren
        1. JSON.stringify()
        2. JSON.parse()
    17. 23. Standard-Globale Variablen
      1. Konstruktoren
      2. Error-Konstruktoren
      3. Nicht-Konstruktor-Funktionen
        1. Text kodieren und dekodieren
        2. Zahlen kategorisieren und parsen
      4. Dynamisches Auswerten von JavaScript-Code über eval() und new Function()
        1. Code mit eval() auswerten
        2. Code mit new Function() auswerten
        3. eval() im Vergleich zu new Function()
        4. Bewährte Methoden
        5. Schlussfolgerung
      5. Die Console API
        1. Wie standardisiert ist die Console API über Engines hinweg?
        2. Einfache Protokollierung
        3. Prüfen und Zählen
        4. Formatierte Protokollierung
        5. Profiling und Timing
      6. Namensräume und spezielle Werte
    18. 24. Unicode und JavaScript
      1. Unicode-Geschichte
      2. Wichtige Unicode-Konzepte
      3. Code Points
      4. Unicode-Kodierungen
      5. JavaScript-Quellcode und Unicode
        1. Quellcode intern
        2. Quellcode extern
      6. JavaScript-Strings und Unicode
        1. Escape-Sequenzen
        2. Verweis auf Astralebenen-Zeichen über Escapes
        3. Zeichen zählen
        4. Unicode-Normalisierung
      7. JavaScript-Reguläre Ausdrücke und Unicode
        1. Abgleich beliebiger Code-Einheiten und beliebiger Code Points
        2. Bibliotheken
        3. Empfohlene Lektüre und Quellennachweise für das Kapitel
    19. 25. Neu in ECMAScript 5
      1. Neue Funktionen
      2. Syntaktische Änderungen
      3. Neue Funktionalität in der Standardbibliothek
        1. Metaprogrammierung
        2. Neue Methoden
        3. JSON
      4. Tipps für die Arbeit mit älteren Browsern
  6. IV. Tipps, Werkzeuge und Bibliotheken
    1. 26. Ein Meta Code Style Guide
      1. Bestehende Style Guides
      2. Allgemeine Tipps
        1. Code sollte konsistent sein
        2. Code sollte leicht verständlich sein
      3. Allgemein anerkannte Best Practices
        1. Klammerstile
        2. Literale gegenüber Konstruktoren bevorzugen
        3. Nicht schlau sein
        4. Akzeptable Cleverness
      4. Umstrittene Regeln
        1. Syntax
        2. Variablen
        3. Objektorientierung
        4. Verschiedenes
      5. Schlussfolgerung
    2. 27. Sprachmechanismen für das Debugging
    3. 28. Unterklassen von integrierten Objekten
      1. Terminologie
      2. Hindernis 1: Instanzen mit internen Eigenschaften
        1. Workaround für Hindernis 1
        2. Vorbehalte
      3. Hindernis 2: Ein Konstruktor, der nicht als Funktion aufgerufen werden kann
        1. Workaround für Hindernis 2
      4. Eine weitere Lösung: Delegation
    4. 29. JSDoc: Generierung von API-Dokumentation
      1. Die Grundlagen von JSDoc
        1. Syntax
        2. Typen benennen
      2. Grundlegende Tags
      3. Dokumentation von Funktionen und Methoden
      4. Inline-Typinformationen („Inline-Doc-Kommentare“)
      5. Dokumentation von Variablen, Parametern und Instanz-Eigenschaften
      6. Klassen dokumentieren
        1. Eine Klasse über eine Konstruktor-Funktion definieren
        2. Eine Klasse über ein Objektliteral definieren
        3. Eine Klasse über ein Objektliteral mit einer @constructs-Methode definieren
        4. Unterklassenbildung
      7. Weitere nützliche Tags
    5. 30. Bibliotheken
      1. Shims im Vergleich zu Polyfills
      2. Vier Sprachbibliotheken
      3. Die ECMAScript Internationalization API
        1. Die ECMAScript Internationalization API, Edition 1
        2. Welche Art von Standard ist es?
        3. Wann kann ich es verwenden?
        4. Weiterführende Lektüre
      4. Verzeichnisse für JavaScript-Ressourcen
    6. 31. Modulsysteme und Paketmanager
      1. Modulsysteme
      2. Paketmanager
      3. Schnelle und einfache Module
    7. 32. Mehr Werkzeuge
    8. 33. Was als Nächstes tun?
  7. Index
  8. Über den Autor
  9. Kolophon
  10. Copyright