JavaScript 中有哈希码函数吗？

Question

基本上，我试图创建一个由独特对象组成的对象，即一组。我有一个绝妙的主意，即使用 JavaScript 对象和属性名称对象。例如，

set[obj] = true;

在某种程度上，这是有效的。它适用于字符串和数字，但对于其他对象，它们似乎都“散列”为相同的值并访问相同的属性。有某种方法可以为对象生成唯一的哈希值吗？字符串和数字是如何做到的，我可以覆盖相同的行为吗？

Answer 1

JavaScript对象只能使用字符串作为键（其他任何东西都转换为字符串）。

或者，您可以维护一个数组，该数组索引相关对象，并使用其索引字符串作为对象的引用。像这样：

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

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

显然它有点冗长，但是你可以编写一些处理它的方法，然后设置所有方法。

编辑：

  

您的猜测是事实 - 这是JavaScript中定义的行为 - 特别是发生toString转换意味着您可以在将用作属性名称的对象上定义自己的toString函数。 - olliej

这引出了另一个有趣的观点;您可以在要散列的对象上定义toString方法，并且可以形成其哈希标识符。

Answer 2

如果你想在JavaScript中使用像Java这样的hashCode（）函数，那就是你的：

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

这是Java（按位运算符）的实现方式。

Answer 3

最简单的方法是为每个对象提供独特的toString方法：

(function() {
    var id = 0;

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

我遇到了同样的问题，这对我来说完全解决了这个问题，而且重新实现了一些脂肪Java风格Hashtable并将equals()和hashCode()添加到对象类中。只要确保你不粘贴字符串'<！> lt; #MyObject：12 <！> gt;进入你的哈希值，否则它将清除你带有该id的退出对象的条目。

现在我所有的哈希都非常寒冷。我几天前刚刚发布了一篇关于这个话题的博客文章。

Answer 4

我选择的解决方案类似于Daniel的解决方案，但是不是使用对象工厂并覆盖toString，而是在首次通过getHashCode函数请求时向表中显式添加哈希。有点凌乱，但更符合我的需求:)）

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

Answer 5

您所描述的内容由Harmony WeakMaps 所涵盖， ECMAScript <！> nbsp; 6 规范（下一版JavaScript）。这是：一个集合，其中键可以是任何东西（包括未定义的）并且是不可枚举的。

这意味着除非您直接引用链接到它的键（任何对象！），否则无法获取对值的引用。这对于一系列与效率和垃圾收集相关的引擎实现原因很重要，但它也非常酷，因为它允许新的语义，如可撤销访问权限和传递数据而不暴露数据发送者。

来自 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可用于当前的Firefox，Chrome和Edge。它们也在Node v7中支持，在v6中也支持--harmony-weak-maps标志。

Answer 6

对于我的具体情况，我只关心对象和原始值的对象是否相等。对我有用的解决方案是将对象转换为其JSON表示并将其用作哈希。有一些限制，例如密钥定义的顺序可能不一致;但就像我说它对我有用，因为这些物体都是在一个地方生成的。

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

Answer 7

JavaScript规范将索引属性访问定义为对索引名称执行toString转换。例如，

myObject[myProperty] = ...;

与

相同

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

这在JavaScript中是必要的

myObject["someProperty"]

与

相同

myObject.someProperty

是的，这也让我感到难过： - （

Answer 8

我刚才将一个小型JavaScript模块放在一起，为字符串，对象，数组等生成哈希码。（我只是将其提交给 GitHub :)）

用法：

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

Answer 9

在ECMAScript 6中，现在有一个Set符合您的要求： https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set

最新的Chrome，FF和IE11已经提供。

Answer 10

参考： https://developer.mozilla .ORG / EN-US /文档/网络/的JavaScript /参考/ Global_Objects /符号

您可以使用Es6符号创建唯一键和访问对象。     从Symbol（）返回的每个符号值都是唯一的。符号值可以用作对象属性的标识符;这是数据类型的唯一目的。

var obj = {};

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

Answer 11

这是我的简单解决方案，它返回一个唯一的整数。

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

Answer 12

我的解决方案为全局Object对象引入了静态函数。

