Esiste un tipo di funzione di codice hash in JavaScript?

Fondamentalmente, sto cercando di creare un oggetto di oggetti unici, un set. Ho avuto la geniale idea di usare semplicemente un oggetto JavaScript con oggetti per i nomi delle proprietà. Ad esempio,

set[obj] = true;

Questo funziona, fino a un certo punto. Funziona alla grande con stringhe e numeri, ma con altri oggetti, sembrano tutti "hash" allo stesso valore e accedere alla stessa proprietà. Esiste un modo per generare un valore hash univoco per un oggetto? Come lo fanno stringhe e numeri, posso ignorare lo stesso comportamento?

Gli oggetti JavaScript possono utilizzare solo stringhe come chiavi (qualsiasi altra cosa viene convertita in stringa).

In alternativa, è possibile mantenere un array che indicizza gli oggetti in questione e utilizzare la sua stringa di indice come riferimento all'oggetto. Qualcosa come questo:

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

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

Ovviamente è un po 'prolisso, ma potresti scrivere un paio di metodi che lo gestiscono e ottengono e impostano tutti volenti o nolenti.

Modificare:

La tua ipotesi è un fatto - questo è un comportamento definito in JavaScript - in particolare si verifica una conversione toString nel senso che puoi definire la tua funzione toString sull'oggetto che verrà usato come nome della proprietà. - Olliej

Questo fa apparire un altro punto interessante; puoi definire un metodo toString sugli oggetti che vuoi hash e che può formare il loro identificatore hash.

Se vuoi una funzione hashCode () come Java in JavaScript, questa è la tua:

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;
}

Questo è il modo di implementazione in Java (operatore bit a bit).

Nota che hashCode potrebbe essere positivo e negativo, ed è normale, vedi HashCode che fornisce valori negativi . Quindi, potresti considerare di usare Math.abs()insieme a questa funzione.

Il modo più semplice per farlo è quello di dare a ciascuno dei tuoi oggetti il ​​suo toStringmetodo unico :

(function() {
    var id = 0;

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

Ho avuto lo stesso problema e questo mi ha risolto perfettamente con il minimo sforzo, ed è stato molto più semplice implementare un po 'di grasso stile Java Hashtablee aggiungere equals()ehashCode() alle tue classi di oggetti. Assicurati solo di non attaccare una stringa '<#MyObject: 12> nel tuo hash o che cancellerà la voce per il tuo oggetto uscente con quell'id.

Ora tutti i miei hash sono completamente freddi. Ho anche pubblicato un post sul blog qualche giorno fa su questo argomento esatto .

Quello che hai descritto è coperto da Harmony WeakMaps , parte della specifica ECMAScript 6 (prossima versione di JavaScript). Cioè: un set in cui le chiavi possono essere qualsiasi cosa (incluso indefinito) ed è non enumerabile.

Ciò significa che è impossibile ottenere un riferimento a un valore a meno che non si abbia un riferimento diretto alla chiave (qualsiasi oggetto!) Che si collega ad esso. È importante per una serie di motivi di implementazione del motore relativi all'efficienza e alla garbage collection, ma è anche fantastico perché consente nuove semantiche come autorizzazioni di accesso revocabili e passaggio di dati senza esporre il mittente dei dati.

Da 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

Le mappe deboli sono disponibili negli attuali Firefox, Chrome e Edge. Sono inoltre supportati in Nodo v7 e in v6 con la --harmony-weak-mapsbandiera.

La soluzione che ho scelto è simile a quella di Daniel, ma anziché utilizzare una factory di oggetti e sovrascrivere toString, aggiungo esplicitamente l'hash all'oggetto quando viene richiesto per la prima volta tramite una funzione getHashCode. Un po 'disordinato, ma migliore per le mie esigenze :)

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

Per la mia situazione specifica, mi preoccupo solo dell'uguaglianza dell'oggetto per quanto riguarda le chiavi e i valori primitivi. La soluzione che ha funzionato per me è stata convertire l'oggetto nella sua rappresentazione JSON e usarlo come hash. Vi sono limitazioni come l'ordine di definizione della chiave potenzialmente incoerente; ma come ho detto, ha funzionato per me perché tutti gli oggetti venivano generati in un unico posto.

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
// }

Qualche tempo fa ho messo insieme un piccolo modulo JavaScript per produrre hashcode per stringhe, oggetti, array, ecc. (L'ho appena assegnato a GitHub :))

Uso:

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

La specifica JavaScript definisce l'accesso alla proprietà indicizzata come l'esecuzione di una conversione toString sul nome dell'indice. Per esempio,

myObject[myProperty] = ...;

equivale a

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

Questo è necessario come in JavaScript

myObject["someProperty"]

equivale a

myObject.someProperty

E sì, mi rende anche triste :-(

In ECMAScript 6 ora esiste un file Setche funziona come desideri: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set

È già disponibile negli ultimi Chrome, FF e IE11.

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

puoi usare il simbolo Es6 per creare una chiave univoca e accedere all'oggetto. Ogni valore di simbolo restituito da Symbol () è univoco. Un valore di simbolo può essere utilizzato come identificatore per le proprietà dell'oggetto; questo è l'unico scopo del tipo di dati.

var obj = {};

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

Ecco la mia semplice soluzione che restituisce un numero intero univoco.

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;
}

In base al titolo, possiamo generare hash forti con js, può essere utilizzato per generare un hash univoco da un oggetto, una matrice di parametri, una stringa o altro.

In seguito per l'indicizzazione questo evita ogni possibile errore di corrispondenza, consentendo nel contempo di recuperare un indice dai parametri (evitare di cercare / eseguire il loop dell'oggetto ecc.):

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] ))

