blocks|key|1719532|text|JavaScript规范将索引属性访问定义为对索引名称执行toString转换。例如,|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1719533|myObject[myProperty]+=+...;|code-block|syntax|javascript|1719534|等同于|1719535|myObject[myProperty.toString()]+=+...;|1719536|在JavaScript中，这是必需的|1719537|myObject["someProperty"]|1719538|1719539|myObject.someProperty|1719540|是的，这也让我很悲伤:-(|1719541|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|W|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|X|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|Z|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|10|8|@]|9|@]|A|$E|F]]|$1|O|3|H|5|6|7|11|8|@]|9|@]|A|$]]|$1|P|3|Q|5|D|7|12|8|@]|9|@]|A|$E|F]]|$1|R|3|S|5|6|7|13|8|@]|9|@]|A|$]]|$1|T|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|U|$]]

The JavaScript specification defines indexed property access as performing a toString conversion on the index name. For example,

<pre><code>myObject[myProperty] = ...;
</code></pre>

is the same as

<pre><code>myObject[myProperty.toString()] = ...;
</code></pre>

This is necessary as in JavaScript

<pre><code>myObject["someProperty"]
</code></pre>

is the same as

<pre><code>myObject.someProperty
</code></pre>

And yes, it makes me sad as well :-(

blocks|key|1504554|text|要做到这一点，最简单的方法是为每个对象提供自己唯一的toString方法：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1504555|(function()+{
++++var+id+=+0;

++++/*global+MyObject+*/
++++MyObject+=+function()+{
++++++++this.objectId+=+'<#MyObject:'+%2B+(id%2B%2B)+%2B+'>';
++++++++this.toString=+function()+{
++++++++++++return+this.objectId;
++++++++};
++++};
})();|code-block|syntax|javascript|1504556|我也遇到过同样的问题，这对我来说完美地解决了这个问题，而且比重新实现一些胖的Java风格的Hashtable并将equals()和hashCode()添加到对象类要容易得多。只要确保你没有把一个字符串'<#MyObject:12>‘放入你的散列中，否则它会用这个id清除你正在退出的对象的入口。|1504557|现在我所有的哈希都很酷了。几天前我还发布了一篇关于this+exact+topic的博客文章。|1504558|entityMap|0|LINK|mutability|MUTABLE|url|http://strd6.com/?p=276^0|Q|8|0|0|19|9|1K|8|1T|A|0|P|G|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|17|8|@]|D|@$9|18|A|19|1|1A]]|E|$]]|$1|O|3|-4|5|6|7|1B|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]]]

The easiest way to do this is to give each of your objects its own unique <code>toString</code> method:

<pre><code>(function() {
 var id = 0;

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

I had the same problem and this solved it perfectly for me with minimal fuss, and was a lot easier that re-implementing some fatty Java style <code>Hashtable</code> and adding <code>equals()</code> and <code>hashCode()</code> to your object classes. Just make sure that you don't also stick a string '&lt;#MyObject:12> into your hash or it will wipe out the entry for your exiting object with that id.

Now all my hashes are totally chill. I also just posted a blog entry a few days ago about <a href="http://strd6.com/?p=276" rel="noreferrer">this exact topic</a>.

blocks|key|1504634|text|我选择的解决方案类似于丹尼尔的解决方案，但我没有使用对象工厂并覆盖toString，而是在第一次通过getHashCode函数请求对象时显式地将散列添加到对象中。有点乱，但更符合我的需求:)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1504635|Function.prototype.getHashCode+=+(function(id)+{
++++return+function()+{
++++++++if+(!this.hashCode)+{
++++++++++++this.hashCode+=+'<hash%7C#'+%2B+(id%2B%2B)+%2B+'>';
++++++++}
++++++++return+this.hashCode;
++++}
}(0));|code-block|syntax|javascript|1504636|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

The solution I chose is similar to Daniel's, but rather than use an object factory and override the toString, I explicitly add the hash to the object when it is first requested through a getHashCode function. A little messy, but better for my needs :)

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

blocks|key|1504697|text|如果你想要一个像JavaScript中的Java那样的hashCode()函数，那就是你想要的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1504698|String.prototype.hashCode+=+function(){
++++var+hash+=+0;
++++for+(var+i+=+0;+i+<+this.length;+i%2B%2B)+{
++++++++var+character+=+this.charCodeAt(i);
++++++++hash+=+((hash<<5)-hash)%2Bcharacter;
++++++++hash+=+hash+&+hash;+//+Convert+to+32bit+integer
++++}
++++return+hash;
}|code-block|syntax|javascript|1504699|这就是Java+(按位运算符)的实现方式。|1504700|请注意，hashCode可以是正的，也可以是负的，这是正常的，请参阅HashCode+giving+negative+values。因此，您可以考虑将Math.abs()与此函数一起使用。|offset|length|style|CODE|1504701|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/9249983/hashcode-giving-negative-values^0|0|0|0|23|A|Y|V|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|Z|8|@$K|10|L|11|M|N]]|9|@$K|12|L|13|1|14]]|A|$]]|$1|O|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

