JavaScript Design Patterns

Table of contents

1. JavaScript Design Patterns
2. Contributors
3. About the author
4. About the reviewers
5. Preface
   1. Who this book is for
   2. What this book covers
   3. To get the most out of this book
   4. Download the example code files
   5. Conventions used
   6. Get in touch
   7. Share Your Thoughts
   8. Download a free PDF copy of this book
6. Part 1:Design Patterns
7. Chapter 1: Working with Creational Design Patterns
   1. What are creational design patterns?
   2. Implementing the prototype pattern in JavaScript
      1. Implementation
      2. A use case
   3. The singleton pattern with eager and lazy initialization in JavaScript
      1. Implementation
      2. Use cases
      3. Improvements with the “class singleton” pattern
      4. A singleton without class fields using ES module behavior
   4. The factory pattern in JavaScript
      1. Implementation
      2. Use cases
      3. Improvements with modern JavaScript
   5. Summary
8. Chapter 2: Implementing Structural Design Patterns
   1. Technical requirements
   2. What are structural design patterns?
   3. Implementing the Proxy pattern with Proxy and Reflect
      1. A redaction proxy implementation
      2. Use cases
      3. Improving the proxy pattern in JavaScript with the Proxy and Reflect global objects
   4. Decorator in JavaScript
      1. Implementation
      2. Use cases
      3. Improvements/limitations
   5. Flyweight in JavaScript
      1. Implementation
      2. Use cases
      3. Improvements/limitations
   6. Adapter in JavaScript
      1. Use cases
      2. Improvements/limitations
   7. Summary
9. Chapter 3: Leveraging Behavioral Design Patterns
   1. Technical requirements
   2. What are behavioral design patterns?
   3. The observer pattern in JavaScript
      1. Implementation
      2. Use cases of the observer pattern
      3. Limitations and improvements
   4. State and strategy in JavaScript and a simplified approach
      1. Implementation
      2. Use cases of the state and strategy patterns
      3. Limitations and improvements
   5. Visitor in JavaScript
      1. Implementation
      2. Use cases of the visitor pattern
   6. Summary
10. Part 2:Architecture and UI Patterns
11. Chapter 4: Exploring Reactive View Library Patterns
    1. Technical requirements
    2. What are reactive view library patterns?
    3. The render prop pattern
       1. Use cases
       2. Implementation/example
       3. Limitations
    4. The higher-order component pattern
       1. Implementation/example
       2. Use cases
       3. Limitations
    5. The hooks pattern
       1. An implementation/example
       2. Use cases
       3. Limitations
    6. The provider pattern
       1. Use case – the prop drilling problem
       2. An implementation/example
       3. Limitations
    7. Summary
12. Chapter 5: Rendering Strategies and Page Hydration
    1. Technical requirements
    2. Client and server rendering with React
       1. Client-side rendering in React
       2. Server rendering in React
       3. Trade-offs between client and server rendering
    3. Static rendering with Next.js
    4. Automatic static generation
    5. Static generation with a third-party data source
    6. Static generation with dynamic paths
    7. Page hydration strategies
       1. Common React rehydration issues
       2. React streaming server-side rendering
    8. Summary
13. Chapter 6: Micro Frontends, Zones, and Islands Architectures
    1. Technical requirements
    2. An overview of micro frontends
       1. Key benefits
       2. “Classic” micro frontend patterns
       3. Other concerns in a micro frontend world
    3. Composing applications with Next.js “zones”
       1. Root app
       2. Adding a /search app
       3. Adding /checkout app
       4. The benefits/supporting team scaling
       5. The drawbacks of Next.js zones
    4. Scaling performance-sensitive pages with the “islands” architecture
       1. Islands setup with is-land
       2. Product island
       3. Cart island
       4. A related products island
       5. Scaling with a team – bundling islands
       6. Drawbacks
    5. Summary
14. Part 3:Performance and Security Patterns
15. Chapter 7: Asynchronous Programming Performance Patterns
    1. Technical requirements
    2. Controlling sequential asynchronous operations with async/await and Promises
    3. Parallel asynchronous operation patterns
    4. Asynchronous cancellation and timeouts with AbortController
    5. Throttling, debouncing, and batching asynchronous operations
    6. Summary
16. Chapter 8: Event-Driven Programming Patterns
    1. Technical requirements
    2. Optimizing event listeners through event delegation
    3. Patterns for secure frame/native WebView bridge messaging
    4. Event listener performance antipatterns
    5. Summary
17. Chapter 9: Maximizing Performance – Lazy Loading and Code Splitting
    1. Technical requirements
    2. Dynamic imports and code splitting with Vite
    3. Route-based code splitting and bundling
    4. Loading JavaScript on element visibility and interaction
    5. Summary
18. Chapter 10: Asset Loading Strategies and Executing Code off the Main Thread
    1. Technical requirements
    2. Asset loading optimization – async, defer, preconnect, preload, and prefetch
    3. Using Next.js Script’s strategy option to optimize asset loading
    4. Loading and running scripts in a worker thread
    5. Summary
19. Index
    1. Why subscribe?
20. Other Books You May Enjoy
    1. Packt is searching for authors like you
    2. Download a free PDF copy of this book