(function() {
    var lastStorageId = 0;

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

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

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

我认为这对JavaScript中的其他对象操作函数更方便。

Answer 13

如果你真的想要设置行为（我是通过Java知识），那么你将很难在JavaScript中找到解决方案。大多数开发人员会建议使用唯一键来表示每个对象，但这与set不同，因为您可以获得两个相同的对象，每个对象都有一个唯一的键。 Java API通过比较哈希代码值而不是键来检查重复值，并且由于JavaScript中没有对象的哈希码值表示，因此几乎不可能这样做。甚至Prototype JS库也承认了这个缺点，当它说：

  

<！>“哈希可以被认为是一个   关联数组，绑定唯一键   价值观（不一定是   唯一的）... QUOT <！>;

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

Answer 14

除了eyelidlessness的答案之外，这里还有一个为任何对象返回可重现的唯一ID的函数：

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

正如你所看到的，它使用了一个非常低效的查找列表，但这是我现在能找到的最好的。

Answer 15

如果你想使用对象作为键，你需要覆盖它们的toString方法，就像这里已经提到的那样。使用的哈希函数都很好，但它们只适用于相同的对象，而不适用于相同的对象。

我编写了一个从对象创建哈希的小型库，您可以轻松地将其用于此目的。对象甚至可以有不同的顺序，哈希将是相同的。在内部，您可以为哈希使用不同的类型（djb2，md5，sha1，sha256，sha512，ripemd160）。

以下是文档中的一个小例子：

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

该软件包可以在浏览器和Node-Js中使用。

存储库： https://bitbucket.org/tehrengruber/es-js-hash

Answer 16

如果要在查找对象中具有唯一值，可以执行以下操作：

创建查找对象

var lookup = {};

设置哈希码功能

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

<强>对象

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

<强>阵列

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

其他类型

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

最终结果

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

请注意，当对象或数组为空时，getHashCode不会返回任何值

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

这与@ijmacd解决方案类似，只有JSON没有<=>依赖。

Answer 17

我会尝试比其他答案更深入一些。

即使 JS 有更好的哈希支持，它也不会神奇地完美地哈希所有内容，在许多情况下，您必须定义自己的哈希函数。例如Java有很好的哈希支持，但是你仍然需要思考并做一些工作。

一个问题是术语哈希/哈希码......有加密哈希和非加密哈希。另一个问题是您必须了解散列为什么有用以及它是如何工作的。

当我们谈论 JavaScript 或 Java 中的哈希时，大多数时候我们谈论的是非加密哈希，通常是哈希图/哈希表的哈希（除非我们正在处理身份验证或密码，您可以使用 NodeJS 在服务器端进行这些操作）。 ..)。

这取决于您拥有哪些数据以及您想要实现的目标。

您的数据具有一些自然的“简单”独特性：

• 整数的哈希值是...整数，因为它是唯一的，你很幸运！
• 字符串的哈希值...这取决于字符串，如果字符串表示唯一标识符，您可以将其视为散列（因此不需要散列）。
• 任何间接几乎唯一的整数都是最简单的情况
• 这将尊重：如果对象相等，则哈希码相等

您的数据具有一些自然的“复合”独特性：

• 例如，对于 person 对象，您可以使用名字、姓氏、出生日期等计算哈希值。看看 Java 是如何做到的： 良好的字符串哈希函数, ，或者使用一些其他足够便宜且独特的 ID 信息来满足您的用例

您不知道您的数据是什么：

• 祝你好运 ...你可以序列化为字符串并对其进行散列Java风格，但是如果字符串很大并且它不能避免冲突以及整数（自身）的散列，那么这可能会很昂贵。

对于未知数据，没有神奇有效的哈希技术，在某些情况下它很容易，在其他情况下你可能需要三思而后行。所以即使 JavaScript/ECMAScript 添加了更多支持，也没有神奇的语言解决这个问题。

在实践中你需要两件事：足够的独特性，足够的速度

除此之外，它还很棒：“如果对象相等，则哈希码相等”

• https://en.wikipedia.org/wiki/Hash_table#Collision_resolution
• Java中hashCode和equals方法的关系

Answer 18

我结合了眼睑和KimKha的答案。

以下是angularjs服务，它支持数字，字符串和对象。

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

使用示例：

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

<强>输出

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

<强>解释

正如您所看到的，服务的核心是KimKha创建的哈希函数。我已经在字符串中添加了类型，这样对象的结构也会影响最终的哈希值。键被哈希以防止数组|物体碰撞。

eyelidlessness对象比较用于通过自引用对象来防止无限递归。

<强>用法

我创建了这个服务，以便我可以使用对象访问的错误服务。因此，一个服务可以向给定对象注册错误，另一个服务可以确定是否发现任何错误。

<强>即

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

这将返回：

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

虽然

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

这将返回

[]