8000 Deploy 11c99b46a5c9e3d177ef5168621e4cde9ea00b09 to NPM branch · rplansky/immutable-js@eaa8040 · GitHub
[go: up one dir, main page]
Skip to content

Commit eaa8040

Browse files
author
Travis CI
committed
Deploy 11c99b4 to NPM branch
1 parent 3153ae1 commit eaa8040

File tree

1 file changed

+89
-89
lines changed

1 file changed

+89
-89
lines changed

‎README.md

Lines changed: 89 additions & 89 deletions
Original file line numberDiff line numberDiff line change
@@ -43,10 +43,10 @@ Then require it into any module.
4343

4444
<!-- runkit:activate -->
4545
```js
46-
const { Map } = require('immutable');
47-
const map1 = Map({ a: 1, b: 2, c: 3 });
48-
const map2 = map1.set('b', 50);
49-
map1.get('b') + " vs. " + map2.get('b'); // 2 vs. 50
46+
const { Map } = require('immutable')
47+
const map1 = Map({ a: 1, b: 2, c: 3 })
48+
const map2 = map1.set('b', 50)
49+
map1.get('b') + " vs. " + map2.get('b') // 2 vs. 50
5050
```
5151

5252
### Browser
@@ -68,7 +68,7 @@ Use a script tag to directly add `Immutable` to the global scope:
6868
```html
6969
<script src="immutable.min.js"></script>
7070
<script>
71-
var map1 = Immutable.Map({ a: 1, b: 2, c: 3 });
71+
var map1 = Immutable.Map({a:1, b:2, c:3});
7272
var map2 = map1.set('b', 50);
7373
map1.get('b'); // 2
7474
map2.get('b'); // 50
@@ -79,7 +79,7 @@ Or use an AMD-style loader (such as [RequireJS](http://requirejs.org/)):
7979

8080
```js
8181
require(['./immutable.min.js'], function (Immutable) {
82-
var map1 = Immutable.Map({ a: 1, b: 2, c: 3 });
82+
var map1 = Immutable.Map({a:1, b:2, c:3});
8383
var map2 = map1.set('b', 50);
8484
map1.get('b'); // 2
8585
map2.get('b'); // 50
@@ -108,7 +108,7 @@ lib. Include either `"target": "es2015"` or `"lib": "es2015"` in your
108108
const { Map } = require("immutable");
109109
const map1 = Map({ a: 1, b: 2, c: 3 });
110110
const map2 = map1.set('b', 50);
111-
map1.get('b') + " vs. " + map2.get('b'); // 2 vs. 50
111+
map1.get('b') + " vs. " + map2.get('b') // 2 vs. 50
112112
```
113113

114114
#### Using TypeScript with Immutable.js v3 and earlier:
@@ -120,7 +120,7 @@ via relative path to the type definitions at the top of your file.
120120
///<reference path='./node_modules/immutable/dist/immutable.d.ts'/>
121121
import Immutable from require('immutable');
122122
var map1: Immutable.Map<string, number>;
123-
map1 = Immutable.Map({ a: 1, b: 2, c: 3 });
123+
map1 = Immutable.Map({a:1, b:2, c:3});
124124
var map2 = map1.set('b', 50);
125125
map1.get('b'); // 2
126126
map2.get('b'); // 50
@@ -157,11 +157,11 @@ instead of the `===` operator which determines object *reference identity*.
157157

158158
<!-- runkit:activate -->
159159
```js
160-
const { Map } = require('immutable');
161-
const map1 = Map({ a: 1, b: 2, c: 3 });
162-
const map2 = Map({ a: 1, b: 2, c: 3 });
163-
map1.equals(map2); // true
164-
map1 === map2; // false
160+
const { Map } = require('immutable')
161+
const map1 = Map({ a: 1, b: 2, c: 3 })
162+
const map2 = Map({ a: 1, b: 2, c: 3 })
163+
map1.equals(map2) // true
164+
map1 === map2 // false
165165
```
166166

167167
Note: As a performance optimization Immutable.js attempts to return the existing
@@ -174,10 +174,10 @@ potentially be more costly. The `===` equality check is also used internally by
174174

175175
<!-- runkit:activate -->
176176
```js
177-
const { Map } = require('immutable');
178-
const map1 = Map({ a: 1, b: 2, c: 3 });
179-
const map2 = map1.set('b', 2); // Set to same value
180-
map1 === map2; // true
177+
const { Map } = require('immutable')
178+
const map1 = Map({ a: 1, b: 2, c: 3 })
179+
const map2 = map1.set('b', 2) // Set to same value
180+
map1 === map2 // true
181181
```
182182

183183
If an object is immutable, it can be "copied" simply by making another reference
@@ -187,8 +187,8 @@ execution speed for programs which rely on copies (such as an undo-stack).
187187

188188
<!-- runkit:activate -->
189189
```js
190-
const { Map } = require('immutable');
191-
const map = Map({ a: 1, b: 2, c: 3 });
190+
const { Map } = require('immutable')
191+
const map = Map({ a: 1, b: 2, c: 3 })
192192
const mapCopy = map; // Look, "copies" are free!
193193
```
194194

@@ -216,7 +216,7 @@ instead return new immutable collections.
216216

217217
<!-- runkit:activate -->
218218
```js
219-
const { List } = require('immutable');
219+
const { List } = require('immutable')
220220
const list1 = List([ 1, 2 ]);
221221
const list2 = list1.push(3, 4, 5);
222222
const list3 = list2.unshift(0);
@@ -235,7 +235,7 @@ and `map()`.
235235

236236
<!-- runkit:activate -->
237237
```js
238-
const { Map } = require('immutable');
238+
const { Map } = require('immutable')
239239
const alpha = Map({ a: 1, b: 2, c: 3, d: 4 });
240240
alpha.map((v, k) => k.toUpperCase()).join();
241241
// 'A,B,C,D'
@@ -249,16 +249,16 @@ accepts plain JavaScript Arrays and Objects anywhere a method expects a
249249

250250
<!-- runkit:activate -->
251251
```js
252-
const { Map, List } = require('immutable');
253-
const map1 = Map({ a: 1, b: 2, c: 3, d: 4 });
254-
const map2 = Map({ c: 10, a: 20, t: 30 });
255-
const obj = { d: 100, o: 200, g: 300 };
252+
const { Map, List } = require('immutable')
253+
const map1 = Map({ a: 1, b: 2, c: 3, d: 4 })
254+
const map2 = Map({ c: 10, a: 20, t: 30 })
255+
const obj = { d: 100, o: 200, g: 300 }
256256
const map3 = map1.merge(map2, obj);
257257
// Map { a: 20, b: 2, c: 10, d: 100, t: 30, o: 200, g: 300 }
258-
const list1 = List([ 1, 2, 3 ]);
259-
const list2 = List([ 4, 5, 6 ]);
260-
const array = [ 7, 8, 9 ];
261-
const list3 = list1.concat(list2, array);
258+
const list1 = List([ 1, 2, 3 ])
259+
const list2 = List([ 4, 5, 6 ])
260+
const array = [ 7, 8, 9 ]
261+
const list3 = list1.concat(list2, array)
262262
// List [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]
263263
```
264264

@@ -270,8 +270,8 @@ results, these operations can be extremely efficient.
270270

271271
<!-- runkit:activate -->
272272
```js
273-
const { Seq } = require('immutable');
274-
const myObject = { a: 1, b: 2, c: 3 };
273+
const { Seq } = require('immutable')
274+
const myObject = { a: 1, b: 2, c: 3 }
275275
Seq(myObject).map(x => x * x).toObject();
276276
// { a: 1, b: 4, c: 9 }
277277
```
@@ -282,14 +282,14 @@ shorthand, while Immutable Maps accept keys of any type.
282282

283283
<!-- runkit:activate -->
284284
```js
285-
const { fromJS } = require('immutable');
285+
const { fromJS } = require('immutable')
286286

287-
const obj = { 1: "one" };
288-
console.log(Object.keys(obj)); // [ "1" ]
289-
console.log(obj["1"], obj[1]); // "one", "one"
287+
const obj = { 1: "one" }
288+
console.log(Object.keys(obj)) // [ "1" ]
289+
console.log(obj["1"], obj[1]) // "one", "one"
290290

291-
const map = fromJS(obj);
292-
console.log(map.get("1"), map.get(1)); // "one", undefined
291+
const map = fromJS(obj)
292+
console.log(map.get("1"), map.get(1)) // "one", undefined
293293
```
294294

295295
Property access for JavaScript Objects first converts the key to a string, but
@@ -307,12 +307,12 @@ nested objects.
307307

308308
<!-- runkit:activate -->
309309
```js
310-
const { Map, List } = require('immutable');
311-
const deep = Map({ a: 1, b: 2, c: List([ 3, 4, 5 ]) });
312-
console.log(deep.toObject()); // { a: 1, b: 2, c: List [ 3, 4, 5 ] }
313-
console.log(deep.toArray()); // [ 1, 2, List [ 3, 4, 5 ] ]
314-
console.log(deep.toJS()); // { a: 1, b: 2, c: [ 3, 4, 5 ] }
315-
JSON.stringify(deep); // '{"a":1,"b":2,"c":[3,4,5]}'
310+
const { Map, List } = require('immutable')
311+
const deep = Map({ a: 1, b: 2, c: List([ 3, 4, 5 ]) })
312+
console.log(deep.toObject()) // { a: 1, b: 2, c: List [ 3, 4, 5 ] }
313+
console.log(deep.toArray()) // [ 1, 2, List [ 3, 4, 5 ] ]
314+
console.log(deep.toJS()) // { a: 1, b: 2, c: [ 3, 4, 5 ] }
315+
JSON.stringify(deep) // '{"a":1,"b":2,"c":[3,4,5]}'
316316
```
317317

318318
### Embraces ES2015
@@ -338,9 +338,9 @@ used anywhere an Iterable is expected, such as when spreading into an Array.
338338

339339
<!-- runkit:activate -->
340340
```js
341-
const { List } = require('immutable');
342-
const aList = List([ 1, 2, 3 ]);
343-
const anArray = [ 0, ...aList, 4, 5 ]; // [ 0, 1, 2, 3, 4, 5 ]
341+
const { List } = require('immutable')
342+
const aList = List([ 1, 2, 3 ])
343+
const anArray = [ 0, ...aList, 4, 5 ] // [ 0, 1, 2, 3, 4, 5 ]
344344
```
345345

346346
Note: A Collection is always iterated in the same order, however that order may
@@ -360,8 +360,8 @@ trees of data, similar to JSON.
360360

361361
<!-- runkit:activate -->
362362
```js
363-
const { fromJS } = require('immutable');
364-
const nested = fromJS({ a: { b: { c: [ 3, 4, 5 ] } } });
363+
const { fromJS } = require('immutable')
364+
const nested = fromJS({ a: { b: { c: [ 3, 4, 5 ] } } })
365365
// Map { a: Map { b: Map { c: List [ 3, 4, 5 ] } } }
366366
```
367367

@@ -371,19 +371,19 @@ most useful are `mergeDeep`, `getIn`, `setIn`, and `updateIn`, found on `List`,
371371

372372
<!-- runkit:activate -->
373373
```js
374-
const { fromJS } = require('immutable');
375-
const nested = fromJS({ a: { b: { c: [ 3, 4, 5 ] } } });
374+
const { fromJS } = require('immutable')
375+
const nested = fromJS({ a: { b: { c: [ 3, 4, 5 ] } } })
376376

377-
const nested2 = nested.mergeDeep({ a: { b: { d: 6 } } });
377+
const nested2 = nested.mergeDeep({ a: { b: { d: 6 } } })
378378
// Map { a: Map { b: Map { c: List [ 3, 4, 5 ], d: 6 } } }
379379

380-
console.log(nested2.getIn([ 'a', 'b', 'd' ])); // 6
380+
console.log(nested2.getIn([ 'a', 'b', 'd' ])) // 6
381381

382-
const nested3 = nested2.updateIn([ 'a', 'b', 'd' ], value => value + 1);
382+
const nested3 = nested2.updateIn([ 'a', 'b', 'd' ], value => value + 1)
383383
console.log(nested3);
384384
// Map { a: Map { b: Map { c: List [ 3, 4, 5 ], d: 7 } } }
385385

386-
const nested4 = nested3.updateIn([ 'a', 'b', 'c' ], list => list.push(6));
386+
const nested4 = nested3.updateIn([ 'a', 'b', 'c' ], list => list.push(6))
387387
// Map { a: Map { b: Map { c: List [ 3, 4, 5, 6 ], d: 7 } } }
388388
```
389389

@@ -403,28 +403,28 @@ Consider the example below where two identical `Map` instances are not
403403
<!-- runkit:activate -->
404404
```js
405405
// First consider:
406-
const obj1 = { a: 1, b: 2, c: 3 };
407-
const obj2 = { a: 1, b: 2, c: 3 };
408-
obj1 !== obj2; // two different instances are always not equal with ===
409-
410-
const { Map, is } = require('immutable');
411-
const map1 = Map({ a: 1, b: 2, c: 3 });
412-
const map2 = Map({ a: 1, b: 2, c: 3 });
413-
map1 !== map2; // two different instances are not reference-equal
414-
map1.equals(map2); // but are value-equal if they have the same values
415-
is(map1, map2); // alternatively can use the is() function
406+
const obj1 = { a: 1, b: 2, c: 3 }
407+
const obj2 = { a: 1, b: 2, c: 3 }
408+
obj1 !== obj2 // two different instances are always not equal with ===
409+
410+
const { Map, is } = require('immutable')
411+
const map1 = Map({ a: 1, b: 2, c: 3 })
412+
const map2 = Map({ a: 1, b: 2, c: 3 })
413+
map1 !== map2 // two different instances are not reference-equal
414+
map1.equals(map2) // but are value-equal if they have the same values
415+
is(map1, map2) // alternatively can use the is() function
416416
```
417417

418418
Value equality allows Immutable.js collections to be used as keys in Maps or
419419
values in Sets, and retrieved with different but equivalent collections:
420420

421421
<!-- runkit:activate -->
422422
```js
423-
const { Map, Set } = require('immutable');
424-
const map1 = Map({ a: 1, b: 2, c: 3 });
425-
const map2 = Map({ a: 1, b: 2, c: 3 });
426-
const set = Set().add(map1);
427-
set.has(map2); // true because these are value-equal
423+
const { Map, Set } = require('immutable')
424+
const map1 = Map({ a: 1, b: 2, c: 3 })
425+
const map2 = Map({ a: 1, b: 2, c: 3 })
426+
const set = Set().add(map1)
427+
set.has(map2) // true because these are value-equal
428428
```
429429

430430
Note: `is()` uses the same measure of equality as [Object.is][] for scalar
@@ -459,10 +459,10 @@ to quickly determine if no change occurred.
459459

460460
<!-- runkit:activate -->
461461
```js
462-
const { Map } = require('immutable');
463-
const originalMap = Map({ a: 1, b: 2, c: 3 });
464-
const updatedMap = originalMap.set('b', 2);
465-
updatedMap === originalMap; // No-op .set() returned the original reference.
462+
const { Map } = require('immutable')
463+
const originalMap = Map({ a: 1, b: 2, c: 3 })
464+
const updatedMap = originalMap.set('b', 2)
465+
updatedMap === originalMap // No-op .set() returned the original reference.
466466
```
467467

468468
However updates which do result in a change will return a new reference. Each
@@ -471,16 +471,16 @@ the same reference:
471471

472472
<!-- runkit:activate -->
473473
```js
474-
const { Map } = require('immutable');
475-
const originalMap = Map({ a: 1, b: 2, c: 3 });
476-
const updatedMap = originalMap.set('b', 1000);
474+
const { Map } = require('immutable')
475+
const originalMap = Map({ a: 1, b: 2, c: 3 })
476+
const updatedMap = originalMap.set('b', 1000)
477477
// New instance, leaving the original immutable.
478-
updatedMap !== originalMap;
479-
const anotherUpdatedMap = originalMap.set('b', 1000);
478+
updatedMap !== originalMap
479+
const anotherUpdatedMap = originalMap.set('b', 1000)
480480
// Despite both the results of the same operation, each created a new reference.
481-
anotherUpdatedMap !== updatedMap;
481+
anotherUpdatedMap !== updatedMap
482482
// However the two are value equal.
483-
anotherUpdatedMap.equals(updatedMap);
483+
anotherUpdatedMap.equals(updatedMap)
484484
```
485485

486486
Batching Mutations
@@ -505,7 +505,7 @@ immutable Lists.
505505

506506
<!-- runkit:activate -->
507507
```js
508-
const { List } = require('immutable');
508+
const { List } = require('immutable')
509509
const list1 = List([ 1, 2, 3 ]);
510510
const list2 = list1.withMutations(function (list) {
511511
list.push(4).push(5).push(6);
@@ -545,10 +545,10 @@ For example, the following performs no work, because the resulting
545545
`Seq`'s values are never iterated:
546546

547547
```js
548-
const { Seq } = require('immutable');
548+
const { Seq } = require('immutable')
549549
const oddSquares = Seq([ 1, 2, 3, 4, 5, 6, 7, 8 ])
550550
.filter(x => x % 2 !== 0)
551-
.map(x => x * x);
551+
.map(x => x * x)
552552
```
553553

554554
Once the `Seq` is used, it performs only the work 10B8B necessary. In this
@@ -563,9 +563,9 @@ Any collection can be converted to a lazy Seq with `Seq()`.
563563

564564
<!-- runkit:activate -->
565565
```js
566-
const { Map, Seq } = require('immutable');
567-
const map = Map({ a: 1, b: 2, c: 3 });
568-
const lazySeq = Seq(map);
566+
const { Map, Seq } = require('immutable')
567+
const map = Map({ a: 1, b: 2, c: 3 })
568+
const lazySeq = Seq(map)
569569
```
570570

571571
`Seq` allows for the efficient chaining of operations, allowing for the
@@ -575,7 +575,7 @@ expression of logic that can otherwise be very tedious:
575575
lazySeq
576576
.flip()
577577
.map(key => key.toUpperCase())
578-
.flip();
578+
.flip()
579579
// Seq { A: 1, B: 1, C: 1 }
580580
```
581581

@@ -584,13 +584,13 @@ limited, for example `Range` is a special kind of Lazy sequence.
584584

585585
<!-- runkit:activate -->
586586
```js
587-
const { Range } = require('immutable');
587+
const { Range } = require('immutable')
588588
Range(1, Infinity)
589589
.skip(1000)
590590
.map(n => -n)
591591
.filter(n => n % 2 === 0)
592592
.take(2)
593-
.reduce((r, n) => r * n, 1);
593+
.reduce((r, n) => r * n, 1)
594594
// 1006008
595595
```
596596

0 commit comments

Comments
 (0)
0