How to get the identity of an object in Javascript?

Question

Several languages have a means of obtaining the "identity" of an object, i.e. an [integer] number that is unique to each object, such that different objects have different identities. Examples:

• Java (System.identityHashCode)

As far as reasonably practical, the hashcode method defined by the Object class returns distinct integers for distinct objects. (This is typically implemented by converting the object’s internal address into an integer, but this implementation technique is not required by the Java programming language.)

• Python (id)

Returns the "identity" of an object. This is an integer (or long integer) that is guaranteed to be unique and constant to that object during its life cycle. Two objects with non-overlapping lifetimes can have the same value for id().

Is there similar functionality in Javascript? Preferably standardized, that worked in all browsers and other environments (Rhino, V8). Searching for "Identity" I only find references to the operator (===)...

I know that some environments do not support this concept (.NET apparently does not do so for reasons of optimization), but in general this is not a problem because they are more complete languages, which have the concepts of destructor, finisher and/or weak references. As far as I know, Javascript does not support this, so a way to get a numeric value that only represents an object would be very useful (a simple reference to the object does not serve as it would prevent it from being collected as garbage).

Answer 1

The specification ECMA-262 does not foresee this functionality in the language, and I have no knowledge of any Javascript engine that implements it.

If you want to implement yourself, a starting point is this (based on this reply in English):

(function(){
    var id = 0;
    Object.prototype.getIdentity = function() {
        if(!this.hasOwnProperty('__identity__')) {
            this.__identity__ = ++id;
        }
        return this.__identity__;
    };
}());

Note that __identity__ is a public property that all objects that invoked getIdentity once they become. Therefore nothing prevents it from being manipulated directly, which would potentially compromise the results.

An implementation with features of Ecmascript 5 (i.e., incompatible with older engines like IE8) can prevent this:

(function(){
    var id = 0;
    Object.prototype.getIdentity = function() {
        if(!this.hasOwnProperty('__identity__')) {
            Object.defineProperty(this, '__identity__', { 
                enumerable: false,
                writable: false,
                value: ++id 
            });
        }
        return this.__identity__;
    };
}());

The attribute writable: false ensures that the value of __identity__ cannot be changed manually. E enumerable: false omit the property of enumerations for..in, or serialization via JSON.stringify, as suggested by Talles.

Answer 2

You can add global functionality to the type String:

String.prototype.hashCode = function(){
    var hash = 0;
    for (var i = 0; i < this.length; i++) {
        var character = this.charCodeAt(i);
        hash = ((hash << 5) - hash) + character;
        hash = hash & hash; // Converte para inteiro 32 bit
    }
    return hash;
}

Source

The library Lo-Dash offers some useful features. One is the possibility to compare the equivalence of two values

http://lodash.com/docs#isEqual

var object = { 'name': 'fred' };
var copy = { 'name': 'fred' };

object == copy;
// → false

_.isEqual(object, copy);
// → true

var words = ['hello', 'goodbye'];
var otherWords = ['hi', 'goodbye'];

_.isEqual(words, otherWords, function(a, b) {
  var reGreet = /^(?:hello|hi)$/i,
      aGreet = _.isString(a) && reGreet.test(a),
      bGreet = _.isString(b) && reGreet.test(b);

  return (aGreet || bGreet) ? (aGreet == bGreet) : undefined;
});
// → true