Sorting Collections | 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

Maintaining sort order

If your application has collections that are always sorted, then you need a way to maintain that sort order. This means that once you add or change values in a collection, you have to make sure that the collection is still in the order that you expected.

Finding the insertion index

Let's say that you want to add a value to a list that's already sorted. Using push() will insert the value at the end of the list, and this isn't what you want. The insert() method can put the value at a particular index—you just have to figure out which index to use to keep the list sorted:

const sortedInsert = (item, list) => {
  let low = 0;
  let high = list.count();

  while (low < high) {
    const mid = (low + high) >>> 1;
    if (item > list.get(mid)) {
      low = mid + 1;
    } else {
      high = mid;
    }
  }
  return list.insert(low, item);
};

The sortedIndex() function takes a value and a list into which to insert the value as arguments. It then does a simple...

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