Listening for variable changes in JavaScript

This question was originally posted in 2009 and most of the existing answers are either outdated, ineffective, or require the inclusion of large bloated libraries:

• Object.watch and Object.observe are both deprecated and should not be used.
• onPropertyChange is a DOM element event handler that only works in some versions of IE.
• Object.defineProperty allows you to make an object property immutable, which would allow you to detect attempted changes, but it would also block any changes.
• Defining setters and getters works, but it requires a lot of setup code and it does not work well when you need to delete or create new properties.

As of 2018, you can now use the Proxy object to monitor (and intercept) changes made to an object. It is purpose built for what the OP is trying to do. Here's a basic example:

var targetObj = {};var targetProxy = new Proxy(targetObj, {  set: function (target, key, value) {      console.log(`${key} set to ${value}`);      target[key] = value;      return true;  }});targetProxy.hello_world = "test"; // console: 'hello_world set to test'

The only drawbacks of the Proxy object are:

1. The Proxy object is not available in older browsers (such as IE11) and the polyfill cannot fully replicate Proxy functionality.
2. Proxy objects do not always behave as expected with special objects (e.g., Date) -- the Proxy object is best paired with plain Objects or Arrays.

If you need to observe changes made to a nested object, then you need to use a specialized library such as Observable Slim (which I have published). It works like this:

var test = {testing:{}};var p = ObservableSlim.create(test, true, function(changes) {    console.log(JSON.stringify(changes));});p.testing.blah = 42; // console:  [{"type":"add","target":{"blah":42},"property":"blah","newValue":42,"currentPath":"testing.blah",jsonPointer:"/testing/blah","proxy":{"blah":42}}] 

Yes, this is now completely possible!

I know this is an old thread but now this effect is possible using accessors (getters and setters): https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Working_with_Objects#Defining_getters_and_setters

You can define an object like this, in which aInternal represents the field a:

x = {  aInternal: 10,  aListener: function(val) {},  set a(val) {    this.aInternal = val;    this.aListener(val);  },  get a() {    return this.aInternal;  },  registerListener: function(listener) {    this.aListener = listener;  }}

Then you can register a listener using the following:

x.registerListener(function(val) {  alert("Someone changed the value of x.a to " + val);});

So whenever anything changes the value of x.a, the listener function will be fired. Running the following line will bring the alert popup:

x.a = 42;

See an example here: https://jsfiddle.net/5o1wf1bn/1/

You can also user an array of listeners instead of a single listener slot, but I wanted to give you the simplest possible example.

No.

But, if it's really that important, you have 2 options (first is tested, second isn't):

First, use setters and getters, like so:

var myobj = {a : 1};function create_gets_sets(obj) { // make this a framework/global function    var proxy = {}    for ( var i in obj ) {        if (obj.hasOwnProperty(i)) {            var k = i;            proxy["set_"+i] = function (val) { this[k] = val; };            proxy["get_"+i] = function ()    { return this[k]; };        }    }    for (var i in proxy) {        if (proxy.hasOwnProperty(i)) {            obj[i] = proxy[i];        }    }}create_gets_sets(myobj);

then you can do something like:

function listen_to(obj, prop, handler) {    var current_setter = obj["set_" + prop];    var old_val = obj["get_" + prop]();    obj["set_" + prop] = function(val) { current_setter.apply(obj, [old_val, val]); handler(val));}

then set the listener like:

listen_to(myobj, "a", function(oldval, newval) {    alert("old : " + oldval + " new : " + newval);}

Second, you could put a watch on the value:

Given myobj above, with 'a' on it:

function watch(obj, prop, handler) { // make this a framework/global function    var currval = obj[prop];    function callback() {        if (obj[prop] != currval) {            var temp = currval;            currval = obj[prop];            handler(temp, currval);        }    }    return callback;}var myhandler = function (oldval, newval) {    //do something};var intervalH = setInterval(watch(myobj, "a", myhandler), 100);myobj.set_a(2);