Filtering Collections and Finding Items | Mastering Immutable.js

Sign In Start Free Trial

Book Overview & Buying
Table Of Contents

Mastering Immutable.js

By : Adam Boduch

Mastering Immutable.js

By: Adam Boduch

Overview of this book

Immutable.js is a JavaScript library that will improve the robustness and dependability of your larger JavaScript projects. All aspects of the Immutable.js framework are covered in this book, and common JavaScript situations are examined in a hands-on way so that you gain practical experience using Immutable.js that you can apply across your own JavaScript projects. The key to building robust JavaScript applications using immutability is to control how data flows through your application, and how the side-effects of these flows are managed. Many problems that are difficult to pinpoint in large codebases stem from data that’s been mutated where it shouldn’t have been. With immutable data, you rule out an entire class of bugs. Mastering Immutable.js takes a practical, hands-on approach throughout, and shows you the ins and outs of the Immutable.js framework so that you can confidently build successful and dependable JavaScript projects.

Preface

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Free Chapter

Why Immutable.js?

Why Immutable.js?

Mutations are destructive

The Immutable.js approach

Unidirectional data flow

Other libraries similar to Immutable.js

Summary

Creating Immutable Data

Creating Immutable Data

Immutable.js constructors

Using the of() method

Parsing data using the fromJS() function

Summary

Persistent Changes

Persistent Changes

Adding values to collections

Changing collection values

Removing values from collections

Emptying collections

Keeping track of changes

Summary

Filtering Collections and Finding Items

Filtering Collections and Finding Items

Filtering using simple comparisons

Filtering maps by keys

Finding collection values

Filtering using deep equality

Partial matches

Changing the search direction

Summary

Sequences and Side-Effects

Sequences and Side-Effects

Why lazy evaluation?

Sequence creation and iteration

Lazy filtering

Limiting results and reducing work

Summary

Sorting Collections

Sorting Collections

Sorting and reversing

Sorting lists of maps

Ordered maps

Sorting maps

Maintaining sort order

Summary

Mapping and Reducing

Mapping and Reducing

Mapping lists of maps

Mapping to new lists of maps

Reducing collections

Lazy mapping

Summary

Zipping and Flattening

Zipping and Flattening

Zipping collections

Flattening collections

Summary

Persistent Change Detection

Persistent Change Detection

Collection equality

Transformations versus mutations

Caching side-effects

Summary

Working with Sets

Working with Sets

Sets are not lists

Removing duplicates

Ordered sets

Maintaining sets

Summary

Comparing Collections

Comparing Collections

Set intersections

List intersections

Collection differences

Comparing maps

Subsets and supersets

Summary

Combining Collections

Combining Collections

Merging maps

Merging lists

Concatenating lists and sequences

Interposing and interleaving

Summary

Declarative Decision Making

Declarative Decision Making

Mapping behavior

Parameters and defaults

Composing behavior

Summary

Side-Effects in User Interfaces

Side-Effects in User Interfaces

A simple application

DOM side-effects

React side-effects

Summary

Side-Effects in Node.js

Side-Effects in Node.js

Reading data into collections

Writing collection data

Summary

Immutable Architecture

Immutable Architecture

The reusable application state updater

Initial application state

Events and state updaters

Executing side-effects

Summary

Filtering using deep equality

String equality works well when you need to compare two object references or two primitive values. But what about the cases where you want to compare something complex, such as two maps? Strict equality doesn't work here because they're two distinct references, even though their keys and values are the same. Immutable.js provides tools for performing deep collection comparisons.

Using the is() function and the equals() method

Immutable.js exports an is() function, which is used to compare two values. It can compare primitive JavaScript types using the same semantics as Object.is(), and it can do deep comparisons between two Immutable.js collections. When you pass two collections to is(), it will actually call the equals() method of the first collection. This means that you can be more direct if you know that you're comparing two collection types by calling equals(). If you don't know what you're comparing, is() is the better choice.

Let's start by comparing some...

CONTINUE READING

83

Tech Concepts

36

Programming languages

73

Tech Tools

Unlimited access to the largest independent learning library in tech of over 8,000 expert-authored tech books and videos.

Innovative learning tools, including AI book assistants, code context explainers, and text-to-speech.

50+ new titles added per month and exclusive early access to books as they are being written.

Mastering Immutable.js

Search

Your notes and bookmarks