Existe-t-il une fonction de code de hachage en JavaScript?

En gros, j'essaye de créer un objet d'objets uniques, un ensemble. J'ai eu la brillante idée d'utiliser simplement un objet JavaScript avec des objets pour les noms de propriétés. Tel que,

set[obj] = true;

Cela fonctionne, jusqu'à un certain point. Cela fonctionne très bien avec des chaînes et des nombres, mais avec d'autres objets, ils semblent tous "hacher" à la même valeur et accéder à la même propriété. Existe-t-il un moyen de générer une valeur de hachage unique pour un objet? Comment les chaînes et les nombres le font, puis-je remplacer le même comportement?

Les objets JavaScript ne peuvent utiliser que des chaînes comme clés (tout le reste est converti en chaîne).

Vous pouvez également conserver un tableau qui indexe les objets en question et utiliser sa chaîne d'index comme référence à l'objet. Quelque chose comme ça:

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

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

De toute évidence, c'est un peu verbeux, mais vous pouvez écrire quelques méthodes pour le gérer et obtenir et définir tout bon gré mal gré.

Éditer:

Votre hypothèse est un fait - il s'agit d'un comportement défini dans JavaScript - en particulier une conversion toString se produit, ce qui signifie que vous pouvez définir votre propre fonction toString sur l'objet qui sera utilisé comme nom de propriété. - olliej

Cela soulève un autre point intéressant; vous pouvez définir une méthode toString sur les objets que vous souhaitez hacher, et qui peuvent former leur identifiant de hachage.

Si vous voulez une fonction hashCode () comme celle de Java en JavaScript, c'est la vôtre:

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

C'est le mode d'implémentation en Java (opérateur bit à bit).

Veuillez noter que hashCode peut être positif et négatif, et c'est normal, voir HashCode donnant des valeurs négatives . Donc, vous pouvez envisager d'utiliser Math.abs()avec cette fonction.

Le moyen le plus simple de le faire est de donner à chacun de vos objets sa propre toStringméthode unique :

(function() {
    var id = 0;

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

J'ai eu le même problème et cela l'a parfaitement résolu pour moi avec un minimum de tracas, et c'était beaucoup plus facile que de réimplémenter un style Java gras Hashtableet d'ajouter equals()et hashCode()à vos classes d'objets. Assurez-vous simplement que vous ne collez pas également une chaîne '<#MyObject: 12> dans votre hachage ou cela effacera l'entrée de votre objet existant avec cet identifiant.

Maintenant, tous mes hashes sont totalement froids. Je viens également de publier une entrée de blog il y a quelques jours sur ce sujet précis .

Ce que vous avez décrit est couvert par Harmony WeakMaps , qui fait partie de la spécification ECMAScript 6 (prochaine version de JavaScript). C'est-à-dire: un ensemble où les clés peuvent être n'importe quoi (y compris indéfini) et ne sont pas énumérables.

Cela signifie qu'il est impossible d'obtenir une référence à une valeur à moins d'avoir une référence directe à la clé (n'importe quel objet!) Qui y est liée. C'est important pour un tas de raisons d'implémentation de moteur liées à l'efficacité et au ramassage des ordures, mais c'est aussi super cool car cela permet une nouvelle sémantique comme des autorisations d'accès révocables et la transmission de données sans exposer l'expéditeur de données.

De 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

WeakMaps est disponible dans Firefox, Chrome et Edge actuels. Ils sont également pris en charge dans Node v7 et dans v6 avec l' --harmony-weak-mapsindicateur.

La solution que j'ai choisie est similaire à celle de Daniel, mais plutôt que d'utiliser une fabrique d'objets et de remplacer le toString, j'ajoute explicitement le hachage à l'objet lorsqu'il est demandé pour la première fois via une fonction getHashCode. Un peu en désordre, mais mieux pour mes besoins :)

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

Pour ma situation spécifique, je ne me soucie que de l'égalité de l'objet en ce qui concerne les clés et les valeurs primitives. La solution qui a fonctionné pour moi a été de convertir l'objet en sa représentation JSON et de l'utiliser comme hachage. Il existe des limites telles que l'ordre de définition des clés pouvant être incohérent; mais comme je l'ai dit, cela a fonctionné pour moi parce que ces objets étaient tous générés au même endroit.

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

