會員

Mastering Immutable.js

Adam Boduch 著

更新時間：2021-07-08 10:30:50

開會員，本書免費(fèi)讀 >

ThisbookisforJavaScriptdevelopers,fromintermediatelevelandbeyond,whoneedtocreatedependableJavaScriptprojects,usingtheImmutable.jsJavaScriptframework.

目錄(292章)

倒序

coverpage
Title Page
Copyright
Mastering Immutable.js
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
Downloading the color images of this book
Errata
Piracy
Questions
Why Immutable.js?
Mutations are destructive
Deleting old data
A scary class of bugs
Persisting changes
The Immutable.js approach
A collections API
Collection methods return new data
Chaining method calls
Unidirectional data flow
What other direction is there?
Subscriptions are out
Data is only created
Implicit side-effects are hard to do
Other libraries similar to Immutable.js
What are we comparing?
Lodash is a good bet
Summary
Creating Immutable Data
Immutable.js constructors
The types of Immutable.js data
Lists
Maps
Ordered maps
Sets
Ordered sets
Sequences
Stacks
Records
Passing JavaScript collections
Passing Immutable.js collections
Using the of() method
Lists of values
Maps of values
Sets of values
Sequences of values
Parsing data using the fromJS() function
Parsing JavaScript arrays
Parsing JavaScript objects
Parsing complex structures
Summary
Persistent Changes
Adding values to collections
Pushing values to lists
Adding key-value pairs to maps
Chaining value insertion methods
Pushing multiple list values
Adding multiple map key-value pairs
Changing collection values
Changing list values
Setting list values
Updating list values
Changing map values
Setting map values
Updating map values
Chaining collection mutation methods
Removing values from collections
Removing values from lists
Removing values from maps
Chaining collection removal methods
Emptying collections
Replacing collections with new instances
Using the clear() method
Keeping track of changes
Summary
Filtering Collections and Finding Items
Filtering using simple comparisons
Strict equality
Greater than and less than
Filtering by negation
Filtering maps by keys
Filtering string keys
Filtering fancy keys
Finding collection values
Value existence checks
Getting values using find()
Filtering using deep equality
Using the is() function and the equals() method
Searching lists of maps
Partial matches
The shape of maps
Subsets and supersets
Changing the search direction
Searching sorted collections
Using findLast() and reduceRight()
Summary
Sequences and Side-Effects
Why lazy evaluation?
Large collections are expensive
Avoiding unnecessary work
Chained operations are easy to understand
Sequence creation and iteration
Basic sequence creation
Collections to sequences
Lists to sequences
Maps to sequences
Iterating with for...of loops
Iterating with forEach()
Lazy filtering
Basic lazy filtering
Multiple filter levels
Limiting results and reducing work
Using take() to limit results
Using slice() to paginate
Summary
Sorting Collections
Sorting and reversing
The sort() method
The reverse() method
Sorting lists of maps
The sortBy() method
Sorting by multiple keys
Ordered maps
Order guarantees
Insertion order is not sort order
Setting the order with set()
Sorting maps
Creating ordered maps
Sorting maps by key
Maintaining sort order
Finding the insertion index
Is this really necessary?
Summary
Mapping and Reducing
Mapping lists of maps
Plucking values
Computing new values
Mapping to new lists of maps
Creating new keys
Filtering keys
Reducing collections
When filtering isn't enough
Producing minimums and maximums
Accumulating values
Lazy mapping
Multiple map() calls
Filtering before mapping
The ultimate lazy pattern
Summary
Zipping and Flattening
Zipping collections
Removing excess iterations
Zipping lists of simple values
Zipping lists of maps
Lazy zipping
Flattening collections
Avoiding recursion
Deep flattening nested lists
Shallow flattening lists
Flattening nested maps
Summary
Persistent Change Detection
Collection equality
Strict equality and mutative methods
Detecting changes
Detecting no changes
Strict equality versus deep equality
Transformations versus mutations
Transformations always return new collections
Detecting changes before transformations
Caching side-effects
Summary
Working with Sets
Sets are not lists
Do not use the get() method
No defined iteration order
Maps with keys only
Removing duplicates
Converting to sets
Converting to sets then back to lists
Lazy duplicate removal
Ordered sets
Sorting sets
Iterating over sets
Maintaining sets
Adding unique values
Adding duplicate values
Summary
Comparing Collections
Set intersections
Intersecting sets
Ordered intersections
List intersections
Reducing list intersections
Filtering list intersections
Collection differences
Set differences
List differences
Comparing maps
Map intersections
Map differences
Subsets and supersets
List subsets
List supersets
Summary
Combining Collections
Merging maps
Merging maps by key
Merging maps with complex keys
Merging lists
Merging simple values
Merging lists of maps
Merging lists of lists
Concatenating lists and sequences
Simple value concatenation
Lazy sequence concatenation
Interposing and interleaving
Lazily interposing values
Lazily interleaving values
Summary
Declarative Decision Making
Mapping behavior
Keys are logical paths values are behavior
Wrapping behavior maps in functions
Parameters and defaults
Providing default behavior
Parameterizing mapped behavior
Composing behavior
A generic higher-order behavior function
Logical and/or conditions
Complex behavior compositions
Summary
Side-Effects in User Interfaces
A simple application
Application data
Filter controls
Episode results
DOM side-effects
HTML markup
Filter fields
Rating slider
Episode template
Filtering episodes
Handling events
Rendering elements
React side-effects
Application state
Handling events and changing state
Mapping episodes to elements
Summary
Side-Effects in Node.js
Reading data into collections
Reading and parsing CSV data
Reading large amounts of data
Using concat()
Using push()
Using push() and withMutations()
Writing collection data
Iterating over collections and writing lines
Asynchronous data and sequences
Chaining lazy sequences and streams
Summary
Immutable Architecture
The reusable application state updater
Initial state
Side-effects
Updating state and running side-effects
Initial application state
Result state
Creating a new episode state
Events and state updaters
Updating the search query
Updating the checkboxes and slider state
Updating new episode data
Creating new episodes
Executing side-effects
Rendering episode results
Rendering the result count
Resetting the new episode form
Summary 更新時間：2021-07-08 10:30:50

官术网_书友最值得收藏!

Mastering Immutable.js