immutable
Advanced tools
Package description
The immutable npm package provides persistent immutable data structures that do not change once created, enabling advanced memoization, change detection, and functional programming techniques. It offers a variety of data structures such as List, Map, Set, and Record.
Persistent Immutable List
Create and manipulate immutable lists, where modifications return new lists without altering the original.
const { List } = require('immutable');
const list1 = List([1, 2, 3]);
const list2 = list1.push(4);
console.log(list1.size); // 3
console.log(list2.size); // 4Persistent Immutable Map
Create and manipulate immutable maps, with key-value pairs. Changes produce new maps without changing the original.
const { Map } = require('immutable');
const map1 = Map({ a: 1, b: 2, c: 3 });
const map2 = map1.set('b', 50);
console.log(map1.get('b')); // 2
console.log(map2.get('b')); // 50Persistent Immutable Set
Create and manipulate immutable sets, which are collections of unique values. Adding existing values does not change the set.
const { Set } = require('immutable');
const set1 = Set([1, 2, 3]);
const set2 = set1.add(3).add(4);
console.log(set1.has(3)); // true
console.log(set2.has(4)); // trueRecord Factory
Define 'Record' factories to create immutable records with default values and specific shapes.
const { Record } = require('immutable');
const Person = Record({ name: null, age: null });
const person1 = new Person({ name: 'Alice', age: 30 });
const person2 = person1.set('name', 'Bob');
console.log(person1.name); // Alice
console.log(person2.name); // BobMori is a library that provides immutable data structures and functional programming utilities. It is similar to immutable but wraps the ClojureScript's data structures and has a different API.
Immer offers a different approach to immutable data. Instead of persistent data structures, it allows you to work with the standard JavaScript data structures in an immutable way by using a draft state and producing the next immutable state.
Seamless-immutable provides immutability for arrays and objects without introducing new data structures. It is simpler and has a smaller API surface compared to immutable, but it does not offer the same level of functional programming support.
Readme
Warning: API Unstable (even more so than most < 1.0.0 releases)
immutable neatly packages immutable equivalents to JavaScript's Objects and Arrays.
Mutability causes headaches; immutability soothes them. JavaScript's Object and Array are crying out for immutable counterparts to complement first-class functions.
Current support is limited to ECMAScript 5 compliant environments; although ECMAScript 3 compliance is a goal of this project.
var i = require('immutable'),
person = i.object({ firstName: 'hugh', secondName: 'jackson' })
var personWithAge = person.set({ age: 24 })
person.has('age') //= false
personWithAge.has('age') //= true
personWithAge.get('age') //= 24
npm install immutable
Creates an empty object, or sets the attributes if an object is passed.
var o = i.object()
// or
var you = i.object({ wise: true, willUseThisLib: true })
Returns a new object with the additional attribute(s).
var o = i.object()
var changed = o.set('x', 3).set({ y: 4, z: 5 })
changed.has('x') //= true
changed.get('y') //= 4
Gets an attribute.
var o = i.object({ x: 3, y: 4 })
o.get('x') //= 3
Returns true or false; same as key in object for regular objects:
var o = i.object({ x: 3, y: 4 })
o.has('x') //= true
o.has('z') //= false
alias: .delete(String) -> objectReturns a new object with the key removed.
var o = i.object({
foo: 'bar',
baz: 'quux'
})
var updated = o.remove('foo').remove('baz')
updated.has('foo') //= false
o.has('foo') //= true
Returns a seperate, mutable object with the same attrs.
var o = i.object({
foo: 'bar',
baz: 'quux'
})
var trans = o.transient()
delete trans.foo
o.has('foo') //= true
Shares the same API as immutable.object, except:
Returns a seperate, mutable array with the same attrs.
var arr1 = i.array([1, 2, 3]),
arr2 = arr1.transient()
arr2.splice(1)
arr1[1] !== arr2[1] //= true
The following native methods return a new instance of i.array:
The following native methods work as expected for a regular array:
Based on Bagwell (2001), and Clojure's immutable implementation of a Hash Array Mapped Trie.
FAQs
Immutable Data Collections
We found that immutable demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
ESLint has approved an RFC that adds support for TypeScript configuration files, which is aimed at improving the developer experience and recognizing changes in the evolving JavaScript ecosystem.
Security News
The NVD is facing a significant backlog with over 12,500 CVEs awaiting analysis, and more than 50% of known exploited vulnerabilities (KEVs) left unenriched since mid-February.
Security News
Ransomware costs victims an estimated $30 billion per year and has gotten so out of control that global support for banning payments is gaining momentum.