JavaScript: Functional Programming for JavaScript Developers电子书

JavaScript: Functional Programming for JavaScript Developers

Table of Contents

JavaScript: Functional Programming for JavaScript Developers

JavaScript: Functional Programming for JavaScript Developers

Credits

Preface

What this learning path covers

What you need for this learning path

Who this learning path is for

Reader feedback

Customer support

Downloading theexample code

Errata

Piracy

Questions

1. Module 1

1. JavaScript Primer

A little bit of history

How to use this book

Hello World

An overview of JavaScript

Comments

Variables

Constants

Number

String

Undefined values

Booleans

The instanceof operator

Date objects

The + operator

The ++ and -- operators

Boolean operators

Equality

Strict equality using ===

Weak equality using ==

JavaScript types

Automatic semicolon insertion

JavaScript style guide

Whitespaces

Parentheses, line breaks, and braces

Quotes

End of lines and empty lines

Type checking

Type casting

Conditional evaluation

Naming

The eval() method is evil

The strict mode

Enabling the strict mode for an existing code can break it

Package with care

Variables must be declared in strict mode

The eval() function is cleaner in strict mode

Features that are blocked in strict mode

Running JSHint

Summary

2. Functions, Closures, and Modules

A function literal

A function declaration

Functions as data

Scoping

Global scope

Local scope

Function-level scope versus block-level scope

Inline function expressions

Block scopes

Function declarations versus function expressions

The arguments parameter

The this parameter

Invocation as a function

Invocation as a method

Invocation as a constructor

Invocation using apply() and call() methods

Anonymous functions

Anonymous functions while creating an object

Anonymous functions while creating a list

Anonymous functions as a parameter to another function

Anonymous functions in conditional logic

Closures

Timers and callbacks

Private variables

Loops and closures

Modules

Stylistic considerations

Summary

3. Data Structures and Manipulation

Regular expressions

Exact match

Match from a class of characters

Repeated occurrences

Alternatives – OR

Beginning and end

Backreferences

Greedy and lazy quantifiers

Arrays

Maps

Sets

A matter of style

Summary

4. Object-Oriented JavaScript

Understanding objects

Behavior of JavaScript objects

Prototypes

Instance properties versus prototype properties

Inheritance

Getters and setters

Summary

5. Testing and Debugging

Unit testing

Test-driven development

Behavior-driven development

JavaScript debugging

Syntax errors

Using strict

Runtime exceptions

Console.log and asserts

Chrome DevTools

Summary

6. ECMAScript 6

Shims or polyfills

Transpilers

ES6 syntax changes

Block scoping

Default parameters

Spread and rest

Destructuring

Object literals

Template literals

Maps and Sets

Symbols

Iterators

For..of loops

Arrow functions

Summary

7. DOM Manipulation and Events

DOM

Accessing DOM elements

Accessing specific nodes

Chaining

Traversal and manipulation

Working with browser events

Propagation

jQuery event handling and propagation

Event delegation

The event object

Summary

8. Server-Side JavaScript

An asynchronous evented-model in a browser

Callbacks

Timers

EventEmitters

Modules

Creating modules

npm

Installing packages

JavaScript performance

JavaScript profiling

The CPU profile

The Timeline view

Summary

2. Module 2

1. Designing for Fun and Profit

The road to JavaScript

The early days

A pause

The way of GMail

JavaScript everywhere

What is a design pattern?

Anti-patterns

Summary

2. Organizing Code

Chunks of code

What's the matter with global scope anyway?

Objects in JavaScript

Build me a prototype

Inheritance

Modules

ECMAScript 2015 classes and modules

Best practices and troubleshooting

Summary

3. Creational Patterns

Abstract factory

Implementation

Builder

Implementation

Factory method

Implementation

Singleton

Implementation

Disadvantages

Prototype

Implementation

Tips and tricks

Summary

4. Structural Patterns

Adapter

Implementation

Bridge

Implementation

Composite

Example

Implementation

Decorator

Implementation

Façade

Implementation

Flyweight

Implementation

Proxy

Implementation

Hints and tips

Summary

5. Behavioral Patterns

Chain of responsibility

Implementation

Command

Command message

Invoker

Receiver

Interpreter

Example

Implementation

Iterator

Implementation

ECMAScript 2015 iterators

Mediator

Implementation

Memento

Implementation

Observer

Implementation

State

Implementation

Strategy

Implementation

Template method

Implementation

Visitor

Hints and tips

Summary

Part 2

6. Functional Programming

Functional functions are side-effect-free

Function passing

Implementation

Filters and pipes

Implementation

Accumulators

Implementation

Memoization

Implementation

Immutability

