Existe algum tipo de função de código hash em JavaScript?

Basicamente, estou tentando criar um objeto de objetos únicos, um conjunto. Eu tive a brilhante idéia de apenas usar um objeto JavaScript com objetos para os nomes das propriedades. Tal como,

set[obj] = true;

Isso funciona, até certo ponto. Funciona muito bem com string e números, mas com outros objetos, todos parecem "hash" com o mesmo valor e acessam a mesma propriedade. Existe alguma maneira de gerar um valor de hash exclusivo para um objeto? Como seqüências de caracteres e números fazem isso, posso substituir o mesmo comportamento?

Os objetos JavaScript podem usar apenas cadeias de caracteres como chaves (qualquer outra coisa é convertida em uma cadeia de caracteres).

Como alternativa, você pode manter uma matriz que indexa os objetos em questão e usar sua string de índice como uma referência ao objeto. Algo assim:

var ObjectReference = [];
ObjectReference.push(obj);

set['ObjectReference.' + ObjectReference.indexOf(obj)] = true;

Obviamente, é um pouco detalhado, mas você pode escrever alguns métodos que lidam com isso e obter e definir tudo de maneira desagradável.

Editar:

Seu palpite é fato - esse é um comportamento definido no JavaScript - especificamente, ocorre uma conversão em toString, o que significa que você pode definir sua própria função toString no objeto que será usado como o nome da propriedade. - olliej

Isso traz outro ponto interessante; você pode definir um método toString nos objetos que deseja hash e que podem formar seu identificador de hash.

Se você deseja uma função hashCode () como Java em JavaScript, essa é sua:

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; // Convert to 32bit integer
    }
    return hash;
}

Essa é a maneira de implementação em Java (operador bit a bit).

Observe que o hashCode pode ser positivo e negativo, e isso é normal, consulte HashCode fornecendo valores negativos . Portanto, você pode considerar usar Math.abs()junto com esta função.

A maneira mais fácil de fazer isso é atribuir a cada um de seus objetos seu próprio toStringmétodo exclusivo :

(function() {
    var id = 0;

    /*global MyObject */
    MyObject = function() {
        this.objectId = '<#MyObject:' + (id++) + '>';
        this.toString= function() {
            return this.objectId;
        };
    };
})();

Eu tive o mesmo problema e isso resolveu-o perfeitamente para mim com o mínimo de confusão e foi muito mais fácil reimplementar algum estilo Java gordo Hashtablee adicionar equals()e adicionar hashCode()às suas classes de objetos. Apenas certifique-se de não colocar uma string '<#MyObject: 12> no seu hash ou isso limpará a entrada do seu objeto existente com esse ID.

Agora todos os meus hashes estão totalmente relaxados. Também acabei de publicar uma entrada de blog há alguns dias sobre esse tópico exato .

O que você descreveu é coberto pelo Harmony WeakMaps , parte da especificação do ECMAScript 6 (próxima versão do JavaScript). Ou seja: um conjunto em que as chaves podem ser qualquer coisa (incluindo indefinidas) e não enumeráveis.

Isso significa que é impossível obter uma referência a um valor, a menos que você tenha uma referência direta à chave (qualquer objeto!) Vinculada a ele. É importante por várias razões de implementação de mecanismo relacionadas à eficiência e à coleta de lixo, mas também é super legal, pois permite novas semânticas, como permissões de acesso revogáveis ​​e passagem de dados sem expor o remetente.

Do MDN :

var wm1 = new WeakMap(),
    wm2 = new WeakMap();
var o1 = {},
    o2 = function(){},
    o3 = window;

wm1.set(o1, 37);
wm1.set(o2, "azerty");
wm2.set(o1, o2); // A value can be anything, including an object or a function.
wm2.set(o3, undefined);
wm2.set(wm1, wm2); // Keys and values can be any objects. Even WeakMaps!

wm1.get(o2); // "azerty"
wm2.get(o2); // Undefined, because there is no value for o2 on wm2.
wm2.get(o3); // Undefined, because that is the set value.

wm1.has(o2); // True
wm2.has(o2); // False
wm2.has(o3); // True (even if the value itself is 'undefined').

wm1.has(o1);   // True
wm1.delete(o1);
wm1.has(o1);   // False

Os WeakMaps estão disponíveis no Firefox, Chrome e Edge atuais. Eles também são suportados no nó v7 e na v6 com o --harmony-weak-mapssinalizador.

A solução que escolhi é semelhante à de Daniel, mas, em vez de usar uma fábrica de objetos e substituir o toString, adiciono explicitamente o hash ao objeto quando ele é solicitado pela primeira vez por meio da função getHashCode. Um pouco bagunçado, mas melhor para as minhas necessidades :)