If you want a hashCode() function like Java's in JavaScript, that is yours:

<pre><code>String.prototype.hashCode = function(){
 var hash = 0;
 for (var i = 0; i &lt; this.length; i++) {
 var character = this.charCodeAt(i);
 hash = ((hash&lt;&lt;5)-hash)+character;
 hash = hash &amp; hash; // Convert to 32bit integer
 }
 return hash;
}
</code></pre>

That is the way of implementation in Java (bitwise operator).

Please note that hashCode could be positive and negative, and that's normal, see <a href="https://stackoverflow.com/questions/9249983/hashcode-giving-negative-values">HashCode giving negative values</a>. So, you could consider to use <code>Math.abs()</code> along with this function.

blocks|key|1719905|text|ECMAScript 6规范(JavaScript的下一版本)的一部分Harmony+WeakMaps已经涵盖了您所描述的内容。也就是说:一个集合，其中的键可以是任何东西(包括未定义的)，并且是不可枚举的。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1719906|这意味着除非直接引用键(任何对象)，否则不可能获得对值的引用。与之相关的链接。它对于与效率和垃圾收集相关的一系列引擎实现原因很重要，但它也非常酷，因为它允许新的语义，如可撤销的访问权限和在不暴露数据发送者的情况下传递数据。|1719907|来自MDN|1719908|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|code-block|syntax|javascript|1719909|WeakMaps可以在当前的火狐，浏览器和边缘浏览器中使用。在Node+v7和v6中使用--harmony-weak-maps标志也支持它们。|style|CODE|1719910|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/ECMAScript#Versions|1|https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/WeakMap|2|https://en.wikipedia.org/wiki/Mozilla_Developer_Network^0|0|C|0|17|8|1|0|0|2|3|2|0|0|18|J|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@$A|13|B|14|1|15]|$A|16|B|17|1|18]]|C|$]]|$1|D|3|E|5|6|7|19|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|1A|8|@]|9|@$A|1B|B|1C|1|1D]]|C|$]]|$1|H|3|I|5|J|7|1E|8|@]|9|@]|C|$K|L]]|$1|M|3|N|5|6|7|1F|8|@$A|1G|B|1H|O|P]]|9|@]|C|$]]|$1|Q|3|-4|5|6|7|1I|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]|Y|$5|T|U|V|C|$W|Z]]|10|$5|T|U|V|C|$W|11]]]]

What you described is covered by Harmony <a href="https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/WeakMap" rel="noreferrer">WeakMaps</a>, part of the <a href="http://en.wikipedia.org/wiki/ECMAScript#Versions" rel="noreferrer">ECMAScript&nbsp;6</a> specification (next version of JavaScript). That is: a set where the keys can be anything (including undefined) and is non-enumerable.

This means it's impossible to get a reference to a value unless you have a direct reference to the key (any object!) that links to it. It's important for a bunch of engine implementation reasons relating to efficiency and garbage collection, but it's also super cool for in that it allows for new semantics like revokable access permissions and passing data without exposing the data sender.

From <a href="https://en.wikipedia.org/wiki/Mozilla_Developer_Network" rel="noreferrer">MDN</a>:

