TypeScript 4 Design Patterns and Best Practices
TypeScript 4 Design Patterns and Best Practices
Contributors
About the author
About the reviewer
Preface
Who this book is for
What this book covers
To get the most out of this book
Download the example code files
Download the color images
Conventions used
Get in touch
Share your thoughts

1

Getting Started with TypeScript 4

Section 1: Getting Started with TypeScript 4
Technical requirements
Introducing TypeScript 4
Working with input and output
Useful TypeScript 4 features
Understanding TypeScript and JavaScript's relationship
How does JavaScript compare to TypeScript?
Transitioning from JavaScript to TypeScript
Design patterns in JavaScript
Installing and using the code examples
Reviewing the libraries included in the code examples
Understanding the tsconfig.json file
Running the unit tests
Using VSCode with TypeScript
Using VSCode for this book's code
Inspecting types
Refactoring with VSCode
Introducing Unified Modeling Language (UML)
What is UML?
Learning UML class diagrams
Summary
Q & A
Further reading
Technical requirements
Working with advanced types
Using utility types
Using advanced types and assertions
OOP with TypeScript
Abstraction
Inheritance
Encapsulation
Polymorphism
Developing in the browser
Understanding the DOM
Using TypeScript with webpack
Using React
Developing in the server
Understanding the server environment
Using Express with TypeScript
Introducing design patterns in TypeScript
Why design patterns exist
Design patterns in TypeScript
Summary
Q&A
Further reading
Section 2: Core Design Patterns and Concepts
Technical requirements
Creational design patterns
Singleton pattern
When do we use the Singleton?
UML class diagram
Classic implementation
Modern implementations
Variants
Testing
Criticisms of the singleton
Real-world examples
Prototype pattern
When do we use the Prototype pattern?
UML class diagram
Classic implementation
Testing
Criticisms of the Prototype pattern
Real-world examples
Builder pattern
When do we use Builder?
UML class diagram for Builder
Classic implementation
Testing
Modern implementations
Criticisms of Builder
Real-world examples
Factory method pattern
When do we use the Factory method?
UML class diagram
Classic implementation
Alternative implementations
Testing
Real-world examples
Abstract Factory pattern
When do we use the Abstract Factory?
UML class diagram
Classic implementation
Testing
Criticisms of Abstract Factory
Real-world example
Summary
Q&A
Further reading
Technical requirements
Understanding structural design patterns
Adapter pattern
When to use Adapter
UML class diagram
Classic implementation
Testing
Criticisms of Adapter
Real-world use cases
Decorator pattern
When to use Decorator
UML class diagram
Classic implementation
Modern variants
Testing
Criticisms of Decorator
Real-world use cases
Façade pattern
When to use Façade
UML class diagram
Classic implementation
Testing
Criticisms of Façade
Real-world use cases
Composite pattern
When to use Composite
UML class diagram
Classic implementation
Testing
Criticisms of Composite
Real-world use cases
Proxy pattern
When to use Proxy
UML class diagram
Classic implementation
Modern variant
Testing
Criticisms of Proxy
Real-world use cases
Bridge pattern
When to use Bridge
UML class diagram
Classic implementation
Testing
Criticisms of Bridge
Real-world use cases
Flyweight pattern
When to use Flyweight
UML class diagram
Classic implementation
Testing
Criticisms of Flyweight
Real-world use cases
Summary
Q&A
Further reading
Technical requirements
Behavioral design patterns
The Strategy pattern?
When to use the Strategy pattern
UML class diagram
Classic implementation
Testing
Criticism of this pattern
Real-world use cases
Chain of Responsibility
When to use Chain of Responsibility?
UML class diagram
Classic implementation
Testing
Criticisms of this pattern
Real-world use case
The Command pattern
When to use the Command pattern?
UML class diagram
Classic implementation
Testing
Criticism of this pattern
Real-world use case
The Iterator pattern
When to use the Iterator pattern?
UML class diagram
Classic implementation
Testing
Criticism of this pattern
Real-world use case
The Mediator pattern
When to use the Meditator pattern?
UML class diagram
Classic implementation
Testing
Criticisms of this pattern
Real-world use cases
The Observer pattern
When to use the Observer pattern?
UML class diagram
Classic implementation
Testing
Criticisms of this pattern
Real-world use case
The Memento pattern
When to use the Memento pattern?
UML class diagram
Classic implementation
Testing
Criticisms of this pattern
Real-world use case
The State pattern
When to use the State pattern?
UML class diagram
Classic implementation
Testing
Criticisms of this pattern
Real-world use case
The Template method pattern
When to use the Template method pattern?
UML class diagram
Classic implementation
Testing
Criticism of this pattern
Real-world use case
The Visitor pattern
When to use the Visitor pattern?
UML class diagram
Classic implementation
Testing
Criticisms of this pattern
Real-world use case
Summary
Q&A
Further reading
Section 3: Advanced Concepts and Best Practices
Technical requirements
Learning key concepts in functional programming
Pure functions
Recursion
Functions as first-class citizens
Function composition
Referential transparency
Immutability
Understanding functional lenses
Implementation of lenses
Use cases of lenses
Understanding transducers
Understanding monads
Summary
Q & A
Further reading
Technical requirements
Learning Reactive programming concepts
The asynchronous propagation of changes
The pull pattern
The push pattern
The push-pull pattern
Understanding Promises and Futures
Futures
Learning observables
Getting started with ReactiveX observables
Composable operators
Cold versus hot observables
Summary
Q & A
Further reading
Technical requirements
Combining patterns
Singleton
Iterator
Command
Using utility types
Using domain-driven design
Understanding entities
Understanding value objects
Understanding domain events
Applying the SOLID principles
Understanding the single-responsibility principle
Understanding the open-closed principle
Understanding the Liskov substitution principle
Understanding the interface segregation principle
Understanding the dependency inversion principle
Is using SOLID a best practice?
Summary
Q&A
Further reading
Technical requirements
Class overuse
Not using runtime assertions
Permissive or incorrect types
Using idiomatic code from other languages
From the Java language
From the Go language
Type inference gotchas
Summary
Q & A
Further reading
Share your thoughts

Behavioral Design Patterns

Unlock This Title

You do not have access to this section. Get the full version of this title with a SitePoint Premium Account.

Start Free TrialRead Free Preview

Already a Premium member? Sign In

Community Questions