Name: Mastering JavaScript Functional Programming
Author: Federico Kereki
ISBN: 9781787289734

微信读书书城Mastering JavaScript Functional Programming

首页我的书架登录

翻译完成

切换

Mastering JavaScript Functional Programming

Federico Kereki

扉页
版权信息
+书签
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

简介

版权

Mastering JavaScript Functional Programming