Function.prototype.getHashCode = (function(id) {
    return function() {
        if (!this.hashCode) {
            this.hashCode = '<hash|#' + (id++) + '>';
        }
        return this.hashCode;
    }
}(0));

Para minha situação específica, só me preocupo com a igualdade do objeto, tanto quanto as chaves e os valores primitivos. A solução que funcionou para mim foi converter o objeto em sua representação JSON e usá-lo como hash. Existem limitações como ordem de definição de chave potencialmente inconsistente; mas como eu disse, funcionou para mim porque todos esses objetos estavam sendo gerados em um só lugar.

var hashtable = {};

var myObject = {a:0,b:1,c:2};

var hash = JSON.stringify(myObject);
// '{"a":0,"b":1,"c":2}'

hashtable[hash] = myObject;
// {
//   '{"a":0,"b":1,"c":2}': myObject
// }

Eu montei um pequeno módulo JavaScript há algum tempo para produzir códigos de hash para strings, objetos, matrizes, etc. (acabei de o comprometer com o GitHub :))

Uso:

Hashcode.value("stackoverflow")
// -2559914341
Hashcode.value({ 'site' : "stackoverflow" })
// -3579752159

A especificação JavaScript define o acesso à propriedade indexada como executando uma conversão toString no nome do índice. Por exemplo,

myObject[myProperty] = ...;

é o mesmo que

myObject[myProperty.toString()] = ...;

Isso é necessário, como no JavaScript

myObject["someProperty"]

é o mesmo que

myObject.someProperty

