Is there some way to add meta-data to JavaScript objects?

Question

I would like to add key-value pairs of metadata to arbitrary JavaScript objects. This metadata should not affect code that is not aware of the metadata, that means for example

JSON.stringify(obj) === JSON.stringify(obj.WithMetaData('key', 'value'))

MetaData aware code should be able to retrieve the data by key, i.e.

obj.WithMetaData('key', 'value').GetMetaData('key') === 'value'

Is there any way to do it - in node.js? If so, does it work with builtin types such as String and even Number? (Edit Thinking about it, I don't care about real primitives like numbers, but having that for string instances would be nice).

Some Background: What I'm trying to do is cache values that are derived from an object with the object itself, so that

• to meta data unaware code, the meta data enriched object will look the same as the original object w/o meta
• code that needs the derived values can get it out of the meta-data if already cached
• the cache will get garbage collected alongside the object

Another way would be to store a hash table with the caches somewhere, but you'd never know when the object gets garbage collected. Every object instance would have to be taken care of manually, so that the caches don't leak.

(btw clojure has this feature: http://clojure.org/metadata)

Answer 1

ES6 spec introduces Map and WeakMap. You can enable these in node by running node --harmony and by enabling the experimental javascript flag in Chrome, (it's also in Firefox by default). Maps and WeakMaps allow objects to be used as keys which can be be used to store metadata about objects that isn't visible to anyone without access to the specific map/weakmap. This is a pattern I now use a lot:

function createStorage(creator){
  creator = creator || Object.create.bind(null, null, {});
  var map = new Map;
  return function storage(o, v){
    if (1 in arguments) {
      map.set(o, v);
    } else {
      v = map.get(o);
      if (v == null) {
        v = creator(o);
        map.set(o, v);
      }
    }
    return v;
  };
}

Use is simple and powerful:

var _ = createStorage();

_(someObject).meta= 'secret';
_(5).meta = [5];
var five = new Number(5);
_(five).meta = 'five';

console.log(_(someObject).name);
console.log(_(5).meta);
console.log(_(five).meta);

It also facilitates some interesting uses for separating implementation from interface:

var _ = createStorage(function(o){ return new Backing(o) });

function Backing(o){
  this.facade = o;
}
Backing.prototype.doesStuff = function(){
  return 'real value';
}

function Facade(){
  _(this);
}
Facade.prototype.doSomething = function doSomething(){
  return _(this).doesStuff();
}

Answer 2

There is no "comment" system in JSON. The best you can hope for is to add a property with an unlikely name, and add that key contaning the metadata. You can then read the metadata back out if you know it's metadata, but other setups will just see it as another property. And if someone uses for..in...

Answer 3

You could just add the Metadata as a "private" variable!?

var Obj = function (meta) {
    var meta = meta;
    this.getMetaData = function (key) {
        //do something with the meta object
        return meta;
    };
};
var ins_ob = new Obj({meta:'meta'});
var ins_ob2 = new Obj();
if(JSON.stringify(ins_ob) === JSON.stringify(ins_ob2)) {
    console.log('hoorai');
};

Answer 4

If you want object-level metadata, you could create a class that extends Object. Getters and setters are not enumerable and, obviously, neither are private fields.

class MetadataObject extends Object {
  #metadata = undefined;
  
  get metadata() { return this.#metadata; }
  set metadata(value) { this.#metadata; }
}

var obj = new MetadataObject();
obj.a = 1;
obj.b = 2;
obj.metadata = { test: 123 };

console.log(obj); // { a: 1, b: 2 }
console.log(obj.metadata); // { test: 123 }
console.log(JSON.stringify(obj)); // '{"a":1,"b":2}'

You can even simplify the implementation using a Map. Without a setter on metadata, you have to use Map methods to modify it.

class MetadataObject extends Object {
  #metadata = new Map();
  
  get metadata() { return this.#metadata; }
}

var obj = new MetadataObject();
obj.a = 1;
obj.b = 2;
obj.metadata.set('test', 123);

console.log(obj); // { a: 1, b: 2 }
console.log(obj.metadata.get('test')); // 123
console.log(JSON.stringify(obj)); // '{"a":1,"b":2}'

I ran into a situation where I needed property level metadata, and used the latter implementation.

obj.id = 1;
obj.metadata.set('id', 'metadata for the id property');