L'output di cui sopra nel mio browser, dovrebbe essere uguale anche per te ( è davvero? ):

bf1cf3fe6975fe382ab392ec1dd42009380614be03d489f23601c11413cfca2b
93a23971a914e5eacbf0a8d25154cda309c3c1c72fbb9914d47c60f3cb681588
d2f209e194045604a3b15bdfd7502898a0e848e4603c5a818bd01da69c00ad19

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

La mia soluzione introduce una funzione statica per l' Objectoggetto globale .

(function() {
    var lastStorageId = 0;

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

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

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

Penso che questo sia più conveniente con altre funzioni di manipolazione degli oggetti in JavaScript.

Proverò ad andare un po 'più in profondità rispetto alle altre risposte.

Anche se JS avesse un supporto di hashing migliore, non avrebbe magicamente tutto perfettamente sotto controllo, in molti casi dovrai definire la tua funzione di hash. Ad esempio, Java ha un buon supporto di hashing, ma devi ancora pensare e fare un po 'di lavoro.

Un problema è con il termine hash / hashcode ... c'è hash crittografico e hash non crittografico. L'altro problema è che devi capire perché l'hashing è utile e come funziona.

Quando parliamo di hash in JavaScript o Java la maggior parte delle volte parliamo di hash non crittografico, di solito di hash per hashmap / hashtable (a meno che non stiamo lavorando su autenticazione o password, che potresti fare sul lato server usando NodeJS. ..).

Dipende da quali dati hai e cosa vuoi ottenere.

I tuoi dati hanno una naturale "semplice" unicità:

• L'hash di un numero intero è ... il numero intero, in quanto è unico, beato te!
• L'hash di una stringa ... dipende dalla stringa, se la stringa rappresenta un identificatore univoco, è possibile considerarlo come un hash (quindi non è necessario alcun hash).
• Qualunque cosa che sia indirettamente praticamente un intero unico è il caso più semplice
• Questo rispetterà: hashcode uguale se gli oggetti sono uguali

I tuoi dati hanno una naturale unicità "composita":

• Ad esempio con un oggetto persona, puoi calcolare un hash usando il nome, il cognome, la data di nascita, ... guarda come fa Java: buona funzione hash per le stringhe o usa altre informazioni ID che sono economiche e uniche abbastanza per il tuo caso d'uso

Non hai idea di quali saranno i tuoi dati:

• Buona fortuna ... potresti serializzare su stringa e hash lo stile Java, ma potrebbe essere costoso se la stringa è grande e non eviterà le collisioni, come dire l'hash di un numero intero (self).

Non esiste una tecnica di hashing magicamente efficiente per dati sconosciuti, in alcuni casi è abbastanza semplice, in altri casi potresti dover pensarci due volte. Quindi, anche se JavaScript / ECMAScript aggiungono ulteriore supporto, non esiste una soluzione di linguaggio magico per questo problema.

In pratica hai bisogno di due cose: abbastanza unicità, abbastanza velocità

Inoltre, è bello avere: "hashcode uguale se gli oggetti sono uguali"

• https://en.wikipedia.org/wiki/Hash_table#Collision_resolution
• Relazione tra hashCode e metodo uguale in Java

Se vuoi davvero impostare il comportamento (vado dalla conoscenza di Java), allora sarai molto difficile trovare una soluzione in JavaScript. La maggior parte degli sviluppatori raccomanderà una chiave univoca per rappresentare ogni oggetto, ma questo è diverso da quello impostato, in quanto è possibile ottenere due oggetti identici ciascuno con una chiave univoca. L'API Java svolge il compito di verificare la presenza di valori duplicati confrontando i valori del codice hash, non le chiavi, e poiché non esiste una rappresentazione del valore del codice hash degli oggetti in JavaScript, diventa quasi impossibile fare lo stesso. Anche la libreria Prototype JS ammette questo difetto, quando dice:

"L'hash può essere pensato come un array associativo, che lega chiavi uniche a valori (che non sono necessariamente unici) ..."

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

Oltre alla risposta per le ciglia, ecco una funzione che restituisce un ID univoco riproducibile per qualsiasi oggetto:

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

Come puoi vedere usa un elenco per la ricerca che è molto inefficiente, tuttavia è il migliore che potrei trovare per ora.

Se vuoi usare oggetti come chiavi devi sovrascrivere il loro metodo toString, come alcuni già menzionati qui. Le funzioni hash che sono state usate vanno bene, ma funzionano solo per gli stessi oggetti, non per oggetti uguali.

Ho scritto una piccola libreria che crea hash dagli oggetti, che puoi usare facilmente per questo scopo. Gli oggetti possono anche avere un ordine diverso, gli hash saranno gli stessi. Internamente puoi usare diversi tipi per il tuo hash (djb2, md5, sha1, sha256, sha512, ripemd160).

Ecco un piccolo esempio dalla documentazione:

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[{}]);

Il pacchetto può essere utilizzato nel browser e in Node-Js.

Repository: https://bitbucket.org/tehrengruber/es-js-hash

Se vuoi avere valori univoci in un oggetto di ricerca, puoi fare qualcosa del genere:

Creazione di un oggetto di ricerca

var lookup = {};

Impostazione della funzione 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;
}