<pre><code>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
</code></pre>

WeakMaps are available in current Firefox, Chrome and Edge. They're also supported in Node v7 , and in v6 with the <code>--harmony-weak-maps</code> flag.

blocks|key|1504904|text|除了eyelidlessness的答案之外，还有一个函数可以为任何对象返回一个可重现的、唯一的ID：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1504905|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);
}|code-block|syntax|javascript|1504906|正如你所看到的，它使用一个列表进行查找，效率非常低，但这是我目前所能找到的最好的。|1504907|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

In addition to eyelidlessness's answer, here is a function that returns a reproducible, unique ID for any object:

<pre><code>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) &lt; 0) {
 uniqueIdList.push(element);
 }
 return uniqueIdList.indexOf(element);
}
</code></pre>

As you can see it uses a list for look-up which is very inefficient, however that's the best I could find for now.

blocks|key|1504979|text|如果你想使用对象作为键，你需要重写他们的toString方法，就像这里已经提到的那样。使用的散列函数都很好，但它们只适用于相同的对象，而不适用于相等的对象。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1504980|我已经写了一个从对象创建散列的小型库，您可以很容易地将其用于此目的。对象甚至可以有不同的顺序，散列将是相同的。在内部，您可以使用不同的散列类型(djb2、md5、sha1、sha256、sha512、ripemd160)。|1504981|下面是文档中的一个小示例：|1504982|var+hash+=+require('es-hash');

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

var+foo+=+{};

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

/*
+*+Output:
+*++foo
+*++undefined
+*/
console.log(foo[{bar:+'foo'}]);
console.log(foo[{}]);|code-block|syntax|javascript|1504983|该包可以在浏览器中使用，也可以在Node-Js中使用。|1504984|存储库：https://bitbucket.org/tehrengruber/es-js-hash|offset|length|1504985|entityMap|0|LINK|mutability|MUTABLE|url|https://bitbucket.org/tehrengruber/es-js-hash^0|0|0|0|0|0|4|19|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|11|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|12|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|13|8|@]|9|@$O|14|P|15|1|16]]|A|$]]|$1|Q|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X]]]]

If you want to use objects as keys you need to overwrite their toString Method, as some already mentioned here. The hash functions that were used are all fine, but they only work for the same objects not for equal objects.

I've written a small library that creates hashes from objects, which you can easily use for this purpose. The objects can even have a different order, the hashes will be the same. Internally you can use different types for your hash (djb2, md5, sha1, sha256, sha512, ripemd160).

Here is a small example from the documentation:

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

The package can be used either in browser and in Node-Js.

Repository: <a href="https://bitbucket.org/tehrengruber/es-js-hash" rel="nofollow">https://bitbucket.org/tehrengruber/es-js-hash</a>

blocks|key|1505059|text|我的解决方案为全局Object对象引入了一个静态函数。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1505060|(function()+{
++++var+lastStorageId+=+0;

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

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

++++++++return+'#'+%2B+hash;
++++};
}());|code-block|syntax|javascript|1505061|我认为在JavaScript中使用其他对象操作函数会更方便。|1505062|entityMap^0|9|6|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

My solution introduces a static function for the global <code>Object</code> object.

<pre><code>(function() {
 var lastStorageId = 0;

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

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

 return '#' + hash;
 };
}());
</code></pre>

I think this is more convenient with other object manipulating functions in JavaScript.

blocks|key|1505123|text|不久前我把a+small+JavaScript+module放在一起，为字符串、对象、数组等生成哈希码(我刚刚把它提交给了GitHub+:)|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1505124|用法：|1505125|Hashcode.value("stackoverflow")
//+-2559914341
Hashcode.value({+'site'+:+"stackoverflow"+})
//+-3579752159|code-block|syntax|javascript|1505126|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/stuartbannerman/hashcode|1|http://en.wikipedia.org/wiki/GitHub^0|5|P|0|1P|6|1|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]|$A|Y|B|Z|1|10]]|C|$]]|$1|D|3|E|5|6|7|11|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|12|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|13|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]|S|$5|N|O|P|C|$Q|T]]]]

