TypeScript Design Patterns电子书

TypeScript Design Patterns

TypeScript Design Patterns

Credits

About the Author

About the Reviewer

www.PacktPub.com

eBooks, discount offers, and more

Why subscribe?

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Downloading the example code

Errata

Piracy

Questions

1. Tools and Frameworks

Installing the prerequisites

Installing Node.js

Installing TypeScript compiler

Choosing a handy editor

Visual Studio Code

Configuring Visual Studio Code

Opening a folder as a workspace

Configuring a minimum build task

Sublime Text with TypeScript plugin

Installing Package Control

Installing the TypeScript plugin

Other editor or IDE options

Atom with the TypeScript plugin

Visual Studio

WebStorm

Getting your hands on the workflow

Configuring a TypeScript project

Introduction to tsconfig.json

Compiler options

target

module

declaration

sourceMap

jsx

noEmitOnError

noEmitHelpers

noImplicitAny

experimentalDecorators*

emitDecoratorMetadata*

outDir

outFile

rootDir

preserveConstEnums

strictNullChecks

stripInternal*

isolatedModules

Adding source map support

Downloading declarations using typings

Installing typings

Downloading declaration files

Option "save"

Testing with Mocha and Istanbul

Mocha and Chai

Writing tests in JavaScript

Writing tests in TypeScript

Getting coverage information with Istanbul

Testing in real browsers with Karma

Creating a browser project

Installing Karma

Configuring and starting Karma

Integrating commands with npm

Why not other fancy build tools?

Summary

2. The Challenge of Increasing Complexity

Implementing the basics

Creating the code base

Defining the initial structure of the data to be synchronized

Getting data by comparing timestamps

Two-way synchronizing

Things that went wrong while implementing the basics

Passing a data store from the server to the client does not make sense

Making the relationships clear

Growing features

Synchronizing multiple items

Simply replacing data type with an array

Server-centered synchronization

Synchronizing from the server to the client

Synchronizing from client to server

Synchronizing multiple types of data

Supporting multiple clients with incremental data

Updating the client side

Updating server side

Supporting more conflict merging

New data structures

Updating client side

Updating the server side

Things that go wrong while implementing everything

Piling up similar yet parallel processes

Data stores that are tremendously simplified

Getting things right

Finding abstraction

Implementing strategies

Wrapping stores

Summary

3. Creational Design Patterns

Factory method

Participants

Pattern scope

Implementation

Consequences

Abstract Factory

Participants

Pattern scope

Implementation

Consequences

Builder

Participants

Pattern scope

Implementation

Consequences

Prototype

Singleton

Basic implementations

Conditional singletons

Summary

4. Structural Design Patterns

Composite Pattern

Participants

Pattern scope

Implementation

Consequences

Decorator Pattern

Participants

Pattern scope

Implementation

Classical decorators

Decorators with ES-next syntax

Consequences

Adapter Pattern

Participants

Pattern scope

Implementation

Consequences

Bridge Pattern

Participants

Pattern scope

Implementation

Consequences

Façade Pattern

Participants

Pattern scope

Implementation

Consequences

Flyweight Pattern

Participants

Pattern scope

Implementation

Consequences

Proxy Pattern

Participants

Pattern scope

Implementation

Consequences

Summary

5. Behavioral Design Patterns

Chain of Responsibility Pattern

Participants

Pattern scope

Implementation

Consequences

Command Pattern

Participants

Pattern scope

Implementation

Consequences

Memento Pattern

Participants

Pattern scope

Implementation

Consequences

Iterator Pattern

Participants

Pattern scope

Implementation

Simple array iterator

ES6 iterator

Consequences

Mediator Pattern

Participants

Pattern scope

Implementation

Consequences

Summary

6. Behavioral Design Patterns: Continuous

Strategy Pattern

Participants

Pattern scope

Implementation

Consequences

State Pattern

Participants

Pattern scope

Implementation

Consequences

Template Method Pattern

Participants

Pattern scope

Implementation

Consequences

Observer Pattern

Participants

Pattern scope

Implementation

Consequences

Visitor Pattern

Participants

Pattern scope

Implementation

Consequences

Summary

7. Patterns and Architectures in JavaScript and TypeScript

Promise-based web architecture

Promisifying existing modules or libraries

Views and controllers in Express

Abstraction of responses

Abstraction of permissions

Expected errors

Defining and throwing expected errors

Transforming errors

Modularizing project

Asynchronous patterns

Writing predictable code

Asynchronous creational patterns

Asynchronous middleware and hooks

Event-based stream parser

Summary

8. SOLID Principles

Single responsibility principle

Example

Choosing an axis

Open-closed principle

Example

Abstraction in JavaScript and TypeScript

Refactor earlier

Liskov substitution principle

Example

The constraints of substitution

Interface segregation principle

Example

Proper granularity

Dependency inversion principle

Example

Separating layers

Summary

9. The Road to Enterprise Application

Creating an application

Decision between SPA and "normal" web applications

Taking team collaboration into consideration

Building and testing projects

Static assets packaging with webpack

Introduction to webpack

Bundling JavaScript

Loading TypeScript

Splitting code

Loading other static assets

Adding TSLint to projects

Integrating webpack and tslint command with npm scripts

Version control

Git flow

Main branches

Supporting branches

Feature branches

Release branches

Hotfix branches

Summary of Git flow

Pull request based code review

Configuring branch permissions

Comments and modifications before merge

Testing before commits

Git hooks

Adding pre-commit hook automatically

Continuous integration

Connecting GitHub repository with Travis-CI

Deployment automation

Passive deployment based on Git server side hooks

Proactive deployment based on timers or notifications

Summary