J'ai mis en place un petit module JavaScript il y a quelque temps pour produire des hashcodes pour des chaînes, des objets, des tableaux, etc. (je viens de le valider dans GitHub :))

Usage:

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

La spécification JavaScript définit l'accès aux propriétés indexées comme effectuant une conversion toString sur le nom de l'index. Par exemple,

myObject[myProperty] = ...;

est le même que

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

C'est nécessaire comme en JavaScript

myObject["someProperty"]

est le même que

myObject.someProperty

Et oui, ça me rend triste aussi :-(

Dans ECMAScript 6, il y a maintenant un Setqui fonctionne comme vous le souhaitez: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set

Il est déjà disponible dans les derniers Chrome, FF et IE11.

Référence: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol

vous pouvez utiliser le symbole Es6 pour créer une clé unique et un objet d'accès. Chaque valeur de symbole renvoyée par Symbol () est unique. Une valeur de symbole peut être utilisée comme identificateur pour les propriétés d'objet; c'est le seul objectif du type de données.

var obj = {};

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

Voici ma solution simple qui renvoie un entier unique.

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

Sur la base du titre, nous pouvons générer des hachages forts avec js, il peut être utilisé pour générer un hachage unique à partir d'un objet, d'un tableau de paramètres, d'une chaîne ou autre.

Plus tard pour l'indexation, évitez toute erreur de correspondance possible, tout en permettant de récupérer un index à partir des paramètres (évitez de rechercher / boucler l'objet, 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] ))

La sortie ci-dessus dans mon navigateur, elle devrait être égale pour vous aussi ( est-ce vraiment? ):

bf1cf3fe6975fe382ab392ec1dd42009380614be03d489f23601c11413cfca2b
93a23971a914e5eacbf0a8d25154cda309c3c1c72fbb9914d47c60f3cb681588
d2f209e194045604a3b15bdfd7502898a0e848e4603c5a818bd01da69c00ad19

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

Ma solution introduit une fonction statique pour l' Objectobjet global .