Oggetto

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

Vettore

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

Altri tipi

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

Risultato finale

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

Si noti che getHashCodenon restituisce alcun valore quando l'oggetto o la matrice sono vuoti

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

Questo è simile alla soluzione @ijmacd solo getHashCodenon ha la JSONdipendenza.

Ho combinato le risposte di palpebra e KimKha.

Quello che segue è un servizio angularjs e supporta numeri, stringhe e oggetti.

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;
};

Esempio di utilizzo:

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')

Produzione

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

Spiegazione

Come puoi vedere, il cuore del servizio è la funzione hash creata da KimKha. Ho aggiunto tipi alle stringhe in modo che la struttura dell'oggetto abbia un impatto anche sul valore finale dell'hash. Le chiavi sono sottoposte a hash per impedire collisioni di array | oggetti.

la comparazione di oggetti senza palpebre viene utilizzata per prevenire la ricorsione infinita da oggetti autoreferenziali.

uso

Ho creato questo servizio in modo da poter avere un servizio di errore a cui si accede con oggetti. In modo che un servizio possa registrare un errore con un determinato oggetto e un altro può determinare se sono stati rilevati errori.

vale a dire

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"}'});

Ciò restituirebbe:

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

Mentre

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

Questo sarebbe tornato

[]

Basta usare la proprietà segreta nascosta con il defineProperty enumerable: false

Funziona molto velocemente :

• La prima lettura uniqueId: 1.257.500 ops / s
• Tutti gli altri: 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
}