View on GitHub


ES6 Object.observe with nested object support

Download this project as a .zip file Download this project as a tar.gz file

Build Status


Do you dream of observing a plain javascript object for changes and reacting to it later? Now you can.

Available in Node >= 0.11.13, the standards compliant Object.observe treasure resides.

Object.observe allows us to register a listener for any type of change to a given object.

var o = { name: 'harmony' };
Object.observe(o, function (changes) {
}) = 'ES6!'
o.kind = 'observed';

// logs..
// [ { type: 'update',
//     object: { name: 'ES6!', kind: 'observed' },
//     name: 'name',
//     oldValue: 'harmony' },
//   { type: 'add',
//     object: { name: 'ES6!', kind: 'observed' },
//     name: 'kind' } ]

You'll notice our callback received an array of all changes that occured. Cool. But what about nested objects? Do they get automatically observed as well?

var o = { nested: { deeper: true }};
Object.observe(o, function (changes) {
o.nested.deeper = false
// crickets ..

Turns out they don't. And that's what observed is for: watching object modifications without having to care about whether or not they have nested objects and arrays.


observed returns an EventEmitter which you listen to for changes. There are five classes of events, closely mirroring Object.observe

var O = require('observed')
var object = { name: {} }
var ee = O(object)

ee.on('add', console.log) = 'observed'

// logs
// { path: 'name.last',
//   name: 'last',
//   type: 'add',
//   object: { last: 'observed' },
//   value: 'observed',
//   oldValue: undefined }

You'll notice we now receive more information compared to Object.observe

You may also listen for changes to specific paths:

var O = require('observed')
var object = { name: { last: 'Heckmann', first: 'aaron' }}
var ee = O(object)

ee.on('update name.first', console.log) = 'Aaron'

// logs
// { path: 'name.first',
//   name: 'first',
//   type: 'update',
//   object: { last: 'Heckmann', first: 'Aaron' },
//   value: 'Aaron',
//   oldValue: 'aaron' }


There are occasions where we want to immediately force all pending changes to emit instead of waiting for the next turn of the event loop. observed has us covered here too. Just call its deliverChanges() method and all pending changes will emit.

var O = require('observed');
var obj = { movie: { title: 'Godzilla' }};
var ee = O(obj);

var emitted = false;
ee.on('change', function(){ emitted = true }); = 2014;
assert.equal(false, emitted);

assert.equal(true, emitted);
// :)

Use cases

  1. passing object changes down to a browser in realtime using something like primus.
  2. fanning out object changes across multiple nodes using something like axon.
  3. buffering changes and pass them off to your database of choice in one save action.


  1. Object tracking: Using ES6 Object.observe we provide support for rich object tracking without manual getters/setters.
  2. Unobtrusive: Your object remains untouched and you may work with it as a plain js object.
  3. Events: Receive an EventEmitter back which emits the following events:

Node version requirements

Object.observe is available by default in Node >= 0.11.13.

> node yourProgram.js

If you are running Node >= 0.11.0 < 0.11.13 you must run Node using the --harmony flag and use a 0.0.n version of this module.

> npm install observed@0.0.3
> node --harmony yourProgram.js


Run em with npm test