Como obter a identidade de um objeto em JavaScript? – javascript

Diversas linguagens possuem um meio de se obter a “identidade” de um objeto, i.e. um número [inteiro] que é único para cada objeto, tal que objetos diferentes tenham identidades diferentes. Exemplos:

• Java (System.identityHashCode)

Tanto quanto razoavelmente prático, o método hashCode definido pela classe Object retorna inteiros distintos para objetos distintos. (Isto é tipicamente implementado convertendo o endereço interno do objeto em um inteiro, mas essa técnica de implementação não é exigida pela linguagem de programação Java.)

• Python (id)

Retorna a “identidade” de um objeto. Isto é um inteiro (ou inteiro longo) que é garantido ser único e constante para esse objeto durante seu ciclo de vida. Dois objetos com tempo de vida não sobrepostos podem ter o mesmo valor para id().

Existe alguma funcionalidade semelhante em JavaScript? De preferência padronizada, que funcionasse em todos os browsers e outros ambientes (Rhino, V8). Buscando por “identity” eu somente encontro referências para o operador (===)…

Sei que alguns ambientes não suportam esse conceito (.NET aparentemente não o faz por razões de otimização), mas em geral isso não é problema pois são linguagens mais completas, que possuem os conceitos de destrutor, finalizador e/ou referências fracas. Até onde eu saiba, JavaScript não suporta isso, de modo que uma maneira de se obter um valor numérico que unicamente representa um objeto seria muito útil (uma simples referência pro objeto não serve, pois ela o impediria de ser coletado como lixo).

A especificação ECMA-262 não prevê essa funcionalidade na linguagem, e não tenho conhecimento de nenhum motor de JavaScript que implemente isso.

Se quiser implementar você mesmo, um ponto de partida é isto (baseado nesta resposta em inglês):

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

Note que __identity__ é uma propriedade pública que todos os objetos que invocaram getIdentity uma vez passam a ter. Portanto nada impede que ela seja manipulada diretamente, o que potencialmente comprometeria os resultados.

Uma implementação com recursos do ECMAScript 5 (ou seja, incompatível com motores antigos como o do IE8) consegue impedir isso:

(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__;
    };
}());

O atributo writable: false garante que o valor de __identity__ não possa ser alterado manualmente. E enumerable: false omite a propriedade de enumerações for..in, ou serialização via JSON.stringify, conforme a sugestão do talles.

Pode-se adicionar uma funcionalidade global para o tipo 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;
}

Fonte

A biblioteca Lo-Dash oferece algumas funcionalidades úteis. Uma delas é a possibilidade de comparar a equivalência de dois valores

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