Mastering JavaScript functional programming in-depth guide for writing robust and maintainable JavaScript codes in ES8 and beyond
Master Functional Programming techniques with this comprehensive guide for writing cleaner, safer, high-performing JavaScript codes About This Book Become proficient and skilled with Functional Programming in JavaScript to solve real-world development problems Successfully apply Functional Programmi...
| Otros Autores: | |
|---|---|
| Formato: | Libro electrónico |
| Idioma: | Inglés |
| Publicado: |
Birmingham, England ; Mumbai, [India] :
Packt Publishing
2017.
|
| Edición: | 1st edition |
| Materias: | |
| Ver en Biblioteca Universitat Ramon Llull: | https://discovery.url.edu/permalink/34CSUC_URL/1im36ta/alma991009630093406719 |
Tabla de Contenidos:
- Cover
- Title Page
- Copyright
- Credits
- About the Author
- Dedication
- About the Reviewer
- www.PacktPub.com
- Customer Feedback
- Table of Contents
- Preface
- Chapter 1: 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
- Chapter 2: 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
- Chapter 3: 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
- Chapter 4: 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
- Chapter 5: 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
- Chapter 6: 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
- Chapter 7: 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
- Chapter 8: 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
- Chapter 9: 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.
- Chapter 10: 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
- Chapter 11: 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
- Chapter 12: 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
- Appendix: Answers to Questions
- Index.
