Index
A
- abstract classes, The Command Pattern
- Abstract Decorator class, Abstract Decorators-Abstract Decorators
- Abstract Factory pattern, Abstract Factories
- Adapter pattern
- Ajax-based jQuery application decoupled, Decoupling an Ajax-based jQuery application
- Alexander, Christopher, History of Design Patterns, What Are Proto-Patterns?
- Alman, Ben, Decoupling applications using Ben Alman’s Pub/Sub implementation, Immediately Invoked Function Expressions
- AMD (Asynchronous Module Definition), AMD-AMD Conclusions
- about, AMD, AMD Conclusions, AMD and CommonJS: Competing, but Equally Valid Standards
- benefits of, Why was AMD a better choice for writing modular JavaScript?
- CommonJS and AMD equally valid, AMD and CommonJS: Competing, but Equally Valid Standards
- CommonJS wrapping feature, Getting Started, UMD: AMD and CommonJS-Compatible Modules for Plug-ins
- decoupling applications, The Importance of Decoupling Applications
- define() method for module definition, Getting Started with Modules
- jQuery and, AMD Modules with jQuery
- related reading links, Why was AMD a better choice for writing modular JavaScript?, jQuery plug-ins that function in all environments
- require() method for module dependencies, Getting Started with Modules, Getting Started with Modules-Getting Started with Modules
- script loaders, A Note on Script Loaders, Why was AMD a better choice for writing modular JavaScript?
- Angular, React.js Design Patterns
- anonymous function self-invoked (see immediately invoked function expressions (IIFEs))
- anonymous modules, Getting Started with Modules
- anti-patterns, What Are Anti-Patterns?
- APIs
- application holotypes, Summary
- application structure in React
- applications decoupled in JavaScript, The Importance of Decoupling Applications, Advantages of Using Modules, Modular JavaScript Design Patterns
- architectural patterns
- Astro, Implementing Islands
- async/await patterns, async/await Patterns-Additional Practical Examples
- about async/await, async/await Patterns
- async function composition, async Function Composition
- async iteration, async Iteration
- async keyword, async/await Patterns
- asynchronous action, Asynchronous Programming Patterns, Asynchronous Programming
- await keyword, async/await Patterns
- decorator, async/await Decorator, Additional Practical Examples
- error handling, async Error Handling
- event handling, async Event Handling, Additional Practical Examples
- memoization, async Memoization
- parallelism, async Parallelism
- pipeline, async/await Pipeline
- practical examples
- catching the result, Additional Practical Examples
- decorator, async/await Decorator, Additional Practical Examples
- event handling, async Event Handling, Additional Practical Examples
- HTTP request, Additional Practical Examples
- multiple async executions, Additional Practical Examples
- multiple async executions in sequence, Additional Practical Examples
- reading file from filesystem, Additional Practical Examples
- retry on failure, async Retry, Additional Practical Examples
- writing file to filesystem, Additional Practical Examples
- preload plus async hack, Preload + the async Hack
- promises and callbacks versus, Asynchronous Programming
- retry on failure, async Retry, Additional Practical Examples
- sequential execution, async Sequential Execution
- Asynchronous Module Definition (see AMD)
- asynchronous programming patterns
- attributes of Models, Models
- await, async/await Patterns
B
- Babel for import aliasing, Other Best Practices
- BabelJS ES2015 guide, Modern JavaScript Syntax and Features
- Backbone, Modern MV* Patterns
- background tasks, Asynchronous Programming Patterns
- (see also asynchronous programming patterns)
- behavioral design patterns
- book web page, How to Contact Us
- books in a library example, Converting Code to Use the Flyweight Pattern-Converting Code to Use the Flyweight Pattern
- browsers
- background tasks, Asynchronous Programming Patterns
- (see also asynchronous programming patterns)
- Chrome
- classes supported, Classes with Constructors, Getters, and Setters
- CommonJS suitability, Is CommonJS Suitable for the Browser?
- CSS content-visibility support, Improvements in the Web Platform
- Facade listening to events across browsers, The Facade Pattern
- import and export supported, Advantages of Using Modules
- module scripts evaluated only once, Advantages of Using Modules
- new View without refresh, Templating
- preload optimization, Loading Prioritization
- script tags for modules, Modules with Imports and Exports
- bubbling versus capture in event detection, The Flyweight Pattern and the DOM
- bundle splitting, Bundle Splitting
- Burke, James, UMD: AMD and CommonJS-Compatible Modules for Plug-ins
C
- Calder, Paul, Flyweight
- call API between contexts and arguments, Namespace Injection
- callbacks, Asynchronous Programming
- capture versus bubbling in event detection, The Flyweight Pattern and the DOM
- Cascading Style Sheets (see CSS)
- categories of design patterns
- chat app with static import, Static Import
- checkboxes that are observable, The Observer Pattern-The Observer Pattern
- Cherry, Ben, Disadvantages
- Chisholm, Gary, The Flyweight Pattern and the DOM
- Chrome
- class keyword, Classes with Constructors, Getters, and Setters
- classes
- about, Classes with Constructors, Getters, and Setters-Classes with Constructors, Getters, and Setters
- abstract classes, The Command Pattern
- concrete classes, The Command Pattern
- Constructor pattern, The Constructor Pattern-Constructors with Prototypes
- design pattern classes table, Design Pattern Classes-Summary
- ES6 new syntax supported, Classes with Constructors, Getters, and Setters
- extends keyword, Classes with Constructors, Getters, and Setters
- (see also extends keyword for class inheritance)
- Facade pattern decoupling from code, The Facade Pattern
- JavaScript frameworks and libraries, Classes in JavaScript Frameworks
- method chaining, Subclassing
- Mixins extending, Mixins
- Module pattern, The Module Pattern-Modules with Modern Libraries
- modules versus, Classes with Constructors, Getters, and Setters
- MVC as set of classes to build UI, Smalltalk-80 MVC in JavaScript
- Prototype pattern inheritance versus, The Prototype Pattern
- public versus private, Classes with Constructors, Getters, and Setters
- React class components prior to Hooks, Class Components-Class Components
- Singleton pattern, The Singleton Pattern-State Management in React
- static keyword, Classes with Constructors, Getters, and Setters
- subclasses, Subclassing
- super keyword for parent class constructor, Classes with Constructors, Getters, and Setters
- superclasses, Subclassing
- click handling, The Flyweight Pattern and the DOM
- client-side rendering (CSR), Rendering Patterns, Client-Side Rendering
- code reuse promoted by Decorator pattern, The Decorator Pattern
- code-splitting patterns
- Command pattern, The Command Pattern-The Command Pattern
- CommonJS, CommonJS-Is CommonJS Suitable for the Browser?
- about, CommonJS, AMD and CommonJS: Competing, but Equally Valid Standards
- AMD and CommonJS equally valid, AMD and CommonJS: Competing, but Equally Valid Standards
- AMD supporting CommonJS wrapping feature, Getting Started, UMD: AMD and CommonJS-Compatible Modules for Plug-ins
- browser suitability, Is CommonJS Suitable for the Browser?
- consuming multiple dependencies, Getting Started
- decoupling applications, The Importance of Decoupling Applications
- exports free variable, Getting Started
- Node.js, CommonJS in Node.js
- related reading links, Is CommonJS Suitable for the Browser?
- require() function, Getting Started
- script loaders, A Note on Script Loaders
- component tree access to shared data, An Everyday Use Case for Design Patterns
- componentDidMount() method, Effect Hook
- componentDidUpdate() method, Effect Hook
- componentization, An Introduction to React
- componentWillUnmount() method, Effect Hook
- concrete classes, The Command Pattern
- constructor chaining, Subclassing
- Constructor pattern, The Constructor Pattern-Constructors with Prototypes
- constructor() method
- basic constructors, Basic Constructors
- constructors with prototypes, Constructors with Prototypes
- Decorating, The Decorator Pattern-The Decorator Pattern
- defining a class, Classes with Constructors, Getters, and Setters, Basic Constructors
- Factory pattern, The Factory Pattern-The Factory Pattern
- interface implementation in JavaScript, Interfaces
- Mixins, Mixins
- Modules, Modern Module Pattern with WeakMap
- Observer pattern, The Observer Pattern-The Observer Pattern
- Prototype pattern, The Prototype Pattern
- Publish/Subscribe implementation, An example Publish/Subscribe implementation
- Singletons, The Singleton Pattern-The Singleton Pattern, Managing the Extrinsic States
- constructors for classes, Classes with Constructors, Getters, and Setters-Classes with Constructors, Getters, and Setters
- containers in application structure, Containers
- Controllers between Models and Views, Controllers
- Core Web Vitals (CWV), Importance of Rendering Patterns
- Cornford, Richard, History
- coupling
- Create React App (CRA), Basic Concepts
- creational design patterns
- Crockford, Douglas, History
- Croll, Angus, Namespace Injection
- CSR (client-side rendering), Rendering Patterns, Client-Side Rendering
- CSS (Cascading Style Sheets)
- curl.js, A Note on Script Loaders, Getting Started with Modules
- curly braces ({ }) in object literal notation, Object Literals
- current time, UI notifications
- CWV (Core Web Vitals), Importance of Rendering Patterns
D
- Dangoor, Kevin, CommonJS
- data
- debugging via call stack, Examples
- Decorator pattern, The Decorator Pattern-Advantages and Disadvantages
- decorator pattern
- decoupling
- deep object extension namespacing pattern, Deep Object Extension-Deep Object Extension
- defer attribute, Advantages of Using Modules
- deferred dependencies via require() method, Getting Started with Modules
- define() method for AMD module definition, Getting Started with Modules
- dependencies
- CommonJS consuming multiple, Getting Started
- decoupling applications via modularity, The Importance of Decoupling Applications, Advantages of Using Modules, Modular JavaScript Design Patterns
- Dependency Declaration pattern, Dependency Declaration Pattern
- import and export declarations for modules, Modules with Imports and Exports-Modules with Imports and Exports
- MVC versus MVP versus MVVM, MVC Versus MVP Versus MVVM
- require() method for module dependencies, Getting Started with Modules, Getting Started with Modules-Getting Started with Modules
- Singleton hidden dependencies, The Singleton Pattern
- Dependency Declaration pattern, Dependency Declaration Pattern
- design patterns
- Design Patterns: Elements of Reusable Object-Oriented Software (Gamma, Helm, Johnson, and Vlissides)
- Diaz, Dustin, Pseudoclassical Decorators
- differential inheritance, The Prototype Pattern
- DOM
- DRY (Don’t Repeat Yourself), What Is a Pattern?
- duck punching, Duck punching “implements”
- duck-typing an interface, Interfaces
- “ducks” pattern, Redux
- dynamic imports, Dynamic Imports-Import on Visibility, Dynamic Import-Import on Visibility
- await keyword, Dynamic Imports
- Import on Interaction, Import on Interaction, Import on Interaction
- Import on Visibility, Import on Visibility, Import on Visibility
- import(url), Dynamic Imports
- loadable-components library, Loadable Components
- PRPL pattern, PRPL Pattern-PRPL Pattern
- React design pattern, Dynamic Import-Import on Visibility
- React.Suspense for, Dynamic Import
E
- ECMAScript
- edge rendering, Rendering Patterns
- Eleventy (11ty) + Preact, Implementing Islands
- ES2015+ syntax of JavaScript, Modern JavaScript Syntax and Features
- ES6 (see ES2015+ syntax of JavaScript)
- Event Aggregator pattern, The Mediator Pattern
- (see also Publish/Subscribe pattern)
- events
- async event handling, async Event Handling, Additional Practical Examples
- ECMAScript implementations event driven, Publish/Subscribe Implementations
- event bubbling, The Flyweight Pattern and the DOM
- event capture, The Flyweight Pattern and the DOM
- Facade listening to events across browsers, The Facade Pattern
- Flyweight pattern and the DOM, The Flyweight Pattern and the DOM-Example: Centralized Event Handling
- Mediator notifying of events in other objects, The Mediator Pattern
- Observer versus Mediator, The Mediator Pattern
- Observer versus Publish/Subscribe, Differences Between the Observer and Publish/Subscribe Pattern
- Publish/Subscribe as Event Aggregation, The Mediator Pattern
- Views and ViewModels, Recap: The View and the ViewModel
- export declarations for modules, Modules with Imports and Exports-Modules with Imports and Exports
- export free variable for CommonJS, Getting Started
- Express.js, Mediator/Middleware in Modern JavaScript
- extends keyword for class inheritance, Classes with Constructors, Getters, and Setters
F
- Facade pattern, The Facade Pattern-The Facade Pattern
- Factory pattern, The Factory Pattern-Abstract Factories
- filename extensions for modules versus scripts, Modules with Imports and Exports
- Flyweight pattern, Flyweight-Example: Centralized Event Handling
- about, Flyweight
- books in a library example, Converting Code to Use the Flyweight Pattern-Converting Code to Use the Flyweight Pattern
- converting code to use, Converting Code to Use the Flyweight Pattern-Converting Code to Use the Flyweight Pattern
- DOM and, The Flyweight Pattern and the DOM-Example: Centralized Event Handling
- duck punching for implementation, Duck punching “implements”
- Flyweight factory, Implementing Classical Flyweights, A Basic Factory
- implementing classical Flyweights, Implementing Classical Flyweights-Duck punching “implements”
- intrinsic and extrinsic states, Flyweights and Sharing Data
- sharing data and, Flyweights and Sharing Data
- using, Using Flyweights
- Fowler, Martin, Smalltalk-80 MVC, History, Conclusions
- Freeman, Eric, The Decorator Pattern
- function keyword decreased use, Classes with Constructors, Getters, and Setters
G
- Gamma, Erich, History of Design Patterns, What Are Anti-Patterns?, Background, The Singleton Pattern, The Prototype Pattern, The Observer Pattern, MVC, Smalltalk-80 MVC in JavaScript
- Gang of Four (GoF), History of Design Patterns
- (see also Design Patterns: Elements of Reusable Object-Oriented Software (Gamma, Helm, Johnson, and Vlissides))
- garbage collection (GC) and WeakMap keys, Modern Module Pattern with WeakMap
- Gatsby, Static Rendering
- get current time, UI notifications
- getters for classes, Classes with Constructors, Getters, and Setters-Classes with Constructors, Getters, and Setters
- global state in React state management, State Management in React
- globals component, Styled Components
- GoF (Gang of Four), History of Design Patterns
- (see also Design Patterns: Elements of Reusable Object-Oriented Software (Gamma, Helm, Johnson, and Vlissides))
- groups of Models, Models
H
- Hann, John, Getting Started with Modules, Is CommonJS Suitable for the Browser?
- Harmes, Ross, Pseudoclassical Decorators
- hash (#) prefix for private class fields, Classes with Constructors, Getters, and Setters
- Head First Design Patterns (Freeman et al.), The Decorator Pattern
- Heilmann, Christian, Writing a Pattern, The Revealing Module Pattern
- Helm, Richard, History of Design Patterns, What Are Anti-Patterns?, Background, The Singleton Pattern, The Prototype Pattern, The Observer Pattern, MVC, Smalltalk-80 MVC in JavaScript
- Higher Order Component pattern, Higher-Order Components-Higher-Order Components
- Higher-Order Components (HOCs), Higher-Order Components
- history
- Hooks (React Hooks), Hooks Pattern-Hooks
- about, Hooks Pattern
- advantages, Pros and Cons of Using Hooks-Pros and Cons of Using Hooks
- alternative to classes, Classes in JavaScript Frameworks, Hooks
- application structure, Hooks
- custom Hooks, Custom Hooks-Custom Hooks
- disadvantages, Pros and Cons of Using Hooks
- further information on Hooks, Additional Hooks Guidance
- Higher Order Components pattern similar results, Composing
- Mixins alternative, Advantages and Disadvantages
- useContext Hook, An Everyday Use Case for Design Patterns, Additional Hooks Guidance
- useEffect Hook, Effect Hook, Additional Hooks Guidance
- useReducer Hook, Additional Hooks Guidance
- useState Hook, State Hook, Additional Hooks Guidance
- HTTP request with async/await, Additional Practical Examples
- HTTP/1.0, HTTP/1.1, HTTP/2 comparison, PRPL Pattern
- Hugo, Implementing Islands
- hybrid rendering, Hybrid Rendering
- hydration, Basic Concepts
I
- immediately invoked function expressions (IIFEs)
- implements (Java keyword) via duck punching, Duck punching “implements”
- import aliasing, Other Best Practices
- import declarations for modules, Modules with Imports and Exports-Modules with Imports and Exports
- about import keyword, Static Import
- browser support for, Advantages of Using Modules
- defer attribute, Advantages of Using Modules
- dynamic imports, Dynamic Imports-Import on Visibility, Dynamic Import-Import on Visibility
- await keyword, Dynamic Imports
- Import on Interaction, Import on Interaction, Import on Interaction
- Import on Visibility, Import on Visibility, Import on Visibility
- import(url), Dynamic Imports
- loadable-components library, Loadable Components
- PRPL pattern, PRPL Pattern-PRPL Pattern
- React design pattern, Dynamic Import-Import on Visibility
- React.Suspense for, Dynamic Import
- module objects, Module Objects
- modules from remote sources, Modules Loaded from Remote Sources
- static imports, Static Imports, Static Import-Static Import
- Import on Interaction pattern, Import on Interaction, Import on Interaction
- Import on Visibility pattern, Import on Visibility, Import on Visibility
- incremental static regeneration (ISR), Rendering Patterns, Incremental Static Regeneration
- inheritance
- interfaces
- IntersectionObserver API detecting component visibility, Import on Visibility, Import on Visibility
- Ishikawa, Sara, History of Design Patterns
- Islands architecture, Islands Architecture-Pros and Cons
- isomorphic rendering, Implementing Islands
- ISR (see incremental static regeneration)
- iterating over an async iterable, async Iteration
J
- Java implements keyword via duck punching, Duck punching “implements”
- JavaScript
- about, Introduction to Design Patterns, Modern JavaScript Syntax and Features
- anti-patterns, What Are Anti-Patterns?, Anti-Patterns in JavaScript
- blocking versus nonblocking code, Asynchronous Programming
- duck punching Java keywords, Duck punching “implements”
- ECMAScript
- filename extensions for modules versus scripts, Modules with Imports and Exports
- Flyweights, Implementing Classical Flyweights
- interfaces, Interfaces, Interfaces
- modern syntax and features
- asynchronous programming, Asynchronous Programming Patterns
- classes in JavaScript frameworks, Classes in JavaScript Frameworks
- classes versus modules, Classes with Constructors, Getters, and Setters
- classes with constructors, getters, setters, Classes with Constructors, Getters, and Setters-Classes with Constructors, Getters, and Setters
- dynamic imports, Dynamic Imports-Import on Visibility, Dynamic Import-Import on Visibility
- ES2015+ syntax, Modern JavaScript Syntax and Features
- importing module dependencies and exporting module interfaces, Modules with Imports and Exports-Modules with Imports and Exports
- module advantages, Advantages of Using Modules
- module objects, Module Objects
- modules for decoupling applications, The Importance of Decoupling Applications, Advantages of Using Modules, Modular JavaScript Design Patterns
- modules loaded from remote sources, Modules Loaded from Remote Sources
- modules supported by Node.js and npm, Modules for the Server
- static imports, Static Imports
- unused modules eliminated, Advantages of Using Modules
- MV* pattern implementation, Modern MV* Patterns
- namespace support, Namespacing Patterns
- objects created directly, The Singleton Pattern
- privacy via function scope, Privacy
- script defer in head versus body, Loading Prioritization
- state versus Model state management, Models
- templating, Templating
- JavaScript Patterns (Stefanov), Automating Nested Namespacing, Conclusions
- Jekyll, Implementing Islands
- Johnson, Ralph, History of Design Patterns, What Are Anti-Patterns?, Background, The Singleton Pattern, The Prototype Pattern, The Observer Pattern, MVC, Smalltalk-80 MVC in JavaScript
- jQuery
- .js extension for scripts, Modules with Imports and Exports
- JSON as subset of object literal notation, Object Literal Notation
- JSX (JavaScript Syntax Extension), Basic Concepts
M
- MacBook example
- Maria.js, Smalltalk-80 MVC in JavaScript
- Marko, Implementing Islands
- Mediator pattern, The Mediator Pattern-Mediator Versus Facade
- Meenan, Pat, Preload in Chrome 95+
- memoization
- method chaining, Subclassing
- metrics of Core Web Vitals, Importance of Rendering Patterns
- Michaux, Peter, Smalltalk-80 MVC in JavaScript, Prefix Namespacing, Prefix Namespacing
- middleware callback mediator, Mediator/Middleware in Modern JavaScript
- Miller, Jason, Islands Architecture, Implementing Islands
- Mixin pattern, The Mixin Pattern-Advantages and Disadvantages
- .mjs extension for modules, Modules with Imports and Exports
- Model-View-Controller pattern (see MVC pattern)
- Model-View-Presenter pattern (see MVP pattern)
- Model-View-ViewModel pattern (see MVVM pattern)
- Models
- about, Models
- attributes, Models
- business data primarily, Models, Model
- groups of Models, Models
- information not behavior except validation, Model
- persistence, Models
- photo gallery application, Models
- state, Models
- triggers for changes in state, Recap: The View and the ViewModel
- Views, Models-Views, View
- modular design patterns
- Module pattern, The Module Pattern-Modules with Modern Libraries
- about, The Module Pattern
- advantages and disadvantages, Advantages
- description of Module pattern, The Module Pattern-Examples
- examples, Examples-Examples
- Facade pattern with, The Facade Pattern
- further reading, Disadvantages
- history, History
- object literals, Object Literals-Object Literals
- React and other modern libraries, Modules with Modern Libraries
- Revealing Module pattern from, Writing a Pattern
- variations
- WeakMap object, Modern Module Pattern with WeakMap
- modules
- advantages of using, Advantages of Using Modules, The Module Pattern
- AMD module format overview, AMD
- (see also AMD (Asynchronous Module Definition))
- anonymous modules, Getting Started with Modules
- classes versus, Classes with Constructors, Getters, and Setters
- decoupling applications, The Importance of Decoupling Applications, Advantages of Using Modules, Modular JavaScript Design Patterns
- defer attribute, Advantages of Using Modules
- importing dependencies and exporting interfaces, Modules with Imports and Exports-Modules with Imports and Exports
- loaded from remote sources, Modules Loaded from Remote Sources
- modular defined, Modular JavaScript Design Patterns
- (see also modular design patterns)
- module objects, Module Objects
- MVC facilitating modularization, What Does MVC Give Us?
- Node.js and npm support for, Modules for the Server
- unused modules eliminated, Advantages of Using Modules
- Murphey, Rebecca, Object Literals
- MV* patterns
- MVC (Model-View-Controller) pattern, MVC-Summary of MVC
- about, JavaScript MV* Patterns, MVC for JavaScript Developers
- benefits of, What Does MVC Give Us?
- class set perspective, Smalltalk-80 MVC in JavaScript
- decoupling Views from Models, What Does MVC Give Us?
- Models, Models
- MVP versus, Models, Views, and Presenters
- MVP versus MVVM versus, MVC Versus MVP Versus MVVM
- Smalltalk-80 MVC, MVC, Smalltalk-80 MVC
- ToDo list in vanilla JavaScript, Modern MV* Patterns
- MVP (Model-View-Presenter) pattern, MVP-MVP or MVC?
- about, JavaScript MV* Patterns, MVP
- MVC versus, Models, Views, and Presenters
- MVC versus MVVM versus, MVC Versus MVP Versus MVVM
- passive View, Models, Views, and Presenters
- Presenters, Models, Views, and Presenters
- Supervising Controller variation, Models, Views, and Presenters
- MVPM (Model-View PresentationModel), History
- MVVM (Model-View-ViewModel) pattern, MVVM-MVC Versus MVP Versus MVVM
P
- partial hydration, Rendering Patterns
- patlets, The “Pattern” Tests
- “A Pattern Language” (Alexander, Ishikawa, and Silverstein), History of Design Patterns
- patterns
- Patterns for Building JavaScript Websites key application characteristics, Summary
- Patterns of Enterprise Application (Fowler), Conclusions
- persistence of Models, Models
- photo gallery application, Models
- PINF, Getting Started with Modules
- pipelines
- plug-ins defined via AMD require, Getting Started with Modules
- Preact, React.js Design Patterns
- prefix namespacing, Prefix Namespacing
- preload browser optimization, Loading Prioritization
- PresentationModels, History
- Presenters in Views, Models, Views, and Presenters
- privacy
- JavaScript using function scope for, Privacy
- Module pattern variables or methods, Privacy
- WeakMap() returning object variables, Privacy
- private classes versus public, Classes with Constructors, Getters, and Setters
- Pro JavaScript Design Patterns (PJDP; Diaz and Harmes), Pseudoclassical Decorators
- progressive hydration, Rendering Patterns, Progressive Hydration
- Promise patterns, Promise Patterns-Promise Race
- about promises, Asynchronous Programming Patterns, Asynchronous Programming, Promise Patterns
- .all method, Promise Parallelism
- decorator applied to promises, Promise Decorator
- error handling, Asynchronous Programming, Promise Error Handling
- memoization, Promise Memoization
- network request example, Promise Patterns
- parallelism, Promise Parallelism
- pipeline of async transformations, Promise Pipeline
- promise chaining, Promise Chaining
- Promise constructor, Promise Patterns
- promises versus callbacks versus async, Asynchronous Programming
- race between two, Promise Race
- .resolve method, Promise Sequential Execution
- retrying on failure, Promise Retry
- sequential execution of, Promise Sequential Execution
- PropTypes with components, Other Best Practices
- proto-patterns
- Prototype pattern, The Prototype Pattern-The Prototype Pattern
- prototypes in constructors, Constructors with Prototypes
- Provider pattern, An Everyday Use Case for Design Patterns
- PRPL (Push Render Pre-cache Lazy-load) pattern, PRPL Pattern-PRPL Pattern
- public classes versus private, Classes with Constructors, Getters, and Setters
- Publish/Subscribe pattern
- advantages, Advantages
- disadvantages, Disadvantages
- example Ajax-based jQuery application decoupled, Decoupling an Ajax-based jQuery application
- example jQuery implementation with decoupled UI, Decoupling applications using Ben Alman’s Pub/Sub implementation
- example mail handler implementation, Differences Between the Observer and Publish/Subscribe Pattern
- example PubSub implementation, An example Publish/Subscribe implementation-Decoupling applications using Ben Alman’s Pub/Sub implementation
- implementations, Publish/Subscribe Implementations-Observer pattern in the React ecosystem
- Mediator pattern versus, The Mediator Pattern, Similarities and Differences-Relationships: When to use which, Event Aggregator (Pub/Sub) and Mediator Together
- Observer pattern versus, Differences Between the Observer and Publish/Subscribe Pattern
- (see also Observer pattern)
- pubsubz project, An example Publish/Subscribe implementation
- Push Render Pre-cache Lazy-load (PRPL) pattern, PRPL Pattern-PRPL Pattern
R
- React (React.js)
- about, MV* and React.js, React.js Design Patterns
- application structure
- about, Application Structure for React.js
- containers, Containers
- group by file type, Group by File Type
- group by module, feature, or route, Group by Module, Feature, or Route
- hybrid grouping, Hybrid Grouping Based on Domain and Common Components
- introduction, Introduction-Hybrid Grouping Based on Domain and Common Components
- modern React features, Application Structure for Modern React Features-Styled Components
- Next.js apps, Application Structure for Next.js Apps
- noParse option, Other Best Practices
- other best practices, Other Best Practices
- Redux, Redux
- Styled Components, Styled Components
- components, Basic Concepts
- design patterns
- bundle splitting, Bundle Splitting
- client-side rendering, Basic Concepts, Client-Side Rendering
- dynamic imports, Dynamic Import-Import on Visibility
- Higher Order Component pattern, Higher-Order Components-Higher-Order Components
- Hooks pattern, Composing
- hydration, Basic Concepts
- list virtualization, List Virtualization-Improvements in the Web Platform
- Loading Prioritization pattern, Loading Prioritization
- Provider pattern, An Everyday Use Case for Design Patterns
- PRPL pattern, PRPL Pattern-PRPL Pattern
- Render Props pattern, Render Props Pattern-Cons
- route-based code splitting, Route-based Splitting
- server-side rendering, Basic Concepts, Loadable Components
- static imports, Static Import-Static Import
- Hooks, Hooks Pattern-Hooks
- (see also React Hooks (Hooks))
- introduction to, An Introduction to React
- “Loading…” screen, Higher-Order Components
- MV* patterns and, MV* and React.js
- Next.js for server-rendered applications, MV* and React.js
- Observer pattern and, Observer pattern in the React ecosystem
- props, Basic Concepts
- React Server Components, React Server Components
- react-virtualized library for list virtualization, List Virtualization
- state management, State Management in React
- streaming SSR
- .Suspense for dynamic imports, Dynamic Import
- useState() method, State Hook
- View or presentation layer, Modern MV* Patterns
- React Context for global state management, State Management in React
- React Hooks (Hooks), Hooks Pattern-Hooks
- about, Hooks Pattern
- advantages, Pros and Cons of Using Hooks-Pros and Cons of Using Hooks
- alternative to classes, Classes in JavaScript Frameworks, Hooks
- application structure, Hooks
- custom Hooks, Custom Hooks-Custom Hooks
- disadvantages, Pros and Cons of Using Hooks
- further information on Hooks, Additional Hooks Guidance
- Higher Order Components pattern similar results, Composing
- Mixins alternative, Advantages and Disadvantages
- useContext Hook, An Everyday Use Case for Design Patterns, Additional Hooks Guidance
- useEffect Hook, Effect Hook, Additional Hooks Guidance
- useReducer Hook, Additional Hooks Guidance
- useState Hook, State Hook, Additional Hooks Guidance
- React Server Components, React Server Components
- React Suspense for dynamic imports, Dynamic Import
- react-virtualized library for list virtualization, List Virtualization
- ReactNative, Terminology Used
- reading file from filesystem with async/await, Additional Practical Examples
- real-time display of information, UI notifications
- Redux
- Reenskaug, Trygve, MVC
- region-specific pages rendered, Edge SSR
- Render Props pattern, Render Props Pattern-Cons
- Rendering patterns
- about, Rendering Patterns
- client-side rendering, Client-Side Rendering
- edge SSR, Edge SSR
- hybrid rendering, Hybrid Rendering
- importance of, Importance of Rendering Patterns
- Islands architecture, Islands Architecture-Pros and Cons
- progressive hydration, Rendering Patterns, Progressive Hydration
- React Server Components, React Server Components
- server-side rendering (see server-side rendering (SSR))
- static rendering, Static Rendering-Summary of Static Rendering
- streaming SSR, Rendering Patterns, Streaming SSR
- require() function for CommonJS, Getting Started
- require() method for AMD module dependencies, Getting Started with Modules, Getting Started with Modules-Getting Started with Modules
- RequireJS, A Note on Script Loaders, Getting Started with Modules
- resources online
- AMD related reading, Why was AMD a better choice for writing modular JavaScript?, jQuery plug-ins that function in all environments
- AMD-supported CommonJS wrapper documentation, Basic AMD hybrid format
- anti-patterns article, What Are Anti-Patterns?
- author blog, Conclusions
- book web page, How to Contact Us
- CommonJS related reading, Is CommonJS Suitable for the Browser?
- custom React Hooks, Custom Hooks
- JavaScript ES2015 guide (BabelJS), Modern JavaScript Syntax and Features
- preload articles, Conclusions
- RxJS documentation, Observer pattern in the React ecosystem
- single global variable pattern post, Prefix Namespacing
- UMD related reading, jQuery plug-ins that function in all environments
- reuse of code and Decorator pattern, The Decorator Pattern
- Revealing Module pattern, The Revealing Module Pattern-Disadvantages
- Rollup, Advantages of Using Modules
- route-based code splitting, Route-based Splitting
- rule of three, Rule of Three
- RxJS and Observer pattern, Observer pattern in the React ecosystem
S
- scaling and modularity, The Importance of Decoupling Applications
- scope
- script defer in head versus body, Loading Prioritization
- script loaders, A Note on Script Loaders
- script tag
- sensitive data and server-side rendering, Server-Side Rendering
- Separated Presentation, Smalltalk-80 MVC
- server-side rendering (SSR)
- setters for classes, Classes with Constructors, Getters, and Setters-Classes with Constructors, Getters, and Setters
- shared data
- Silverstein, Murray, History of Design Patterns
- single global variable namespacing pattern, Single Global Variables
- single-page applications (SPA), Terminology Used
- Singleton pattern, The Singleton Pattern-State Management in React
- Smalltalk-80
- sort functions
- SPA (single-page applications), Terminology Used
- “spaghetti” code, MVC for JavaScript Developers
- SSR (server-side rendering)
- state management
- static imports, Static Imports
- static keyword for classes, Classes with Constructors, Getters, and Setters
- static rendering, Rendering Patterns, Static Rendering-Summary of Static Rendering
- Stefanov, Stoyan, Automating Nested Namespacing, Dependency Declaration Pattern, Conclusions
- streaming SSR, Rendering Patterns, Streaming SSR
- structural design patterns
- style.js file, Styled Components
- subclasses
- super keyword for parent class constructor, Classes with Constructors, Getters, and Setters
- superclasses, Subclassing
- Svelte, React.js Design Patterns
- Sylor-Miller, Katie, Islands Architecture
- synchronous functions, Asynchronous Programming
T
- tagged template literals, Templating
- Taligent, MVP
- TC39 standards body, The Importance of Decoupling Applications
- TCP connections in HTTP versions, PRPL Pattern
- templating, Templating
- testing
- theme.js file, Styled Components
- then and catch
- this keyword
- time stamp, UI notifications
- triggers for changes in state, Recap: The View and the ViewModel
- try and catch in async function, Asynchronous Programming
- type attribute of script tag, Modules with Imports and Exports
U
- UI notifications in PubSub implementation, UI notifications
- UIs composed using JavaScript
- UMD (Universal Module Definition), UMD: AMD and CommonJS-Compatible Modules for Plug-ins-jQuery plug-ins that function in all environments
- about, UMD: AMD and CommonJS-Compatible Modules for Plug-ins
- CommonJS, AMD, or browser globals creating module, Using CommonJS, AMD, or browser globals to create a module
- jQuery plug-ins for AMD, browser globals, CommonJS, jQuery plug-ins that function in all environments-jQuery plug-ins that function in all environments
- related reading links, jQuery plug-ins that function in all environments
- Universal Module Definition (see UMD)
- useContext Hook (React), An Everyday Use Case for Design Patterns, Additional Hooks Guidance
- useEffect Hook (React), Effect Hook, Additional Hooks Guidance
- user-centric metrics of Core Web Vitals, Importance of Rendering Patterns
- useReducer Hook (React), Additional Hooks Guidance
- useState Hook (React), State Hook, Additional Hooks Guidance
- useState() method (React), State Hook
V
- validation of data as rare Model behavior, Model
- Vaughn, Brian, List Virtualization
- ViewModel, ViewModel
- views
- Views, Views, View
- about, Models
- active View, View
- Controllers as intermediaries, Controllers
- passive View, Models, Views, and Presenters, View
- Presenters, Models, Views, and Presenters
- templating, Templating
- ViewModel, ViewModel
- virtual DOM on client side, Rendering Patterns
- visibility of components
- Vlissides, John, History of Design Patterns, What Are Anti-Patterns?, Background, The Singleton Pattern, The Prototype Pattern, The Observer Pattern, MVC, Smalltalk-80 MVC in JavaScript
- Vue, React.js Design Patterns
- Vue.js, Modern MV* Patterns
- VuePress, Static Rendering