Next:
Impressum
Javascript
1
Impressum
2
Die Geschichte von JavaScript
2.1
Die Entstehung
2.2
Der Browser-Krieg und die Standardisierung
2.3
Die dunkle Zeit und die Renaissance
2.4
Die moderne Ära: ECMAScript 6 und darüber hinaus
2.5
JavaScript heute
3
ECMAScript: Sprachstandards und Versionen
3.1
Die Standardisierung durch ECMA International
3.2
Entwicklung der ECMAScript-Versionen
3.2.1
ECMAScript 1, 2 und 3 (1997-1999)
3.2.2
ECMAScript 4 und die Kontroverse
3.2.3
ECMAScript 5 (2009)
3.2.4
ECMAScript 5.1 (2011)
3.2.5
ECMAScript 6 / ES2015
3.2.6
Jährliche Releases seit 2016
3.3
Der Standardisierungsprozess
3.4
Implementierungsstatus und Browser-Kompatibilität
3.5
ECMAScript und die JavaScript-Ökosysteme
3.6
Zukunft von ECMAScript
4
Entwicklungsumgebungen und Tools
4.1
Code-Editoren und IDEs
4.1.1
Visual Studio Code
4.1.2
WebStorm und andere JetBrains IDEs
4.2
Browser Developer Tools
4.2.1
Inspektion und DOM-Manipulation
4.2.2
JavaScript-Debugging
4.2.3
Netzwerk-Analyse
4.2.4
Performance-Profiling
4.3
Node.js-Entwicklungstools
4.3.1
Node.js-Runtime
4.3.2
NPM und Yarn
4.3.3
Nodemon
4.4
Build-Tools und Bundler
4.4.1
Webpack
4.4.2
Vite und Snowpack
4.4.3
Babel
4.5
Lint- und Formatierungstools
4.5.1
ESLint
4.5.2
Prettier
4.6
Testing-Tools
4.6.1
Jest
4.6.2
Mocha, Chai und Sinon
4.7
Continuous Integration und Deployment
4.8
Integrierte Entwicklungsumgebungen (Workspaces)
4.9
Debugger und Performance-Tools
4.9.1
Node.js-Debugger
4.9.2
Memory-Profiler
4.10
Auswahl der richtigen Tools
5
Der Browser als Laufzeitumgebung
5.1
JavaScript-Engines
5.2
Browser-Objektmodell (BOM)
5.2.1
Window-Objekt
5.2.2
Location-Objekt
5.2.3
History-Objekt
5.2.4
Navigator-Objekt
5.3
Document Object Model (DOM)
5.3.1
DOM-Struktur
5.3.2
DOM-Navigation
5.3.3
DOM-Manipulation
5.3.4
DOM-Elementauswahl
5.4
Event-Handling
5.4.1
Event-Listener hinzufügen und entfernen
5.4.2
Event-Objekt
5.4.3
Event-Propagation: Bubbling und Capturing
5.4.4
Event-Delegation
5.5
Web APIs
5.5.1
Fetch API
5.5.2
Web Storage API
5.5.3
Weitere wichtige Web APIs
5.6
Sicherheitsmodell des Browsers
5.6.1
Same-Origin-Policy (SOP)
5.6.2
Cross-Origin Resource Sharing (CORS)
5.6.3
Content Security Policy (CSP)
5.7
Rendering und Performance
5.7.1
Kritischer Rendering-Pfad
5.7.2
Reflow und Repaint
5.7.3
requestAnimationFrame
5.8
Offline-Fähigkeit und Progressive Web Apps
5.8.1
Service Workers
6
Sprachkonzepte
6.1
Variablen, Datentypen und Typkonvertierung
6.1.1
Variablendeklaration
6.1.2
Primitive Datentypen
6.1.3
Dynamische Typisierung
6.1.4
Referenztypen
6.1.5
Typüberprüfung
6.1.6
Typkonvertierung (Type Coercion)
6.1.7
Truthy und Falsy Werte
6.1.8
Best Practices bei der Arbeit mit Typen
7
Operatoren und Ausdrücke
7.1
Arithmetische Operatoren
7.1.1
Zuweisungsoperatoren
7.2
Vergleichsoperatoren
7.3
Logische Operatoren
7.4
Nullish Coalescing Operator (??)
7.5
Optional Chaining Operator (?.)
7.6
Bitweise Operatoren
7.7
Bedingter (Ternärer) Operator
7.8
Komma-Operator
7.9
Vorrang und Assoziativität von Operatoren
7.10
Ausdrücke in JavaScript
7.10.1
Arithmetische Ausdrücke
7.10.2
Zeichenkettenausdrücke
7.10.3
Logische Ausdrücke
7.10.4
Primärausdrücke
7.10.5
Funktionsausdrücke
7.10.6
Objekt- und Array-Ausdrücke
7.10.7
Destrukturierungsausdrücke (ES6)
7.10.8
Yield-Ausdrücke (ES6 Generatoren)
7.11
Nebeneffekte in Ausdrücken
8
Kontrollstrukturen und Schleifen
8.1
Bedingte Anweisungen
8.1.1
if-Anweisung
8.1.2
if-else-Anweisung
8.1.3
if-else if-else-Kette
8.1.4
Geschachtelte if-Anweisungen
8.1.5
Bedingte (ternäre) Operatoren
8.1.6
switch-Anweisung
8.2
Schleifen
8.2.1
for-Schleife
8.2.2
for…in-Schleife
8.2.3
for…of-Schleife (ES6)
8.2.4
Vergleich: for…in vs. for…of
8.2.5
while-Schleife
8.2.6
do…while-Schleife
8.3
Schleifensteuerung
8.3.1
break-Anweisung
8.3.2
continue-Anweisung
8.3.3
Labeled Statements
8.4
Moderne Alternativen zu Schleifen
8.4.1
Array.prototype.forEach()
8.4.2
Array.prototype.map()
8.4.3
Array.prototype.filter()
8.4.4
Array.prototype.reduce()
8.4.5
Array.prototype.find() und findIndex()
8.4.6
Array.prototype.some() und every()
8.5
Performancebetrachtungen
8.6
Typische Anwendungsmuster
8.6.1
Iteration über Arrays
8.6.2
Iteration über Objekte
8.6.3
Iteration über Maps und Sets (ES6)
8.7
Asynchrone Iterationen (ES2018)
8.8
Beste Praktiken
9
Funktionen, Scopes und Closures
9.1
Funktionsarten und Parameter
9.1.1
Funktionsdeklaration
9.1.2
Funktionsausdruck
9.1.3
Pfeilfunktionen (ES6)
9.1.4
Weitere Funktionsformen
9.2
Parameter und Argumente
9.2.1
Grundlegende Parameter
9.2.2
Standardparameter (ES6)
9.2.3
Rest-Parameter (ES6)
9.2.4
Destrukturierung in Parametern
9.3
Lexikalisches Scoping
9.3.1
Arten von Scopes
9.3.2
Function-Scope vs. Block-Scope
9.3.3
Scope-Hierarchie
9.3.4
Variable Hoisting
9.4
Closures
9.4.1
Grundkonzept
9.4.2
Praktische Anwendungen
9.4.3
Häufige Fehler mit Closures
9.5
Das this-Keyword
9.5.1
Grundregeln für this
9.5.2
Lexikalisches this mit Pfeilfunktionen
9.6
Funktionale Programmierung mit Funktionen höherer Ordnung
9.6.1
Funktionen höherer Ordnung
9.6.2
Reine Funktionen (Pure Functions)
9.6.3
Funktionskomposition
10
Funktionsarten und Parameter
10.1
Funktionsdeklaration
10.2
Funktionsausdruck
10.3
Pfeilfunktionen
10.4
Methodensyntax in Objektliteralen
10.5
Generatorfunktionen
10.6
Async-Funktionen
10.7
Funktionsparameter
10.7.1
Grundlegende Parameter
10.7.2
Das arguments-Objekt
10.7.3
Standardparameter (ES6)
10.7.4
Rest-Parameter (ES6)
10.7.5
Destrukturierung in Parametern (ES6)
10.8
Beste Praktiken
11
Eingebaute Funktionen und Methoden
11.1
Globale Funktionen
11.1.1
Parsing und Typkonvertierung
11.1.2
URI-Kodierung
11.2
String-Methoden
11.2.1
Suche und Extraktion
11.2.2
Transformation und Formatierung
11.3
Array-Methoden
11.3.1
Nicht-mutierende Methoden
11.3.2
Mutierende Methoden
11.4
Object-Methoden
11.5
Math-Objekt
11.6
Date-Objekt
11.7
JSON-Methoden
11.8
Console-Methoden
11.9
Fehlerbehandlung mit eingebauten Funktionen
11.10
Performance-Überlegungen
11.11
Best Practices für eingebaute Funktionen
12
Lexikalisches Scoping
12.1
Grundlagen des Scoping
12.2
Globaler Scope
12.3
Function-Scope vs. Block-Scope
12.3.1
Function-Scope mit var
12.3.2
Block-Scope mit let und const
12.4
Scope-Hierarchie und Verschachtelung
12.5
Variablenschatten (Variable Shadowing)
12.6
Lexikalisches this
12.7
Variable Hoisting
12.7.1
Hoisting mit var
12.7.2
Hoisting mit let und const
12.7.3
Funktions-Hoisting
12.8
Praktische Auswirkungen des lexikalischen Scoping
12.8.1
Closures
12.8.2
Module und Kapselung
12.8.3
Vermeidung von Namenskonflikten
12.9
Beste Praktiken
13
Closures und Anwendungsmuster
13.1
Das Grundprinzip von Closures
13.2
Wie Closures funktionieren
13.3
Anwendungsmuster für Closures
13.3.1
Datenprivatsheit und Kapselung
13.3.2
Funktionsfabriken
13.3.3
Callback-Konfiguration
13.3.4
Memoization (Caching von Funktionsergebnissen)
13.3.5
Iteratoren und Generatoren erstellen
13.3.6
Zustandserhaltung zwischen Aufrufen
13.3.7
Currying und partielle Anwendung
13.3.8
Module-Muster (vor ES6)
13.4
Häufige Fallstricke bei Closures
13.4.1
Schleifenvariablen in Closures (vor ES6)
13.4.2
Speicherlecks
13.4.3
Performance-Überlegungen
13.5
Fortgeschrittene Anwendungsmuster
13.5.1
Funktionales Programmieren mit Closures
13.5.2
Lazy Evaluation (verzögerte Auswertung)
13.5.3
Dekoratoren-Muster
13.5.4
Datenanalyse mit Closures
13.6
Closures in modernem JavaScript
14
Prototypenbasierte Objektorientierung
14.0.1
Grundkonzept: Objekte und Prototypen
14.0.2
Die Prototypen-Kette
14.0.3
Constructor-Funktionen und new-Operator
14.0.4
Prototypische Vererbung
14.0.5
Das prototype Property vs. [[Prototype]]
14.0.6
Eigenschaftsbeschreibungen und Object.defineProperty()
14.0.7
Moderne Prototyp-Manipulation
15
Klassen und Vererbung (ES6+)
15.1
Klassendefinition und -instanziierung
15.2
Unter der Haube: Klassen und Prototypen
15.3
Vererbung mit extends
15.4
Das super-Schlüsselwort
15.5
Wichtige Besonderheiten von Klassen
15.6
Private Felder und Methoden
15.7
Statische Initialisierungsblöcke
15.8
Klassenausdrücke
15.9
Getter und Setter
15.10
Vererbungshierarchien und Polymorphismus
15.11
Mixin-Muster mit Klassen
16
Module und Namensräume
16.1
Probleme ohne Module
16.2
Namensraum-Muster (Namespace Pattern)
16.3
Unmittelbar ausgeführte Funktionsausdrücke (IIFE)
16.4
Das Modul-Muster (Revealing Module Pattern)
16.5
CommonJS-Module
16.6
AMD-Module (Asynchronous Module Definition)
16.7
UMD (Universal Module Definition)
16.8
ES-Module (ECMAScript-Module)
16.9
Dynamischer Import
16.10
Namensräume in TypeScript
16.11
Module Bundling und Build-Tools
16.12
Best Practices für Module
17
Fortgeschrittene Konzepte
17.1
Asynchrones JavaScript
17.1.1
Das Problem der Synchronität
17.1.2
Callbacks: Der klassische Ansatz
17.1.3
Promises: Strukturierte asynchrone Programmierung
17.1.4
Async/Await: Synchroner Stil für asynchronen Code
17.1.5
Praktisches Beispiel: Datenabruf mit Fetch API
18
Callbacks und Event-basierte Programmierung
18.1
Grundkonzept von Callbacks
18.2
Callbacks in realen Anwendungsfällen
18.2.1
AJAX mit XMLHttpRequest
18.2.2
Node.js Dateisystem-Operationen
18.3
Error-First Callbacks: Eine Konvention
18.4
Die Problematik verschachtelter Callbacks
18.5
Strategien zur Verbesserung des Callback-Codes
18.5.1
Separierung in benannte Funktionen
18.5.2
Control Flow Bibliotheken
18.6
Event-basierte Programmierung
18.6.1
DOM-Events
18.6.2
Das EventEmitter-Pattern
18.6.3
Events und Callbacks im Browser: Ein Beispiel mit XMLHttpRequest
18.7
Best Practices für Callbacks und Event-Handler
18.7.1
Vermeidung tiefer Verschachtelung
18.7.2
Konsistente Fehlerbehandlung
18.7.3
Entkopplung und Modularität
18.7.4
Aufräumen
18.8
Übergang zu moderneren Ansätzen
19
Promises und Promise-Chaining
19.1
Grundkonzept von Promises
19.2
Anatomie eines Promise
19.3
Interaktion mit Promises: then(), catch() und finally()
19.4
Ein praktisches Beispiel: Datenabruf
19.5
Promise-Chaining: Verkettung asynchroner Operationen
19.6
Fehlerbehandlung in Promise-Ketten
19.6.1
Präzise Fehlerbehandlung
19.7
Parallele Ausführung mit Promise-Methoden
19.7.1
Promise.all() - Alle oder keiner
19.7.2
Promise.race() - Der Schnellste gewinnt
19.7.3
Promise.allSettled() (ES2020)
19.7.4
Promise.any() (ES2021)
19.8
Promise-Erstellung und -Transformation
19.8.1
Einfache Promise-Hilfsfunktionen
19.8.2
Umwandlung von Callback-basierten Funktionen zu Promises (Promisification)
19.9
Promise-Verschränkungen und fortgeschrittene Muster
19.9.1
Dynamisches Promise-Chaining
19.9.2
Paralleles Mapping mit Promises
19.9.3
Limitierung paralleler Anfragen
19.10
Timeout für Promises
19.11
Promises und Browser-APIs
19.12
Promise-basierte Redesigns älterer APIs
19.13
Promise-Anti-Patterns und häufige Fehler
19.13.1
Fehler 1: Vergessen der Fehlerbehandlung
19.13.2
Fehler 2: Promise-Hell (neue Form der Callback-Hölle)
19.13.3
Fehler 3: Nicht-Rückgabe von Promises in einer Kette
20
Async/Await
20.1
Grundkonzept von Async/Await
20.2
Vorteile gegenüber reinen Promises
20.3
Fehlerbehandlung mit try/catch
20.4
Umgang mit mehreren asynchronen Operationen
20.4.1
Sequentielle Ausführung
20.4.2
Parallele Ausführung
20.4.3
Kontrollierte parallele Ausführung
20.5
Async-Funktionen in verschiedenen Kontexten
20.6
Top-Level Await (ECMAScript 2022)
20.7
Praktische Beispiele für Async/Await
20.7.1
Beispiel 1: Daten laden und verarbeiten
20.7.2
Beispiel 2: Bedingte asynchrone Logik
20.7.3
Beispiel 3: Wiederholungslogik (Retry Logic)
20.8
Fortgeschrittene Techniken mit Async/Await
20.8.1
Abbruch von asynchronen Operationen mit AbortController
20.8.2
Asynchrone Iteratoren
20.8.3
Asynchrone Funktionen als Event-Handler
20.9
Häufige Fallstricke bei Async/Await
20.9.1
Fallstrick 1: Vergessen des await-Schlüsselworts
20.9.2
Fallstrick 2: Unbeabsichtigte sequentielle Ausführung
20.9.3
Fallstrick 3: Async-Funktionen in for-Schleifen
20.9.4
Fallstrick 4: Fehlerbehandlung außerhalb des try/catch-Blocks
20.10
Async/Await in verschiedenen Umgebungen
20.10.1
Browser-Umgebung
20.10.2
Node.js-Umgebung
21
Event Loop und Concurrency-Modell
21.1
Die Single-Thread-Natur von JavaScript
21.2
Komponenten des JavaScript-Laufzeitsystems
21.3
Der Call Stack
21.4
Web APIs und Callback Queue
21.5
Der Event Loop: Das Herzstück des Concurrency-Modells
21.6
Macrotasks und Microtasks
21.7
Visualisierung des Event Loop
21.8
Blockierende Operationen und deren Auswirkungen
21.8.1
Strategien zur Vermeidung von Blockierungen
21.9
Der Event Loop in verschiedenen Umgebungen
21.9.1
Browser
21.9.2
Node.js
21.10
process.nextTick() in Node.js
21.11
Praktische Beispiele des Event Loops
21.11.1
Beispiel 1: UI-Aktualisierung und Datenverarbeitung
21.11.2
Beispiel 2: Parallele API-Anfragen mit Timeout
21.12
Fortgeschrittene Techniken: Priorisierung asynchroner Operationen
21.13
Auswirkungen des Event Loop auf Debugging
21.14
Concurrency und Parallelismus in JavaScript
21.15
Das mentale Modell: Effektives Denken über den Event Loop
22
Funktionale Programmierung in JavaScript
22.1
Grundprinzipien der funktionalen Programmierung
22.1.1
Pure Funktionen
22.1.2
Unveränderlichkeit (Immutability)
22.1.3
Funktionen höherer Ordnung
22.1.4
Deklarativer vs. imperativer Stil
22.2
Funktionale Programmierkonzepte in JavaScript
22.2.1
First-Class Functions
22.2.2
Closures
22.2.3
Funktionskomposition
22.2.4
Pipe
22.2.5
Currying
22.2.6
Partielle Anwendung
22.3
Funktionale Arrays und Objekte in JavaScript
22.3.1
Array-Methoden
22.3.2
Arbeiten mit Objekten
22.4
Unveränderliche (Immutable) Datenstrukturen
22.4.1
Unveränderliche Updates für Arrays
22.4.2
Unveränderliche Updates für Objekte
22.5
Fortgeschrittene funktionale Konzepte
22.5.1
Lazy Evaluation mit Generatoren
22.5.2
Monaden
22.5.3
Funktionales Error-Handling mit Either
22.6
Praktische Beispiele für funktionale Programmierung
22.6.1
Beispiel 1: Datenverarbeitung
22.6.2
Beispiel 2: Asynchrone Operationen mit funktionalem Ansatz
22.6.3
Beispiel 3: Event Handling mit funktionalem Ansatz
22.7
Funktionale Programmierung mit modernen JavaScript-Features
22.7.1
Optional Chaining und Nullish Coalescing
22.7.2
Destructuring und Spread-Operator
22.8
Vor- und Nachteile der funktionalen Programmierung
22.8.1
Vorteile
22.8.2
Nachteile
22.9
Funktionale Bibliotheken für JavaScript
23
Arrow Functions und lexikalisches this
23.1
Grundlagen der Arrow Functions
23.1.1
Syntax
23.1.2
Vereinfachungen für spezielle Fälle
23.2
Lexikalisches
this
23.2.1
this
in regulären Funktionen
23.2.2
this
in Arrow Functions
23.3
Praktische Anwendungen von Arrow Functions und lexikalischem this
23.3.1
Callbacks ohne Bindungsprobleme
23.3.2
Event-Handler in Klassen
23.3.3
Funktionale Operationen mit Array-Methoden
23.3.4
Sofort ausgeführte Arrow Functions (IIFE)
23.4
Einschränkungen von Arrow Functions
23.4.1
Kein eigener
this
-Kontext
23.4.2
Kein
arguments
-Objekt
23.4.3
Kann nicht als Konstruktor verwendet werden
23.4.4
Kein
super
-Zugriff
23.4.5
Keine
yield
-Unterstützung
23.5
Best Practices
23.5.1
Wann Arrow Functions verwenden?
23.5.2
Wann reguläre Funktionen verwenden?
23.6
Fortgeschrittene Muster mit Arrow Functions
23.6.1
Partielle Anwendung und Currying
23.6.2
Funktionskomposition
23.6.3
Tagged Template Literals mit Arrow Functions
23.7
Arrow Functions in asynchronem Code
23.8
Lexikalisches
this
und Klassenproperties
23.9
Performance-Überlegungen
24
Generatoren und Iteratoren
24.1
Iteratoren
24.1.1
Das Iteration Protocol
24.1.2
Integrierte Iterables
24.1.3
Benutzerdefinierte Iterables
24.2
Generatoren
24.2.1
Grundlagen der Generator-Funktionen
24.2.2
Werte an Generatoren übergeben
24.2.3
Generatoren als Iteratoren
24.2.4
Delegieren von Generatoren
24.3
Praktische Anwendungen
24.3.1
Unendliche Sequenzen
24.3.2
Durchlaufen von Baumstrukturen
24.3.3
Paging und Lazy Loading
24.4
Asynchrone Generatoren und Iteratoren
24.4.1
Asynchrone Iteratoren
24.4.2
Asynchrone Generatoren
24.5
Fortgeschrittene Muster mit Generatoren
24.5.1
Zustandsmaschinen mit Generatoren
24.5.2
Coroutinen mit Generatoren
24.5.3
Asynchroner Kontrollfluss mit Generatoren
24.6
Optimierung und Leistungsüberlegungen
24.6.1
Lazy Evaluation
24.6.2
Speichermanagement
24.7
Iterators und Generators in der Praxis
24.7.1
Eigene Array-Methoden mit Generatoren
24.7.2
Generator-basierte Datastreams
25
Proxies und Reflections
25.1
Proxies
25.1.1
Grundlegende Syntax
25.1.2
Wichtige Fallstricke (Traps)
25.1.3
Beispiel 1: Einfacher Eigenschafts-Zugriff und -Zuweisung
25.1.4
Beispiel 2: Funktionsaufruf und Konstruktor
25.1.5
Beispiel 3: Privater Eigenschaftsschutz
25.2
Praktische Anwendungsfälle für Proxies
25.2.1
Datenvalidierung
25.2.2
Beobachtbare Objekte (Observable Objects)
25.2.3
Automatisches Logging
25.2.4
Verzögerte Initialisierung (Lazy Initialization)
25.3
Reflection
25.3.1
Hauptfunktionen des Reflect-Objekts
25.3.2
Reflect vs. entsprechende Object-Methoden
25.3.3
Beispiel: Reflect-API
25.4
Proxies und Reflect zusammen verwenden
25.5
Fortgeschrittene Anwendungen von Proxies und Reflect
25.5.1
Virtuelle Eigenschaften und berechnete Werte
25.5.2
Revocable Proxies
25.5.3
Objektverschmelzung mit tiefem Zugriff
25.5.4
Implementierung von Middleware-Patterns
25.6
Mögliche Fallstricke und Leistungsüberlegungen
26
Webarchitektur und DOM-Integration
26.1
Browser-Rendering und JavaScript-Ausführung
26.1.1
Der Rendering-Prozess im Browser
26.1.2
JavaScript-Ausführung im Browser
26.1.3
Critical Rendering Path und JavaScript
26.1.4
Timing und Performance
26.1.5
Browser-Ratengrenzwerte und RequestAnimationFrame
26.1.6
Interaktion zwischen JavaScript und Rendering
26.1.7
Web Workers für parallele Ausführung
27
DOM-Struktur und Navigation
27.1
Grundlegende DOM-Architektur
27.2
DOM-Schnittstellen und -Objekte
27.3
Navigation im DOM-Baum
27.3.1
Eltern-Kind-Beziehungen
27.3.2
Geschwister-Beziehungen
27.4
DOM-Selektoren und Elementsuche
27.4.1
Elementsuche nach ID, Klasse oder Tag
27.4.2
CSS-Selektor-basierte Suche
27.5
NodeList vs. HTMLCollection
27.6
Traversieren des DOM-Baums
27.7
Performanceaspekte bei der DOM-Navigation
27.8
Document Fragments
27.9
Shadow DOM und Kapselung
28
DOM-Manipulation und Events
28.1
Grundlegende DOM-Manipulation
28.1.1
Elemente erstellen
28.1.2
Attribute manipulieren
28.1.3
Elemente in den DOM einfügen
28.1.4
Elemente entfernen
28.2
Inhalte modifizieren
28.3
Styling mit JavaScript
28.4
Das Event-System
28.4.1
Grundlegende Event-Registrierung
28.4.2
Event-Objekt und Eigenschaften
28.4.3
Event-Delegation
28.4.4
Event-Phasen: Capturing und Bubbling
28.4.5
Custom Events
28.5
Häufige Event-Typen
28.5.1
UI-Events
28.5.2
Maus- und Touch-Events
28.5.3
Keyboard-Events
28.5.4
Formular-Events
28.6
Fortgeschrittene Techniken
28.6.1
IntersectionObserver für Scrolleffekte
28.6.2
MutationObserver für DOM-Änderungen
28.6.3
ResizeObserver für Elementgrößenänderungen
28.7
Performanceoptimierung bei Events
29
Browser Storage APIs
29.1
Cookies: Der traditionelle Ansatz
29.2
Web Storage: sessionStorage und localStorage
29.2.1
sessionStorage
29.2.2
localStorage
29.3
IndexedDB: Für komplexe Datenspeicherung
29.4
Cache API: Für Ressourcen-Caching
29.5
Web Storage API: Fallstricke und Best Practices
29.6
FileSystem Access API: Direkter Zugriff auf Dateisystem
29.7
Sicherheitsaspekte
29.8
Strategien für die Datenverwaltung
30
Testing Grundlagen
30.1
Was ist Software-Testing?
30.1.1
Warum ist Testing wichtig?
30.2
Arten von Tests
30.2.1
Unit Tests
30.2.2
Integration Tests
30.2.3
End-to-End Tests
30.3
Test-Driven Development (TDD)
30.4
Testing-Konzepte und Terminologie
30.4.1
Assertions
30.4.2
Test Fixtures
30.4.3
Mocking und Stubbing
30.5
Test-Organisation und Best Practices
30.5.1
Test-Struktur
30.5.2
Test-Isolation
30.5.3
Aussagekräftige Testnamen
30.6
Code Coverage
31
Unit Testing mit Jest und Mocha
31.1
Jest: Das All-in-One Testing Framework
31.1.1
Jest Setup und Grundkonfiguration
31.1.2
Grundlegende Jest-Syntax
31.1.3
Jest Matchers
31.1.4
Mocking in Jest
31.1.5
Jest Lifecycle-Hooks
31.2
Mocha: Das flexible Testing-Framework
31.2.1
Mocha Setup und Konfiguration
31.2.2
Mocha mit Chai für Assertions
31.2.3
Chai Assertion-Stile
31.2.4
Mocking mit Sinon
31.2.5
Sinon Spies, Stubs und Mocks
31.3
Jest vs. Mocha: Vergleich und Entscheidungshilfe
31.3.1
Jest Vorteile
31.3.2
Mocha Vorteile
31.4
Performance und Best Practices
31.4.1
Test-Performance optimieren
31.4.2
Debugging-Tipps
32
Integration Tests
32.1
Was sind Integration Tests?
32.1.1
Abgrenzung zu anderen Testarten
32.2
Arten von Integration Tests
32.2.1
Komponenten-Integration
32.2.2
API-Integration Tests
32.2.3
Datenbank-Integration Tests
32.3
Integration Test Patterns
32.3.1
Test Data Builder Pattern
32.3.2
Container Testing Pattern
32.4
Herausforderungen und Best Practices
32.4.1
Test-Isolation und Cleanup
32.4.2
Performance-Optimierung
32.4.3
Fehlerbehandlung und Debugging
32.5
Testing-Tools für Integration Tests
32.5.1
Supertest für HTTP-Integration Tests
33
End-to-End Tests mit Cypress
33.1
Was sind End-to-End Tests?
33.1.1
Einordnung in die Testpyramide
33.2
Cypress: Ein modernes E2E-Framework
33.2.1
Cypress-Architektur
33.2.2
Installation und Setup
33.2.3
Grundkonfiguration
33.3
Grundlegende Cypress-Syntax
33.3.1
Elementauswahl und Interaktion
33.3.2
Formular-Testing
33.3.3
Navigation und Routing
33.4
Erweiterte Cypress-Funktionen
33.4.1
API-Interception und Mocking
33.4.2
Custom Commands
33.4.3
Datei-Upload und Download
33.5
E2E Test Patterns
33.5.1
Page Object Model
33.5.2
Test Data Management
33.6
Performance und Wartung
33.6.1
Test-Performance optimieren
33.6.2
Stabilität und Flaky Tests vermeiden
33.7
Debugging und Troubleshooting
33.7.1
Debugging-Techniken
33.7.2
Error Handling
33.8
Cypress vs. andere E2E-Tools
33.8.1
Vergleich mit Selenium
33.9
CI/CD Integration
33.9.1
GitHub Actions mit Cypress
34
Test-Driven Development
34.1
Was ist Test-Driven Development?
34.1.1
Die TDD-Philosophie
34.2
Der Red-Green-Refactor Zyklus
34.2.1
Red: Fehlschlagenden Test schreiben
34.2.2
Green: Minimalen Code schreiben
34.2.3
Refactor: Code verbessern
34.3
TDD in der Praxis
34.3.1
Schritt-für-Schritt Entwicklung
34.3.2
TDD mit komplexeren Strukturen
34.4
TDD-Stile und Ansätze
34.4.1
Detroit School vs. London School
34.4.2
Outside-In vs. Inside-Out
34.5
TDD mit asynchronem Code
34.5.1
Promises und async/await
34.5.2
Event-driven Code
34.6
TDD Best Practices
34.6.1
FIRST Prinzipien für Tests
34.6.2
Aussagekräftige Testnamen
34.6.3
Test-Granularität
34.7
Häufige TDD-Antipatterns
34.7.1
The Liar
34.7.2
Excessive Setup
34.7.3
Test für Implementation statt Verhalten
34.8
TDD in verschiedenen Kontexten
34.8.1
Frontend TDD mit React
34.8.2
Backend TDD mit Node.js
34.9
Vorteile und Herausforderungen
34.9.1
Vorteile von TDD
34.9.2
Herausforderungen
34.10
TDD-Tools und Integration
34.10.1
TDD mit verschiedenen Test-Frameworks
34.10.2
Continuous Testing