You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
63 lines
2.8 KiB
63 lines
2.8 KiB
11 years ago
|
---
|
||
|
|
id: update
|
||
|
|
title: Immutability Helpers
|
||
|
|
layout: docs
|
||
|
|
permalink: update.html
|
||
|
|
prev: clone-with-props.html
|
||
|
|
---
|
||
|
|
|
||
|
|
React lets you use whatever style of data management you want, including mutation. However, if you can use immutable data in performance-critical parts of your application it's easy to implement a fast `shouldComponentUpdate()` method to significantly speed up your app.
|
||
|
|
|
||
|
|
Dealing with immutable data in JavaScript is more difficult than in languages designed for it, like [Clojure](http://clojure.org/). However, we've provided a simple immutability helper, `update()`, that makes dealing with this type of data much easier, *without* fundamentally changing how your data is represented.
|
||
|
|
|
||
|
|
## The main idea
|
||
|
|
|
||
|
|
If you mutate data like this:
|
||
|
|
|
||
|
|
```javascript
|
||
|
|
myData.x.y.z = 7;
|
||
|
|
myData.a.b.push(9);
|
||
|
|
```
|
||
|
|
|
||
|
|
you have no way of determining which data has changed since the previous copy is destroyed. Instead, you need to create a new copy of `myData` and change only the parts of it that need to be changed. Then you can compare the old copy of `myData` with the new one in `shouldComponentUpdate()` using triple-equals:
|
||
|
|
|
||
|
|
```javascript
|
||
|
|
var newData = deepCopy(myData);
|
||
|
|
newData.x.y.z = 7;
|
||
|
|
newData.a.b.push(9);
|
||
|
|
```
|
||
|
|
|
||
|
|
Unfortunately, deep copies are expensive, and sometimes impossible. You can alleviate this by only copying objects that need to be changed and by reusing the objects that haven't changed. Unfortunately, in today's JavaScript this can be cumbersome:
|
||
|
|
|
||
|
|
```javascript
|
||
|
|
var newData = extend(myData, {
|
||
|
|
x: extend(myData.x, {
|
||
|
|
y: extend(myData.x.y, {z: 7}),
|
||
|
|
}),
|
||
|
|
a: extend(myData.a, {b: myData.a.b.concat(9)})
|
||
|
|
});
|
||
|
|
```
|
||
|
|
|
||
|
|
While this is fairly performant (since it only shallow copies `log n` objects and reuses the rest), it's a big pain to write. Look at all the repetition! This is not only annoying, but also provides a large surface area for bugs.
|
||
|
|
|
||
|
|
`update() provides simple syntactic sugar around this pattern to make writing this code easier. This code becomes:
|
||
|
|
|
||
|
|
```javascript
|
||
|
|
var newData = React.addons.update(myData, {
|
||
|
|
x: {y: {z: {$set: 7}}},
|
||
|
|
a: {b: {$push: [7]}}
|
||
|
|
});
|
||
|
|
```
|
||
|
|
|
||
|
|
While the syntax takes a little getting used to (though it's inspired by [MongoDB's query language](http://docs.mongodb.org/manual/core/crud-introduction/#query)) there's no redundancy, it's statically analyzable and it's not much more typing than the mutative version.
|
||
|
|
|
||
|
|
The `$`-prefixed keys are called *directives*. The data structure they are "mutating" is called the *target*.
|
||
|
|
|
||
|
|
## Available directives
|
||
|
|
|
||
|
|
* `{$push: array}` `push()` all the items in `array` on the target
|
||
|
|
* `{$unshift: array}` `unshift()` all the items in `array` on the target
|
||
|
|
* `{$splice: array of arrays}` for each item in `array()` call `splice()` on the target with the parameters provided by the item.
|
||
|
|
* `{$set: any}` replace the target entirely
|
||
|
|
* `{$merge: object}` merge the keys of `object` with the target
|