为什么在 JavaScript 中，如果 key 是对象，object[key] 不等于 key？

Question

var a = new Object;
var b = new Object;
var c = new Object;

c[a] = a;
c[b] = b;

console.log(c[a] === a);

我测试了上面的代码，得到了false。如果我尝试console.log(c[a] === b)，则会打印true。

为什么？

Answer 1

这里的问题与如何设置Object 的键有关。来自MDN：

参数

nameValuePair1, nameValuePair2, ... nameValuePairN

• 成对的名称（字符串）和值（任何值），其中名称与值之间用冒号分隔。

价值

• 任何值。

可以通过三种方式（通过适当的键）访问对象的值：

var o = {};
var key = "fun";

// method 1:
o[key]    = "the key will be equal to `key.toString()"
// method 2:
o.key     = "the key will be equal to 'key'"
// method 3:
o["key2"] = "the key will be equal to `key2`"
/*
{
    "fun" : "the key will be...",    // method 1
    "key" : "the key will be...",    // method 2
    "key2": "the key will be..."     // method 3
}
*/

使用括号表示法时，您需要注意括号之间的间隙...！对象使用toString 方法设置它们的键和值，除非它们被传递一个字符串（那么toString 没有意义）。使用点表示法时，他们使用.key 作为键。

让我们看看你的情况：

var a = {}
  , b = {}
  , c = {}
  ;

c[a] = a;
// `a` is not a string, and we're using brackets, so the key
// will be equal to `key.toString()`:
// a.toString() === "[object Object]"
// Try the following in your console: `{}.toString()`
// Note how this is different from console.log({}), since
// the console exposes your object (that's why the dev console is useful)
// c is now: `{ "[object Object]" : a }`

c[b] = b;
// b is also an object, so `b.toString()` is the same as `a.toString()`
// that means c is now `{ "[object Object]" : b }`

assert c[a] === a
// a.toString() == b.toString() == "[object Object]"
// and we just noted that c was `{ "[object Object]" : b }`
// so of course this is false
assert c[b] === b
// true because c[b] == b;
assert c["[object Object]"] === b;
// also true
assert c.b === b
// false, since `c` has no "b" key (c.b is `undefined`)

Answer 2

对象不是 JavaScript 对象的有效键，只有字符串是

所以，当你这样做时：

c[a] = a;
c[b] = b;

编译器不能像在 c[a] 或 c[b] 中那样使用 a 或 b 作为 c 的键。

但是，它并没有失败，因为 JavaScript 可以解决这个问题。首先它发现

1. 变量是一个对象，并且
2. 变量具有 toString -function

因此，JavaScript 编译器将调用每个变量的 toString()。默认情况下，Object.prototype.toString 它将返回“[object Object]”-string，因为实现是执行此操作的默认实现，并且该值成为新键

c["[object Object]"] = a;
c["[object Object]"] = b; // overrides the previous

这不是你想要的。问题是 toString 默认总是返回相同的值，所以分配总是会指向同一个键。

为了证明toString实际上是问题所在，你实际上可以做一个可怕的作弊来让每个对象返回唯一的字符串

// don't do this!!! 
(function() {
  var id=1;
  Object.prototype.toString = function() {
   if(!this._id) this._id = id++;
   return "Object"+this._id;
  }
}());

之后 c[a] 的键将是 c["Object1"] 并且 c[b] 将是 c["Object2"] 等等......并且 c[a] == a 和 c[ b] == b 按预期工作，但在现实生活中这不是一个好的解决方案。

解决这个问题的一种可接受的方法是使用其他键，可能是分配给对象的 ID，如 c[a.id] = a 或使用 ES6 Map Object，其中可以使用任何值，包括 Objects作为钥匙。

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

Map 对象是一个简单的键/值映射。任何值（对象和 原始值）可以用作键或值。

Answer 3

我稍微尝试了一下，@royhowie 可能是对的。正如你在这个实现中看到的，我切换了分配的顺序，然后 c[a] == a 给出了一个 true。

var a = new Object;
var b = new Object;
var c = new Object;

//I switched the following lines of code
c[b]=b; 
c[a]=a;

console.log(c[a]===a);

输出：真