Symbol 类型

根据规范，对象的属性键只能是 String 类型或者 Symbol 类型。不是 Number，也不是 Boolean，只有 String 或 Symbol 这两种类型。

到目前为止，我们只见过 String。现在我们来看看 Symbol 能给我们带来什么好处。

Symbol

“Symbol” 值表示唯一的标识符。

可以使用 Symbol() 来创建这种类型的值：

// id 是 symbol 的一个实例化对象
let id = Symbol();

我们可以给 Symbol 一个描述（也称为 Symbol 名），这对于调试非常有用：

// id 是描述为 "id" 的 Symbol
let id = Symbol("id");

Symbol 保证是唯一的。即使我们创建了许多具有相同描述的 Symbol，它们的值也是不同。描述只是一个不影响任何东西的标签。

例如，这里有两个描述相同的 Symbol —— 它们不相等：

let id1 = Symbol("id");
let id2 = Symbol("id");

*!*
alert(id1 == id2); // false
*/!*

如果您熟悉 Ruby 或者其他有 “Symbol” 的语言 —— 别被误导。JavaScript 的 Symbol 与众不同。

JavaScript 中的大多数值都支持 string 的隐式转换。例如，我们可以 `alert` 任何值，这会起作用。Symbol 是特别的，它无法自动转换。例如，这个 `alert` 将会显示错误：

let id = Symbol(“id”);
!
alert(id); // 类型错误：无法将 Symbol 值转换为 String。
/!

如果我们真的想显示一个 Symbol，我们需要在它上面调用 `.toString()`，如下所示：

let id = Symbol(“id”);
!
alert(id.toString()); // Symbol(id)，现在它起作用了
/!

这是一种防止混乱的“语言保护”，因为 String 和 Symbol 有本质上的不同，而且不应该偶尔将它们相互转化。

“隐藏”属性

Symbol 允许我们创建对象的“隐藏”属性，代码的任何其他部分都不能偶尔访问或重写这些属性。

例如，如果我们想存储 object user 的“标识符”，我们可以使用 Symbol 作为它的键：

let user = {name: "John"};
let id = Symbol("id");

user[id] = "ID Value";
alert(user[id] ); // 我们可以使用 Symbol 作为键来访问数据。

在 string "id" 上使用 Symbol("id") 有什么好处？

我们用更深入一点的示例来说明这一点。

假设另一个脚本希望 user 中有它自己的 “id” 属性可以操作。这可能是另一个 JavaScript 库，所以这些脚本完全不知道对方是谁。

然后该脚本可以创建自己的 Symbol("id")，如下所示：

// ...
let id = Symbol("id");

user[id] = "Their id value";

不会冲突，因为 Symbol 总是不同的，即使它们有相同的名称。

现在请注意，如果我们使用 String "id" 而不是用 symbol，那么 就会 出现冲突：

let user = {name: "John"};

// 我们的脚本使用 "id" 属性。user.id = "ID Value";

// ... 如果之后另一个脚本为其目的使用 "id"...

user.id = "Their id value"
// 砰！无意中重写了 id！他不是故意伤害同事的，而是这样做了！

字面量中的 Symbol

如果我们要在 object 字面量中使用 Symbol，则需要方括号。

就像这样：

let id = Symbol("id");

let user = {
  name: "John",
*!*
  [id]: 123 // 不仅仅是 "id：123"
*/!*
};

这是因为我们需要变量 id 的值作为键，而不是 String “id”。

Symbol 在 for..in 中被跳过

Symbolic 属性不参与 for..in 循环。

例如：

let id = Symbol("id");
let user = {
  name: "John",
  age: 30,
  [id]: 123
};

*!*
for (let key in user) alert(key); // name, age (no symbols)
*/!*

// 被 Symbol 任务直接访问
alert("Direct:" + user[id] );

这是一般“隐藏”概念的一部分。如果另一个脚本或库在我们的对象上循环，它不会访问一个 Symbol 类型的属性。

相反，Object.assign 同时复制字符串和符号属性：

let id = Symbol("id");
let user = {[id]: 123
};

let clone = Object.assign({}, user);

alert(clone[id] ); // 123

这里并不矛盾，就是这样设计的。我们的想法是当我们克隆一个 object 或合并 object 时，通常希望 所有 属性被复制（包括像 id 这样的 Symbol）。

我们只能在对象中使用 string 或 symbol 作为键，其它类型转换为 String。例如，在作为属性键使用时，数字 `0` 变成了字符串 `"0"`：

let obj = {
0: “test” // same as “0”: “test”
};