Lazy instantiation

Implementation

Hints and tips

Summary

7. Reactive Programming

Application state changes

Streams

Filtering streams

Merging streams

Streams for multiplexing

Hints and tips

Summary

8. Application Patterns

First, some history

Model View Controller

MVC code

Model View Presenter

MVP code

Model View ViewModel

MVVM code

A better way to transfer changes between the model and the view

Observing view changes

Tips and tricks

Summary

9. Web Patterns

Sending JavaScript

Combining files

Minification

Content Delivery Networks

Plugins

jQuery

d3

Doing two things at once – multithreading

Circuit breaker pattern

Back-off

Degraded application behavior

Promise pattern

Hints and tips

Summary

10. Messaging Patterns

What's a message anyway?

Commands

Events

Request-reply

Publish-subscribe

Fan out and in

Dead letter queues

Message replay

Pipes and filters

Versioning messages

Hints and tips

Summary

11. Microservices

Façade

Service selector

Aggregate services

Pipeline

Message upgrader

Failure patterns

Service degradation

Message storage

Message replay

Indempotence of message handling

Hints and tips

Summary

12. Patterns for Testing

The testing pyramid

Testing in the small with unit tests

Arrange-Act-Assert

Assert

Fake objects

Test spies

Stubs

Mock

Monkey patching

Interacting with the user interface

Browser testing

Faking the DOM

Wrapping the manipulation

Tips and tricks

Summary

13. Advanced Patterns

Dependency injection

Live post processing

Aspect oriented programming

Mixins

Macros

Tips and tricks

Summary

14. ECMAScript-2015/2016 Solutions Today

TypeScript

Decorators

Async/Await

Typing

BabelJS

Classes

Default parameters

Template literals

Block bindings with let

In production

Tips and tricks

Summary

3. Module 3

1. The Powers of JavaScript's Functional Side – a Demonstration

Introduction

The demonstration

The application – an e-commerce website

Imperative methods

Functional programming

Summary

2. Fundamentals of Functional Programming

Functional programming languages

What makes a language functional?

Advantages

Cleaner code

Modularity

Reusability

Reduced coupling

Mathematically correct

Functional programming in a nonfunctional world

Is JavaScript a functional programming language?

Working with functions

Self-invoking functions and closures

Higher-order functions

Pure functions

Anonymous functions

Method chains

Recursion

Divide and conquer

Lazy evaluation

The functional programmer's toolkit

Callbacks

Array.prototype.map()

Array.prototype.filter()

Array.prototype.reduce()

Honorable mentions

Array.prototype.forEach

Array.prototype.concat

Array.prototype.reverse

Array.prototype.sort

Array.prototype.every and Array.prototype.some

Summary

3. Setting Up the Functional Programming Environment

Introduction

Functional libraries for JavaScript

Underscore.js

Fantasy Land

Bilby.js

Lazy.js

Bacon.js

Honorable mentions

Development and production environments

Browsers

Server-side JavaScript

A functional use case in the server-side environment

CLI

Using functional libraries with other JavaScript modules

Functional languages that compile into JavaScript

Summary

4. Implementing Functional Programming Techniques in JavaScript

Partial function application and currying

Function manipulation

Apply, call, and the this keyword

Binding arguments

Function factories

Partial application

Partial application from the left

Partial application from the right

Currying

Function composition

Compose

Sequence – compose in reverse

Compositions versus chains

Programming with compose

Mostly functional programming

Handling events

Functional reactive programming

Reactivity

Putting it all together

Summary

5. Category Theory

Category theory

Category theory in a nutshell

Type safety

Object identities

Functors

Creating functors

Arrays and functors

Function compositions, revisited

Monads

Maybes

Promises

Lenses

jQuery is a monad

Implementing categories

Summary

6. Advanced Topics and Pitfalls in JavaScript

Recursion

Tail recursion

The Tail-call elimination

Trampolining

The Y-combinator

Memoization

Variable scope

Scope resolutions

Global scope

Local scope

Object properties

Closures

Gotchas

Function declarations versus function expressions versus the function constructor

Function declarations

Function expressions

The function constructor

Unpredictable behavior

Summary

7. Functional and Object-oriented Programming in JavaScript

JavaScript – the multi-paradigm language

JavaScript's object-oriented implementation – using prototypes

Inheritance

JavaScript's prototype chain

Inheritance in JavaScript and the Object.create() method

Mixing functional and object-oriented programming in JavaScript

Functional inheritance

Strategy Pattern

Mixins

Classical mixins

Functional mixins

Summary

A. Common Functions for Functional Programming in JavaScript

B. Glossary of Terms

A. Bibliography

Index