Mastering JavaScript Functional Programming电子书

Dedication

Title Page

Copyright

Mastering JavaScript Functional Programming

Credits

About the Author

About the Reviewer

www.PacktPub.com

Why subscribe?

Customer Feedback

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

Becoming Functional – Several Questions

What is Functional Programming?

Theory versus practice

A different way of thinking

What Functional Programming is not

Why use Functional Programming?

What we need

What we get

Not all is gold...

Is JavaScript functional?

JavaScript as a tool

Going functional with JavaScript

Key features of JavaScript

Functions as First Class Objects

Recursion

Closures

Arrow functions

Spread

How do we work with JavaScript?

Using transpilers

Working online

Testing

Questions

Summary

Thinking Functionally - A First Example

The problem - do something only once

Some bad solutions

Solution #1 - hope for the best!

Solution #2 - use a global flag

Solution #3 - remove the handler

Solution #4 - change the handle

Solution #5 - disable the button

Solution #6 - redefine the handler

Solution #7- use a local flag

A functional solution

A higher-order solution

Testing the solution manually

Testing the solution automatically

An even better solution

Questions

Summary

Starting Out with Functions - A Core Concept

All about functions

Of lambdas and functions

Arrow functions - the modern way

Returning values

Handling the this value

Working with arguments

One argument or many?

Functions as objects

A React+Redux reducer

An unnecessary mistake

Working with methods

Using functions in FP ways

Injection - sorting it out

Callbacks, promises, and continuations

Continuation Passing Style

Polyfills

Detecting Ajax

Adding missing functions

Stubbing

Immediate invocation

Questions

Summary

Behaving Properly - Pure Functions

Pure functions

Referential Transparency

Side effects

Usual side effects

Global state

Inner state

Argument mutation

Troublesome functions

Advantages of pure functions

Order of execution

Memoization

Self-documentation

Testing

Impure functions

Avoiding impure functions

Avoiding the usage of state

Injecting impure functions

Is your function pure?

Testing - pure versus impure

Testing pure functions

Testing purified functions

Testing impure functions

Questions

Summary

Programming Declaratively - A Better Style

Transformations

Reducing an array to a value

Summing an array

Calculating an average

Calculating several values at once

Folding left and right

Applying an operation - map

Extracting data from objects

Parsing numbers tacitly

Working with ranges

Emulating map() with reduce()

More general looping

Logical higher-order functions

Filtering an array

A reduce() example

Emulating filter() with reduce()

Searching an array

A special search case

Emulating find() and findIndex() with reduce()

Higher level predicates - some, every

Checking negatives - none

Questions

Summary

Producing Functions - Higher-Order Functions

Wrapping functions

Logging

Logging in a functional way

Taking exceptions into account

Working in a more pure way

Timing

Memoizing

Simple memoization

More complex memoization

Memoization testing

Altering functions

Doing things once, revisited

Logically negating a function

Inverting results

Arity changing

Other higher-order functions

Turning operations into functions

Implementing operations

A handier implementation

Turning functions into promises

Getting a property from an object

Demethodizing - turning methods into functions

Finding the optimum

Questions

Summary

Transforming Functions - Currying and Partial Application

A bit of theory

Currying

Dealing with many parameters

Currying by hand

Currying with bind()

Currying with eval()

Partial application

Partial application with arrow functions

Partial application with eval()

Partial application with closures

Partial currying

Partial currying with bind()

Partial currying with closures

Final thoughts

Parameter order

Being functional

Questions

Summary

Connecting Functions - Pipelining and Composition

Pipelining

Piping in Unix/Linux

Revisiting an example

Creating pipelines

Building pipelines by hand

Using other constructs

Debugging pipelines

Using tee

Tapping into a flow

Using a logging wrapper

Chaining and fluent interfaces

Pointfree style

Defining pointfree functions

Converting to pointfree style

Composing

Some examples of composition

Unary operators

Counting files

Finding unique words

Composing with higher order functions

Testing composed functions

Questions

Summary

Designing Functions - Recursion

Using recursion

Thinking recursively

Decrease and Conquer: searching

Decrease and Conquer: doing powers

Divide and conquer: The Tower of Hanoi

Divide and conquer: sorting

Dynamic programming: making change

Higher order functions revisited

Mapping and filtering

Other higher-order functions

Searching and backtracking

The Eight Queens puzzle

Traversing a tree structure

Recursion techniques

Tail call optimization

Continuation passing style

Trampolines and thunks

Recursion elimination

Questions

Summary

Ensuring Purity - Immutability

The straightforward JS way

Mutator functions

Constants

Freezing

Cloning and mutating

Getters and setters

Getting a property

Setting a property by path

Persistent data structures

Working with lists

Updating objects

A final caveat

Questions

Summary

Implementing Design Patterns - The Functional Way

What are Design Patterns?

Design pattern categories

Do we need design patterns?

Object-oriented design patterns

Façade and Adapter

Decorator or Wrapper

Strategy, Template, and Command

Other patterns

Functional design patterns

Questions

Summary

Building Better Containers - Functional Data Types

Data types

Signatures for functions

Other type options

Containers

Extending current data types

Containers and functors

Wrapping a value: a basic container

Enhancing our container: functors

Dealing with missing values with Maybe

Monads

Adding operations

Handling alternatives - the Either monad

Calling a function - the Try monad

Unexpected Monads - Promises

Functions as data structures

Binary trees in Haskell

Functions as binary trees

Questions

Summary

Bibliography

Answers to Questions