ReactiveDict
A ReactiveDict stores an arbitrary set of key-value pairs. Use it to manage
internal state in your components, ie. like the currently selected item in a list.
Each key is individully reactive such that calling set
for a key will
invalidate any Computations that called get
with that key, according to the
usual contract for reactive data sources.
That means if you call ReactiveDict#get
('currentList')
from inside a Blaze template helper, the template will automatically be rerendered
whenever ReactiveDict#set
('currentList', x)
is called.
To use ReactiveDict
, add the reactive-dict
package to your project by running
in your terminal:
meteor add reactive-dict
new ReactiveDict([name], [initialValue])
Constructor for a ReactiveDict, which represents a reactive dictionary of key/value pairs.
Arguments
- name String
-
Optional. When a name is passed, preserves contents across Hot Code Pushes
- initialValue Object
-
Optional. The default values for the dictionary
If you provide a name to its constructor, its contents will be saved across Hot Code Push client code updates.
Set a value for a key in the ReactiveDict. Notify any listeners
that the value has changed (eg: redraw templates, and rerun any
Tracker.autorun
computations, that called
ReactiveDict.get
on this key
.)
Arguments
- key String
-
The key to set, eg,
selectedItem
- value EJSON-able Object or undefined
-
The new value for
key
Example:
const state = new ReactiveDict();
state.set('currentRoomId', 'random')
Tracker.autorun(() => {
Meteor.subscribe('chatHistory', { room: state.get('currentRoomId') });
});
// Causes the function passed to `Tracker.autorun` to be rerun, so that the
// 'chatHistory' subscription is moved to the room 'general'.
state.set('currentRoomId', 'general');
ReactiveDict.set
can also be called with an object of keys and values, which is
equivalent to calling ReactiveDict.set
individually on each key/value pair.
const state = new ReactiveDict();
state.set({
a: 'foo',
b: 'bar'
});
Set a value for a key if it hasn't been set before.
Otherwise works exactly the same as ReactiveDict.set
.
Arguments
- key String
-
The key to set, eg,
selectedItem
- value EJSON-able Object or undefined
-
The new value for
key
This is useful in initialization code, to avoid re-initializing your state every time a new version of your app is loaded.
Get the value assiciated with a key. If inside a reactive
computation, invalidate the computation the next time the
value associated with this key is changed by
ReactiveDict.set
.
This returns a clone of the value, so if it's an object or an array,
mutating the returned value has no effect on the value stored in the
ReactiveDict.
Arguments
- key String
-
The key of the element to return
Example:
<!-- main.html -->
<template name="main">
<p>We've always been at war with {{theEnemy}}.</p>
<button class="change-enemy">Change Enemy</button>
</template>
// main.js
Template.main.onCreated(function () {
this.state = new ReactiveDict();
this.state.set('enemy', 'Eastasia');
});
Template.main.helpers({
theEnemy() {
const inst = Template.instance();
return inst.state.get('enemy');
}
});
Template.main.events({
'click .change-enemy'(event, inst) {
inst.state.set('enemy', 'Eurasia')
}
});
// Clicking the button will change the page to say "We've always been at war with Eurasia"
remove a key-value pair from the ReactiveDict. Notify any listeners
that the value has changed (eg: redraw templates, and rerun any
Tracker.autorun
computations, that called
ReactiveDict.get
on this key
.)
Arguments
- key String
-
The key to delete, eg,
selectedItem
Test if the stored entry for a key is equal to a value. If inside a reactive computation, invalidate the computation the next time the variable changes to or from the value.
Arguments
- key String
-
The name of the session variable to test
- value String, Number, Boolean, null, or undefined
-
The value to test against
If value is a scalar, then these two expressions do the same thing:
const state = new ReactiveDict()
// ...
state.get('key') === value
state.equals('key', value)
However, the second is recommended, as it triggers fewer invalidations (template redraws), making your program more efficient.
Get all key-value pairs as a plain object. If inside a reactive
computation, invalidate the computation the next time the
value associated with any key is changed by
ReactiveDict.set
.
This returns a clone of each value, so if it's an object or an array,
mutating the returned value has no effect on the value stored in the
ReactiveDict.
remove all key-value pairs from the ReactiveDict. Notify any
listeners that the value has changed (eg: redraw templates, and rerun any
Tracker.autorun
computations, that called
ReactiveDict.get
on this key
.)
Clear all values from the reactiveDict and prevent it from being
migrated on a Hot Code Pushes. Notify any listeners
that the value has changed (eg: redraw templates, and rerun any
Tracker.autorun
computations, that called
ReactiveDict.get
on this key
.)