E sim, isso também me deixa triste :-(

No ECMAScript 6, agora existe um Setque funciona como você deseja: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set

Já está disponível no Chrome, FF e IE11 mais recentes.

Referência: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol

você pode usar o símbolo Es6 para criar chave exclusiva e objeto de acesso. Todo valor de símbolo retornado de Symbol () é exclusivo. Um valor de símbolo pode ser usado como um identificador para propriedades do objeto; esse é o único objetivo do tipo de dados.

var obj = {};

obj[Symbol('a')] = 'a';
obj[Symbol.for('b')] = 'b';
obj['c'] = 'c';
obj.d = 'd';

Aqui está minha solução simples que retorna um número inteiro exclusivo.

function hashcode(obj) {
    var hc = 0;
    var chars = JSON.stringify(obj).replace(/\{|\"|\}|\:|,/g, '');
    var len = chars.length;
    for (var i = 0; i < len; i++) {
        // Bump 7 to larger prime number to increase uniqueness
        hc += (chars.charCodeAt(i) * 7);
    }
    return hc;
}

Com base no título, podemos gerar hashes fortes com js, ele pode ser usado para gerar um hash exclusivo de um objeto, uma matriz de parâmetros, uma string ou qualquer outra coisa.

Posteriormente, para indexar isso, evite possíveis erros de correspondência, enquanto permite recuperar um índice dos parâmetros (evite pesquisar / fazer um loop no objeto, etc.):

async function H(m) {
  const msgUint8 = new TextEncoder().encode(m)                       
  const hashBuffer = await crypto.subtle.digest('SHA-256', msgUint8)          
  const hashArray = Array.from(new Uint8Array(hashBuffer))                    
  const hashHex = hashArray.map(b => b.toString(16).padStart(2, '0')).join('')
  console.log(hashHex)
}

/* Examples ----------------------- */
H("An obscure ....")
H(JSON.stringify( {"hello" : "world"} ))
H(JSON.stringify( [54,51,54,47] ))

A saída acima no meu navegador também deve ser igual para você ( é mesmo? ):

bf1cf3fe6975fe382ab392ec1dd42009380614be03d489f23601c11413cfca2b
93a23971a914e5eacbf0a8d25154cda309c3c1c72fbb9914d47c60f3cb681588
d2f209e194045604a3b15bdfd7502898a0e848e4603c5a818bd01da69c00ad19

https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/digest#Converting_a_digest_to_a_hex_string

Minha solução introduz uma função estática para o Objectobjeto global .

(function() {
    var lastStorageId = 0;

    this.Object.hash = function(object) {
        var hash = object.__id;

        if (!hash)
             hash = object.__id = lastStorageId++;

        return '#' + hash;
    };
}());

Eu acho que isso é mais conveniente com outras funções de manipulação de objetos em JavaScript.

Vou tentar ir um pouco mais fundo do que outras respostas.

Mesmo se o JS tivesse um suporte melhor ao hash, ele não usaria magicamente tudo perfeitamente, em muitos casos, você terá que definir sua própria função de hash. Por exemplo, Java possui um bom suporte de hash, mas você ainda precisa pensar e fazer algum trabalho.

Um problema é com o termo hash / hashcode ... há hash criptográfico e hash não criptográfico. O outro problema é que você precisa entender por que o hash é útil e como ele funciona.

Quando falamos sobre hash em JavaScript ou Java, na maioria das vezes, falamos sobre hash não criptográfico, geralmente sobre hash para hashmap / hashtable (a menos que trabalhemos em autenticação ou senhas, o que você poderia fazer no servidor usando o NodeJS. ..)

Depende dos dados que você possui e do que deseja alcançar.

Seus dados têm alguma singularidade "simples" natural:

• O hash de um número inteiro é ... o número inteiro, pois é único, sorte sua!
• O hash de uma string ... depende da string, se a string representar um identificador exclusivo, você pode considerá-lo como um hash (portanto, não é necessário fazer hash).
• Qualquer coisa que seja indiretamente um número inteiro único é o caso mais simples
• Isso respeitará: hashcode igual se os objetos forem iguais

Seus dados têm alguma exclusividade "composta" natural:

• Por exemplo, com um objeto de pessoa, você pode calcular um hash usando nome, sobrenome, data de nascimento, ... veja como o Java faz isso: Função Hash Bom para Strings , ou use outras informações de ID que sejam baratas e exclusivas o suficiente para sua base de dados

Você não tem idéia de quais serão seus dados:

• Boa sorte ... você pode serializar para string e hash no estilo Java, mas isso pode ser caro se a string for grande e não evitar colisões, como também dizer o hash de um número inteiro (self).

Não existe uma técnica de hash magicamente eficiente para dados desconhecidos; em alguns casos, é bastante fácil; em outros casos, pode ser necessário pensar duas vezes. Portanto, mesmo que o JavaScript / ECMAScript inclua mais suporte, não há solução de linguagem mágica para esse problema.

Na prática, você precisa de duas coisas: singularidade suficiente, velocidade suficiente

Além disso, é ótimo ter: "código de hash igual se os objetos forem iguais"

• https://en.wikipedia.org/wiki/Hash_table#Collision_resolution
• Relação entre hashCode e método igual em Java

Se você realmente deseja definir um comportamento (estou familiarizado com o conhecimento de Java), será difícil encontrar uma solução em JavaScript. A maioria dos desenvolvedores recomendará uma chave exclusiva para representar cada objeto, mas isso é diferente do definido, pois você pode obter dois objetos idênticos, cada um com uma chave exclusiva. A API Java realiza o trabalho de verificação de valores duplicados comparando valores de código de hash, não chaves, e como não há representação de valor de código de hash de objetos em JavaScript, torna-se quase impossível fazer o mesmo. Até a biblioteca Prototype JS admite essa falha, quando diz:

"Hash pode ser pensado como uma matriz associativa, vinculando chaves únicas a valores (que não são necessariamente únicos) ..."

http://www.prototypejs.org/api/hash

Além da resposta da ausência de pálpebra, aqui está uma função que retorna um ID exclusivo e reproduzível para qualquer objeto:

var uniqueIdList = [];
function getConstantUniqueIdFor(element) {
    // HACK, using a list results in O(n), but how do we hash e.g. a DOM node?
    if (uniqueIdList.indexOf(element) < 0) {
        uniqueIdList.push(element);
    }
    return uniqueIdList.indexOf(element);
}

Como você pode ver, ele usa uma lista de pesquisa que é muito ineficiente, mas é o melhor que pude encontrar por enquanto.

Se você quiser usar objetos como chaves, precisará substituir o método toString, como alguns já mencionados aqui. As funções de hash usadas são boas, mas funcionam apenas para os mesmos objetos e não para objetos iguais.

Eu escrevi uma pequena biblioteca que cria hashes a partir de objetos, que você pode usar facilmente para esse fim. Os objetos podem até ter uma ordem diferente, os hashes serão os mesmos. Internamente, você pode usar tipos diferentes para seu hash (djb2, md5, sha1, sha256, sha512, ripemd160).

Aqui está um pequeno exemplo da documentação:

var hash = require('es-hash');

// Save data in an object with an object as a key
Object.prototype.toString = function () {
    return '[object Object #'+hash(this)+']';
}

var foo = {};

foo[{bar: 'foo'}] = 'foo';

/*
 * Output:
 *  foo
 *  undefined
 */
console.log(foo[{bar: 'foo'}]);
console.log(foo[{}]);

O pacote pode ser usado no navegador e nos Nó-Js.

Repositório: https://bitbucket.org/tehrengruber/es-js-hash

Se você deseja ter valores exclusivos em um objeto de pesquisa, pode fazer algo assim:

Criando um objeto de pesquisa

var lookup = {};

Configurando a função hashcode

function getHashCode(obj) {
    var hashCode = '';
    if (typeof obj !== 'object')
        return hashCode + obj;
    for (var prop in obj) // No hasOwnProperty needed
        hashCode += prop + getHashCode(obj[prop]); // Add key + value to the result string
    return hashCode;
}

Objeto

var key = getHashCode({ 1: 3, 3: 7 });
// key = '1337'
lookup[key] = true;

Matriz

var key = getHashCode([1, 3, 3, 7]);
// key = '01132337'
lookup[key] = true;

Outros tipos

var key = getHashCode('StackOverflow');
// key = 'StackOverflow'
lookup[key] = true;

Resultado final

{ 1337: true, 01132337: true, StackOverflow: true }

Observe que getHashCodenão retorna nenhum valor quando o objeto ou a matriz está vazia

getHashCode([{},{},{}]);
// '012'
getHashCode([[],[],[]]);
// '012'

Isso é semelhante à solução @ijmacd, apenas getHashCodenão tem JSONdependência.

Combinei as respostas de eyelidlessness e KimKha.

A seguir, é um serviço angularjs e suporta números, seqüências de caracteres e objetos.

exports.Hash = () => {
  let hashFunc;
  function stringHash(string, noType) {
    let hashString = string;
    if (!noType) {
      hashString = `string${string}`;
    }
    var hash = 0;
    for (var i = 0; i < hashString.length; i++) {
        var character = hashString.charCodeAt(i);
        hash = ((hash<<5)-hash)+character;
        hash = hash & hash; // Convert to 32bit integer
    }
    return hash;
  }

  function objectHash(obj, exclude) {
    if (exclude.indexOf(obj) > -1) {
      return undefined;
    }
    let hash = '';
    const keys = Object.keys(obj).sort();
    for (let index = 0; index < keys.length; index += 1) {
      const key = keys[index];
      const keyHash = hashFunc(key);
      const attrHash = hashFunc(obj[key], exclude);
      exclude.push(obj[key]);
      hash += stringHash(`object${keyHash}${attrHash}`, true);
    }
    return stringHash(hash, true);
  }

  function Hash(unkType, exclude) {
    let ex = exclude;
    if (ex === undefined) {
      ex = [];
    }
    if (!isNaN(unkType) && typeof unkType !== 'string') {
      return unkType;
    }
    switch (typeof unkType) {
      case 'object':
        return objectHash(unkType, ex);
      default:
        return stringHash(String(unkType));
    }
  }

  hashFunc = Hash;

  return Hash;
};

Exemplo de uso:

Hash('hello world'), Hash('hello world') == Hash('hello world')
Hash({hello: 'hello world'}), Hash({hello: 'hello world'}) == Hash({hello: 'hello world'})
Hash({hello: 'hello world', goodbye: 'adios amigos'}), Hash({hello: 'hello world', goodbye: 'adios amigos'}) == Hash({goodbye: 'adios amigos', hello: 'hello world'})
Hash(['hello world']), Hash(['hello world']) == Hash(['hello world'])
Hash(1), Hash(1) == Hash(1)
Hash('1'), Hash('1') == Hash('1')

Resultado

432700947 true
-411117486 true
1725787021 true
-1585332251 true
1 true
-1881759168 true

Explicação

Como você pode ver, o coração do serviço é a função hash criada por KimKha. Adicionei tipos às seqüências de caracteres para que a estrutura do objeto também impactasse o valor final do hash. As chaves são hash para evitar colisões de objetos |

A comparação de objetos sem pálpebras é usada para evitar recursões infinitas por objetos auto-referenciados.

Uso

Eu criei este serviço para poder ter um serviço de erro que é acessado com objetos. Para que um serviço possa registrar um erro em um determinado objeto e outro possa determinar se foram encontrados erros.

ie

JsonValidation.js

ErrorSvc({id: 1, json: '{attr: "not-valid"}'}, 'Invalid Json Syntax - key not double quoted');

UserOfData.js

ErrorSvc({id: 1, json: '{attr: "not-valid"}'});

Isso retornaria:

['Invalid Json Syntax - key not double quoted']

Enquanto

ErrorSvc({id: 1, json: '{"attr": "not-valid"}'});

Isso retornaria

[]

Basta usar a propriedade secreta oculta com o defineProperty enumerable: false

Funciona muito rápido :

• A primeira leitura únicaId: 1.257.500 ops / s
• Todos os outros: 309.226.485 ops / s

var nextObjectId = 1
function getNextObjectId() {
    return nextObjectId++
}

var UNIQUE_ID_PROPERTY_NAME = '458d576952bc489ab45e98ac7f296fd9'
function getObjectUniqueId(object) {
    if (object == null) {
        return null
    }

    var id = object[UNIQUE_ID_PROPERTY_NAME]

    if (id != null) {
        return id
    }

    if (Object.isFrozen(object)) {
        return null
    }

    var uniqueId = getNextObjectId()
    Object.defineProperty(object, UNIQUE_ID_PROPERTY_NAME, {
        enumerable: false,
        configurable: false,
        writable: false,
        value: uniqueId,
    })

    return uniqueId
}