O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

Geheimnisse eines JavaScript-Ninjas

Book Description

  • Bewährte Methoden bei der Entwicklung einer JavaScript-Bibliothek
  • Anspruchsvolle Features von JavaScript
  • Ausführliche Beschreibung browserübergreifender Programmierung
Das Web ist heute ohne JavaScript undenkbar, doch seit der Entstehung dieser Scriptsprache hat sich einiges getan. Dieses Buch stellt moderne JavaScript-Konzepte vor, die für alle Webentwickler von Nutzen sind, die Ajax und JavaScript-Bibliotheken für interaktive Webseiten einsetzen.Der JavaScript-Experte John Resig, Autor der bekannten jQuery-Bibliothek, vermittelt im Buch das Insiderwissen der besten JavaScript-Programmierer. Das Buch richtet sich an fortgeschrittene Anfänger und weist dem Leser den Weg zur Programmierung moderner JavaScript-Anwendungen in drei Stufen: Entwurf, Entwicklung sowie Pflege und Wartung des Codes.Zunächst wird die Grundlage fortgeschrittenen JavaScript-Wissens gelegt. Danach lernt der Leser den Aufbau einer JavaScript-Bibliothek kennen: Hier werden die vielfältigen Aufgaben erläutert sowie Entwicklungsstrategien und Lösungsansätze aus der Praxis vorgestellt. Und natürlich werden auch die Vorgehensweisen zur Erstellung zukunftssicheren Codes thematisiert.Das Buch versetzt den Leser in die Lage, ausgezeichnete JavaScript-Anwendungen zu programmieren, eigene Bibliotheken zu schreiben und die verfügbaren JavaScript-Bibliotheken optimal zu verwenden.
    Aus dem Inhalt:
  • Assertionen und Debugging
  • Funktionen und Objekte
  • Closures
  • Objektorientierung und Prototypen
  • Reguläre Ausdrücke
  • Umgang mit Threads und Timern
  • Codeauswertung zur Laufzeit
  • Die with-Anweisung
  • Cross-Browser-Strategien
  • Attribute, Eigenschaften und CSS
  • Umgang mit Ereignissen
  • Manipulation des DOMs
  • CSS-Selector-Engines
  • Anwendungen und Bibliotheken aus der richtigen Perspektive betrachtet
  • Modernes JavaScript-Design
  • Problemlösungen für die browserübergreifende Entwicklung