I put together <a href="https://github.com/stuartbannerman/hashcode">a small JavaScript module</a> a while ago to produce hashcodes for strings, objects, arrays, etc. (I just committed it to <a href="http://en.wikipedia.org/wiki/GitHub">GitHub</a> :) )

Usage:

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

blocks|key|1505151|text|对于我的特定情况，我只关心对象的相等性，就像键和原始值一样。对我有效的解决方案是将对象转换为其JSON表示，并将其用作散列。有一些限制，比如键定义的顺序可能不一致；但就像我说的那样，它对我来说很有效，因为这些对象都是在一个地方生成的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1505152|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
//+}|code-block|syntax|javascript|1505153|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

For my specific situation I only care about the equality of the object as far as keys and primitive values go. The solution that worked for me was converting the object to its JSON representation and using that as the hash. There are limitations such as order of key definition potentially being inconsistent; but like I said it worked for me because these objects were all being generated in one place.

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

blocks|key|1505222|text|在ECMAScript+6中，现在有一个Set可以按您的喜好工作：https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1505223|它已经在最新的Chrome，FF和IE11中可用。|1505224|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set^0|K|3|X|2C|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]]|D|@$9|S|A|T|1|U]]|E|$]]|$1|F|3|G|5|6|7|V|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]]]

In ECMAScript 6 there's now a <code>Set</code> that works how you'd like: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set" rel="noreferrer">https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set</a>

It's already available in the latest Chrome, FF, and IE11.

blocks|key|1505362|text|参考：https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1505363|您可以使用Es6符号来创建唯一的键和访问对象。Symbol()返回的每个符号值都是唯一的。符号值可以用作对象属性的标识符；这是数据类型的唯一用途。|1505364|var+obj+=+{};

obj[Symbol('a')]+=+'a';
obj[Symbol.for('b')]+=+'b';
obj['c']+=+'c';
obj.d+=+'d';|code-block|syntax|javascript|1505365|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol^0|3|2F|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

Reference: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol" rel="noreferrer">https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol</a>

you can use Es6 symbol to create unique key and access object.
 Every symbol value returned from Symbol() is unique. A symbol value may be used as an identifier for object properties; this is the data type's only purpose. 

<pre><code>var obj = {};

obj[Symbol('a')] = 'a';
obj[Symbol.for('b')] = 'b';
obj['c'] = 'c';
obj.d = 'd';
</code></pre>

blocks|key|1720512|text|下面是我的简单解决方案，返回一个唯一的整数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1720513|function+hashcode(obj)+{
++++var+hc+=+0;
++++var+chars+=+JSON.stringify(obj).replace(/\{%7C\"%7C\}%7C\:%7C,/g,+'');
++++var+len+=+chars.length;
++++for+(var+i+=+0;+i+<+len;+i%2B%2B)+{
++++++++//+Bump+7+to+larger+prime+number+to+increase+uniqueness
++++++++hc+%2B=+(chars.charCodeAt(i)+*+7);
++++}
++++return+hc;
}|code-block|syntax|javascript|1720514|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here's my simple solution that returns a unique integer.

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

Basically, I'm trying to create an object of unique objects, a set. I had the brilliant idea of just using a JavaScript object with objects for the property names. Such as,

<pre><code>set[obj] = true;
</code></pre>

This works, up to a point. It works great with string and numbers, but with other objects, they all seem to "hash" to the same value and access the same property. Is there some kind of way I can generate a unique hash value for an object? How do strings and numbers do it, can I override the same behavior?

Is there any kind of hash code function in JavaScript?

JSON

Java

基本上，我正在尝试创建一个包含唯一对象的对象，一个集合。我有一个绝妙的想法，那就是只使用一个JavaScript对象和属性名称的对象。比如,set[obj] = true;在一定程度上，这是可行的。它可以很好地处理字符串和数字，但对于其他对象，它们似乎都“散列”到相同的值并访问相同的属性。是否有某种方法可以为对象生成唯...

问在JavaScript中有没有某种哈希码函数？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在JavaScript中有没有某种哈希码函数？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在JavaScript中有没有某种哈希码函数？
EN