(function() {
    var lastStorageId = 0;

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

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

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

Je pense que c'est plus pratique avec d'autres fonctions de manipulation d'objets en JavaScript.

J'essaierai d'aller un peu plus loin que les autres réponses.

Même si JS avait un meilleur support de hachage, il ne hacherait pas tout parfaitement par magie, dans de nombreux cas, vous devrez définir votre propre fonction de hachage. Par exemple, Java a un bon support de hachage, mais vous devez encore réfléchir et faire un peu de travail.

Un problème est avec le terme hash / hashcode ... il y a un hachage cryptographique et un hachage non cryptographique. L'autre problème, c'est que vous devez comprendre pourquoi le hachage est utile et comment cela fonctionne.

Lorsque nous parlons de hachage en JavaScript ou Java la plupart du temps, nous parlons de hachage non cryptographique, généralement de hachage pour hashmap / hashtable (sauf si nous travaillons sur l'authentification ou les mots de passe, ce que vous pourriez faire côté serveur en utilisant NodeJS. ..).

Cela dépend des données dont vous disposez et de ce que vous souhaitez atteindre.

Vos données ont un caractère unique "simple" naturel:

• Le hachage d'un entier est ... l'entier, car il est unique, chanceux!
• Le hachage d'une chaîne ... cela dépend de la chaîne, si la chaîne représente un identifiant unique, vous pouvez le considérer comme un hachage (donc pas de hachage nécessaire).
• Tout ce qui est indirectement à peu près un entier unique est le cas le plus simple
• Cela respectera: hashcode égal si les objets sont égaux

Vos données ont un caractère unique "composite" naturel:

• Par exemple, avec un objet personne, vous pouvez calculer un hachage en utilisant le prénom, le nom, la date de naissance, ... voir comment Java le fait: bonne fonction de hachage pour les chaînes , ou utiliser d'autres informations d'identification qui sont assez bon marché et uniques pour votre cas d'utilisation

Vous n'avez aucune idée de ce que seront vos données:

• Bonne chance ... vous pouvez sérialiser en chaîne et hacher le style Java, mais cela peut coûter cher si la chaîne est grande et cela n'évitera pas les collisions ainsi que le hachage d'un entier (self).

Il n'y a pas de technique de hachage magiquement efficace pour les données inconnues, dans certains cas, c'est assez facile, dans d'autres cas, vous devrez peut-être réfléchir à deux fois. Donc, même si JavaScript / ECMAScript ajoute plus de support, il n'y a pas de solution de langage magique pour ce problème.

En pratique, vous avez besoin de deux choses: assez d'unicité, assez de vitesse

En plus de cela, il est génial d'avoir: "hashcode égal si les objets sont égaux"

• https://en.wikipedia.org/wiki/Hash_table#Collision_resolution
• Relation entre hashCode et la méthode equals en Java

Si vous voulez vraiment définir un comportement (je me fie à Java), vous aurez du mal à trouver une solution en JavaScript. La plupart des développeurs recommanderont une clé unique pour représenter chaque objet, mais cela ne ressemble pas à un ensemble, en ce sens que vous pouvez obtenir deux objets identiques chacun avec une clé unique. L'API Java effectue le travail de vérification des valeurs en double en comparant les valeurs de code de hachage, pas les clés, et comme il n'y a pas de représentation de la valeur de code de hachage des objets en JavaScript, il devient presque impossible de faire de même. Même la bibliothèque Prototype JS admet cette lacune, quand elle dit:

"Le hachage peut être considéré comme un tableau associatif, liant des clés uniques à des valeurs (qui ne sont pas nécessairement uniques) ..."

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

En plus de la réponse sans paupière, voici une fonction qui renvoie un identifiant unique et reproductible pour tout objet:

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

Comme vous pouvez le voir, il utilise une liste de recherche qui est très inefficace, mais c'est le meilleur que je puisse trouver pour le moment.

Si vous souhaitez utiliser des objets comme clés, vous devez écraser leur méthode toString, comme certains l'ont déjà mentionné ici. Les fonctions de hachage qui ont été utilisées sont toutes correctes, mais elles ne fonctionnent que pour les mêmes objets et non pour des objets égaux.

J'ai écrit une petite bibliothèque qui crée des hachages à partir d'objets, que vous pouvez facilement utiliser à cette fin. Les objets peuvent même avoir un ordre différent, les hachages seront les mêmes. En interne, vous pouvez utiliser différents types pour votre hachage (djb2, md5, sha1, sha256, sha512, ripemd160).

Voici un petit exemple de la documentation:

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

Le package peut être utilisé dans le navigateur et dans Node-Js.

Dépôt: https://bitbucket.org/tehrengruber/es-js-hash

Si vous voulez avoir des valeurs uniques dans un objet de recherche, vous pouvez faire quelque chose comme ceci:

Création d'un objet de recherche

var lookup = {};

Configuration de la fonction de 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;
}

Objet

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

Tableau

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

Autres types

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

Résultat final

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

Notez que getHashCodene renvoie aucune valeur lorsque l'objet ou le tableau est vide

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

Ceci est similaire à la solution @ijmacd mais getHashCoden'a pas de JSONdépendance.

J'ai combiné les réponses de la paupière et de KimKha.

Ce qui suit est un service angularjs et il prend en charge les nombres, les chaînes et les objets.

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

Exemple d'utilisation:

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

Production

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

Explication

Comme vous pouvez le voir, le cœur du service est la fonction de hachage créée par KimKha, j'ai ajouté des types aux chaînes afin que la structure de l'objet ait également un impact sur la valeur de hachage finale.Les clés sont hachées pour éviter les collisions tableau | objet.

La comparaison d'objets sans paupière est utilisée pour empêcher la récursivité infinie par les objets auto-référençables.

Usage

J'ai créé ce service pour pouvoir disposer d'un service d'erreur accessible avec des objets. Pour qu'un service puisse enregistrer une erreur avec un objet donné et qu'un autre puisse déterminer si des erreurs ont été trouvées.

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

Cela reviendrait:

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

Tandis que

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

Cela reviendrait

[]

Utilisez simplement la propriété secrète cachée avec le defineProperty enumerable: false

Cela fonctionne très vite :

• La première lecture uniqueId: 1,257,500 ops / s
• Tous les autres: 309226485 opérations / 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
}