Table of Contents

  1. Impressum
  2. Vorwort
  3. Einleitung
  4. Teil I: Trainingsvorbereitungen
  5. Kapitel 1: Werden Sie ein JavaScript-Ninja
    1. 1.1 Die verwendeten JavaScript-Bibliotheken​
    2. 1.2 JavaScript​ verstehen
    3. 1.3 Überlegungen zur browserübergreifenden Programmierung​
    4. 1.4 Best Practices​
      1. 1.4.1 Best Practice​: Assertionen​
      2. 1.4.2 Best Practice​: Performance-Analysen​
    5. 1.5 Zusammenfassung
  6. Kapitel 2: Aufrüsten mit Assertionen und Debugging​​
    1. 2.1 Code-Debugging​
      1. 2.1.1 Logging​​
      2. 2.1.2 Breakpoints​​
    2. 2.2 Testerstellung
    3. 2.3 Test-Frameworks​​
      1. 2.3.1 QUnit​​
      2. 2.3.2 YUI Test​​​
      3. 2.3.3 JsUnit​​
      4. 2.3.4 Neuere Unit-Test-Frameworks
    4. 2.4 Die Grundpfeiler einer Testsuite​
      1. 2.4.1 Assertionen​
      2. 2.4.2 Testgruppen​
      3. 2.4.3 Asynchrones Testen​​
    5. 2.5 Zusammenfassung
  7. Teil II: Basistraining für angehende JavaScript-Ninjas
  8. Kapitel 3: Funktionen – Ein JavaScript-Kernkonzept​
    1. 3.1 Worin besteht der funktionale Unterschied​?
      1. 3.1.1 Warum ist der funktionale Charakter von JavaScript​ so bedeutsam?
      2. 3.1.2 Sortieren mit einer Vergleichsfunktio​n (Comparat​or)
    2. 3.2 Deklaratione​​n
      1. 3.2.1 Funktionen​ und Scopes​​
    3. 3.3 Funktionsaufrufe​​
      1. 3.3.1 Von Argumenten​ zu Funktionsparametern​​
      2. 3.3.2 Aufruf als Funktion​
      3. 3.3.3 Aufruf als Methode​
      4. 3.3.4 Aufruf als Konstruktor​
      5. 3.3.5 Aufruf mit den Methoden apply() und call()​​
    4. 3.4 Zusammenfassung
  9. Kapitel 4: Der Umgang mit Funktionen
    1. 4.1 Anonyme Funktionen​
    2. 4.2 Rekursion​​
      1. 4.2.1 Rekursion in benannten Funktionen​​
      2. 4.2.2 Rekursion mit Methoden​
      3. 4.2.3 Das Problem mit der »gestohlenen« Referenz​​
      4. 4.2.4 Benannte Inline-Funktionen​​
      5. 4.2.5 Die callee-Eigenschaft​
    3. 4.3 Programmierspaß mit Funktionen als Objekten​
      1. 4.3.1 Funktionen speichern​
      2. 4.3.2 Selbstmemoisierende Funktionen​​​
    4. 4.4 Argumentlisten variabler Länge​
      1. 4.4.1 Argumentlisten variabler Länge​ mit apply()​
      2. 4.4.2 Funktionsüberladung​
    5. 4.5 Auf Funktionen prüfen​
    6. 4.6 Zusammenfassung
  10. Kapitel 5: Der Umgang mit Closures​
    1. 5.1 Die Funktionsweise von Closures​
    2. 5.2 Closures​ verwenden
      1. 5.2.1 Private Variablen​
      2. 5.2.2 Callback​s und Tim​er
    3. 5.3 Funktionskontexte binden​
    4. 5.4 Partielle Funktionsanwendung​​
    5. 5.5 Funktionsverhalten überschreiben​
      1. 5.5.1 Memoisierung​
      2. 5.5.2 Funktions-Wrapping​
    6. 5.6 Direkte Funktione​n
      1. 5.6.1 Temporärer Scope​ und private Variablen​
      2. 5.6.2 Schleifen​
      3. 5.6.3 Library-Wrapping​
    7. 5.7 Zusammenfassung
  11. Kapitel 6: Objektorientierung und Prototypen​
    1. 6.1 Instanziierung und Prototypen​
      1. 6.1.1 Objektinstanziierung​
      2. 6.1.2 Objekttypisierung mittels Konstruktoren​​
      3. 6.1.3 Vererbung​ und die Prototypkette​
      4. 6.1.4 HTML-DOM-Prototypen​​
    2. 6.2 Häufige Fehler​​​
      1. 6.2.1 Erweiterungsobjekt​
      2. 6.2.2 Number-Erweiterung​
      3. 6.2.3 Subclassing nativer Objekte​​​
      4. 6.2.4 Instanziierungsprobleme​
    3. 6.3 Klassenähnlichen Code​ schreiben
      1. 6.3.1 Serialisierbarkeit von Funktione​​n prüfen
      2. 6.3.2 Unterklassen initialisieren​​
      3. 6.3.3 super-Methoden erhalten​
    4. 6.4 Zusammenfassung
  12. Kapitel 7: Programmentwicklung mit regulären Ausdrücken​
    1. 7.1 Die Vorzüge der regulären Ausdrücke​
    2. 7.2 Reguläre Ausdrücke​ – Übersicht
      1. 7.2.1 Was sind reguläre Ausdrücke​?
      2. 7.2.2 Terme​​ und Operatoren​​
    3. 7.3 Reguläre Ausdrücke kompilieren​
    4. 7.4 Übereinstimmende Teilbereiche »capturen​​«
      1. 7.4.1 Einfache Captures durchführen
      2. 7.4.2 Übereinstimmungssuche mit globalen Ausdrücken​​
      3. 7.4.3 Captures referenzieren​
      4. 7.4.4 Nicht zu erfassende Gruppen​
    5. 7.5 Ersetzen mit Funktionen​
    6. 7.6 Generelle Probleme mit regulären Ausdrücken lösen
      1. 7.6.1 Strings kürzen
      2. 7.6.2 Zeilenumbrüche finden​​
      3. 7.6.3 Unicode​
      4. 7.6.4 Maskierungszeichen​​
    7. 7.7 Zusammenfassung
  13. Kapitel 8: Der Umgang mit Threads und Timern​​
    1. 8.1 Die Arbeitsweise von Timern​ und Threads​
      1. 8.1.1 Timer​​ einrichten und deaktivieren
      2. 8.1.2 Timer-Ausführung​ innerhalb des Ausführungs-Threads
      3. 8.1.3 Unterschiede zwischen Timeouts​ und Intervallen​
    2. 8.2 Minimale Timer-Verzögerung​ und Zuverlässigkeit​
    3. 8.3 Der Umgang mit rechenintensiven Operationen​​
    4. 8.4 Zentrale Timer-Steuerung​
    5. 8.5 Asynchrones Testen​​
    6. 8.6 Zusammenfassung
  14. Teil III: Ninja-Training
  15. Kapitel 9: Ninja-Alchemie: Codeauswertung zur Laufzeit
    1. 9.1 Mechanismen zur Codeauswertung
      1. 9.1.1 Auswertung per eval()-Methode
      2. 9.1.2 Auswertung per Funktionskonstruktor
      3. 9.1.3 Auswertung mit Timern
      4. 9.1.4 Auswertung im globalen Scope
      5. 9.1.5 Sichere Codeauswertung
    2. 9.2 Funktionen dekompilieren​​
    3. 9.3 Codeauswertung in Aktion
      1. 9.3.1 JSON konvertieren​
      2. 9.3.2 Importieren von Code mit Namensraum
      3. 9.3.3 JavaScript komprimieren und verschleiern
      4. 9.3.4 Dynamisches Umschreiben von Code​
      5. 9.3.5 Aspektorientierte Skript-Tags
      6. 9.3.6 Metasprachen​ und DSLs
    4. 9.4 Zusammenfassung
  16. Kapitel 10: Die with-Anweisung​
    1. 10.1 Arbeitsweise der with-Anweisung
      1. 10.1.1 Referenzieren von Eigenschaften innerhalb eines with-Scopes​
      2. 10.1.2 Zuweisungen innerhalb eines with-Scopes
      3. 10.1.3 Überlegungen zur Ausführungsgeschwindigkeit
    2. 10.2 Praxisorientierte Beispiele
    3. 10.3 Importieren von Code mit Namensraum​
    4. 10.4 Testen
    5. 10.5 Templating mit with
    6. 10.6 Zusammenfassung
  17. Kapitel 11: Cross-Browser-Strategien
    1. 11.1 Auswahl der Browser
    2. 11.2 Die fünf wichtigsten Belange bei der Entwicklung
      1. 11.2.1 Browser-Bugs und Unterschiede zwischen den Browsern
      2. 11.2.2 Browser-Bug-Fixes
      3. 11.2.3 Koexistenz mit Auszeichnungssprachen und externem Code
      4. 11.2.4 Fehlende Features
      5. 11.2.5 Regressionen
    3. 11.3 Strategien zur Implementierung
      1. 11.3.1 Gefahrlose Cross-Browser-Korrekturen
      2. 11.3.2 Objekterkennung
      3. 11.3.3 Feature-Simulation
      4. 11.3.4 Nicht überprüfbare Browserprobleme
    4. 11.4 Anzahl der Annahmen reduzieren
    5. 11.5 Zusammenfassung
  18. Kapitel 12: Attribute, Eigenschaften und CSS
    1. 12.1 Attribute und Eigenschaften
      1. 12.1.1 Cross-Browser-Namensgebung
      2. 12.1.2 Beschränkungen bei der Namensgebung
      3. 12.1.3 Unterschiede zwischen XML und HTML
      4. 12.1.4 Verhalten benutzerdefinierter Attribute
      5. 12.1.5 Überlegungen zur Geschwindigkeit
    2. 12.2 Attribute und Cross-Browser-Probleme
      1. 12.2.1 Automatische Ergänzung von Namen und IDs im DOM
      2. 12.2.2 URL-Normalisierung
      3. 12.2.3 Das style-Attribut
      4. 12.2.4 Das type-Attribut
      5. 12.2.5 Das tabIndex-Problem
      6. 12.2.6 Knotennamen
    3. 12.3 Stilattribute
      1. 12.3.1 Wo sind die Stile?
      2. 12.3.2 Namensgebung bei Stileigenschaften​
      3. 12.3.3 Die Stileigenschaft float
      4. 12.3.4 Konvertierung von Pixelwerten​
      5. 12.3.5 Vermessung von Höhen und Breiten
      6. 12.3.6 Transparenzen durchschauen
      7. 12.3.7 Farben
    4. 12.4 Abfrage berechneter Stile
    5. 12.5 Zusammenfassung
  19. Teil IV: Meister-Training
  20. Kapitel 13: Der Umgang mit Ereignissen
    1. 13.1 Anbindung von Event-Handlern und Lösen dieser Bindung
    2. 13.2 Das Event-Objekt​
    3. 13.3 Verwaltung mehrerer Handler
      1. 13.3.1 Zusammengehörige Informationen zentral speichern
      2. 13.3.2 Verwaltung von Event-Handlern​
    4. 13.4 Ereignisse auslösen
      1. 13.4.1 Benutzerdefinierte Ereignisse​
    5. 13.5 Bubbling und Delegation​​
      1. 13.5.1 Ereignisse an übergeordnete Elemente delegieren
      2. 13.5.2 Umgehen von Browserdefizit​en
    6. 13.6 Das ready-Ereignis
    7. 13.7 Zusammenfassung
  21. Kapitel 14: Manipulation des DOMs
    1. 14.1 HTML-Injektion ins DOM​
      1. 14.1.1 Konvertierung von HTML-Code in eine DOM-Struktur
      2. 14.1.2 Einfügen ins Dokument
      3. 14.1.3 Skriptausführung​
    2. 14.2 Klonen von Elementen​​
    3. 14.3 Entfernen von Elementen​​
    4. 14.4 Textinhalte​​
      1. 14.4.1 Textzuweisungen​​
      2. 14.4.2 Auslesen des Textinhalts​​
    5. 14.5 Zusammenfassung
  22. Kapitel 15: CSS-Selector-Engines
    1. 15.1 Die W3C-Selektoren-API
    2. 15.2 XPath zur Suche von Elementen verwenden
    3. 15.3 Reine DOM-Implementierung
      1. 15.3.1 Parsen des Selektors
      2. 15.3.2 Elemente suchen
      3. 15.3.3 Filtern​
      4. 15.3.4 Rekursion und Zusammensetzen
      5. 15.3.5 Bottom-Up-Selector-Engi​ne
    4. 15.4 Zusammenfassung