// 两个 alert 都访问相同的属性（Number 0 被转换为 String “0”）
alert(obj[“0”] ); // test
alert(obj[0] ); // test（相同属性）

全局 symbol

正如我们所看到的，通常所有的 Symbol 都是不同的，即使它们有相同的名字。但有时我们想要同一个名字的 Symbol 是相同的实体。

比如，我们希望在应用程序的不同部分访问相同的 Symbol "id" 属性。

为此，存在一个 全局 symbol 注册表。我们可以在其中创建 Symbol 并在稍后访问它们，它可以确保每次访问相同名称都会返回相同的 Symbol。

为了在注册表中创建或读取 Symbol，请使用 Symbol.for(key)。

该调用会检查全局注册表，如果有一个描述为 key 的 Symbol，则返回该 Symbol，否则将创建一个新 Symbol（Symbol(key)），并通过给定的 key 将其存储在注册表中。

例如：

// 从全局注册表中读取
let id = Symbol.for("id"); // 如果该 Symbol 不存在，则创建它

// 再次读取
let idAgain = Symbol.for("id");

// 相同的 Symbol
alert(id === idAgain); // true

注册表内的 Symbol 称为 全局 Symbol。如果我们想要一个应用程序范围内的 Symbol，可以在代码中随处访问 —— 这就是它们的用途。

在一些编程语言中，例如 Ruby，每个名称都有一个 symbol。在 JavaScript 中，我们应该用全局 symbol。

Symbol.keyFor

对于全局 symbol，Symbol.for(key) 不仅按名称返回一个 symbol，而且还有一个反向调用：Symbol.keyFor(sym)，反过来：通过全局 symbol 返回一个名称。

例如：

let sym = Symbol.for("name");
let sym2 = Symbol.for("id");

// 从 symbol 中获取 name
alert(Symbol.keyFor(sym) ); // name
alert(Symbol.keyFor(sym2) ); // id

Symbol.keyFor 在内部使用全局 symbol 注册表来查找 symbol 的键。所以它不适用于非全局 symbol。如果 symbol 不是全局的，它将无法找到它并返回 undefined。

例如：

alert(Symbol.keyFor(Symbol.for("name")) ); // name, 全局 Symbol

alert(Symbol.keyFor(Symbol("name2")) ); // undefined, 参数不是一个全局 Symbol

系统 Symbol

JavaScript 内部存在很多“系统”Symbol，我们可以使用它们来微调对象的各个方面。

它们列在熟悉的 Symbol 表的规范中：

• Symbol.hasInstance
• Symbol.isConcatSpreadable
• Symbol.iterator
• Symbol.toPrimitive
• … 等等。

例如，Symbol.toPrimitive 允许我们将对象描述为原始值转换，我们很快就会看到它的使用。

当我们研究相应的语言特征时，其他 Symbol 也会变得熟悉起来。

总结

Symbol 是唯一标识符的基本类型

Symbol 使用 Symbol() 创建的，调用带有一个可选的描述。

Symbol 总是不同的值，即使它们有相同的名称。如果我们希望同名 Symbol 相等，那么我们应该使用全局注册表：Symbol.for(key) 返回（如果需要的话创建）一个以 key 作为名称的全局 Symbol。Symbol.for 的多次调用完全返回相同的 Symbol。

Symbol 有两个主要的使用场景：

1. “隐藏”对象属性。如果需要将属性添加到“属于”另一个脚本或库的对象中，则可以创建 Symbol 并将其用作属性键。Symbol 属性不出现在 for..in中，因此不会无心列出。另外，它不会被直接访问，因为另一个脚本没有我们的符号，所以它不会不小心干预它的操作。

   因此我们可以使用 Symbol 属性“秘密地”将一些东西隐藏到我们需要的对象中，但其他人不会以对象属性的形式看到它。

2. JavaScript 使用了许多系统 Symbol，这些 Symbol 可以作为 Symbol.* 访问。我们可以使用它们来改变一些内置行为。例如，在本教程的后面部分，我们将使用 Symbol.iterator 来迭代，Symbol.toPrimitive 来设置对象原始值的转换等等。

从技术上说，Symbol 不是 100% 隐藏的。有一个内置方法 Object.getOwnPropertySymbols(obj) 允许我们获取所有的 Symbol。还有一个名为 Reflect.ownKeys(obj) 返回 所有 键，包括 Symbol。所以它们不是真正的隐藏。但是大多数库、内置方法和语法结构都遵循一个共同的协议。而明确调用上述方法的人可能很清楚他在做什么。