最近面试问了很多次的ES6的新特性-Symbol是干啥的？

那symbol到底是什么呢？

在 ES6 中，Symbol 是一种全新的原始数据类型（primitive type），与 string、number、boolean 等并列，它的主要特点是独一无二，可以作为对象属性的标识符。

一、Symbol 是什么？

Symbol 通过 Symbol() 函数创建，每次调用都会生成一个完全唯一的值，即使传入相同的描述文本，生成的 Symbol 也不相等：

const s1 = Symbol();
const s2 = Symbol();
console.log(s1 === s2); // false

// 可以添加描述文本（仅用于调试，不影响唯一性）
const s3 = Symbol('foo');
const s4 = Symbol('foo');
console.log(s3 === s4); // 仍然是 false

二、Symbol 的核心使用场景

1. 作为对象的唯一属性键，避免属性名冲突

当多个模块或代码片段需要为同一个对象添加属性时，传统字符串键名可能导致意外覆盖（比如两个地方都用了 'name' 作为键）。而 Symbol 作为键名时，永远不会与其他键名冲突：

// 模块 A
const user = {};
const nameKey = Symbol('name');
user[nameKey] = 'Alice';

// 模块 B
const anotherNameKey = Symbol('name'); // 与模块 A 的 nameKey 不同
user[anotherNameKey] = 'Bob';

// 两个属性共存，互不干扰
console.log(user[nameKey]); // 'Alice'
console.log(user[anotherNameKey]); // 'Bob'

2. 定义对象的 "私有" 属性（模拟私有性）

ES6 没有原生私有属性，但可以用 Symbol 模拟类似效果。因为 Symbol 键名不会出现在 for...in、Object.keys() 等常规遍历中，只能通过 Object.getOwnPropertySymbols() 访问，起到隐藏属性的作用：

const secretKey = Symbol('secret');
const obj = {
  public: '公开信息',
  [secretKey]: '敏感信息' // 模拟私有属性
};

console.log(Object.keys(obj)); // ['public']，看不到 Symbol 属性
console.log(obj[secretKey]); // '敏感信息'（需要知道 secretKey 才能访问）

3. 定义常量集合，避免魔法字符串

当需要一组互不相等的常量（比如状态码、事件类型）时，用 Symbol 比字符串更安全，避免拼写错误导致的 bug：

// 传统字符串方式（可能因拼写错误导致逻辑错误）
const STATUS = {
  PENDING: 'pending',
  SUCCESS: 'succes' // 拼写错误，不易察觉
};

// Symbol 方式（确保唯一性，避免错误）
const STATUS = {
  PENDING: Symbol('pending'),
  SUCCESS: Symbol('success'),
  ERROR: Symbol('error')
};

// 使用时不会因拼写错误匹配到错误值
if (currentStatus === STATUS.SUCCESS) { ... }

4. 为内置对象扩展方法

当需要给数组、字符串等内置对象添加自定义方法时，用 Symbol 作为方法名可以避免覆盖原生方法或与其他库冲突：

// 给数组添加自定义遍历方法，不会影响原生 forEach
Array.prototype[Symbol.for('customForEach')] = function(callback) {
  for (let i = 0; i < this.length; i++) {
    callback(this[i], i, this);
  }
};

[1, 2, 3][Symbol.for('customForEach')](item => console.log(item));

三、解决了什么问题？

1. 属性名冲突问题：通过唯一性保证，彻底避免多模块协作时的属性覆盖风险。
2. 私有属性模拟：提供了一种比字符串键名更隐蔽的属性定义方式，适合存储不希望被外部轻易访问的信息。
3. 常量唯一性：替代魔法字符串，让代码更健壮，减少因拼写错误导致的 bug。
4. 扩展安全性：安全地为内置对象或第三方对象添加扩展方法，避免命名冲突。

补充：全局 Symbol 注册表

如果需要在不同地方共享同一个 Symbol，可以使用 Symbol.for() 创建全局可复用的 Symbol：

// 在模块 A 创建
const globalSymbol = Symbol.for('globalKey');

// 在模块 B 中获取同一个 Symbol
const sameSymbol = Symbol.for('globalKey');
console.log(globalSymbol === sameSymbol); // true

Symbol.for() 会在全局注册表中查找键名，存在则返回，不存在则创建，适合跨模块共享 Symbol 的场景。

所以：Symbol 的核心价值在于其唯一性，它为对象属性命名、常量定义等场景提供了更安全、更灵活的解决方案。

那Symbol和ES6中其他新特性（如Set、Map等）如何配合使用？

Symbol 作为 ES6 引入的新原始类型，常与 Set、Map 等新数据结构配合使用，能解决一些特定场景下的问题。它们的组合使用往往能发挥各自的优势，以下是几个典型场景：

1. Symbol 作为 Map 的键（解决键名冲突）

Map 允许使用任意类型作为键（相比对象只能用字符串 / Symbol 作键更灵活），而 Symbol 的唯一性可以避免键名冲突，尤其适合多模块协作场景：

// 模块 A 定义的 Symbol 键
const userKey = Symbol('user');
const map = new Map();

// 存储数据
map.set(userKey, { name: 'Alice', age: 20 });

// 模块 B 中，即使定义同名 Symbol 也不会冲突
const anotherUserKey = Symbol('user');
map.set(anotherUserKey, { name: 'Bob', age: 22 });

// 取值时互不干扰
console.log(map.get(userKey)); // { name: 'Alice', ... }
console.log(map.get(anotherUserKey)); // { name: 'Bob', ... }

优势 ：相比用字符串作为 Map 键，Symbol 能确保不同模块 / 逻辑中定义的 "同名" 键不会互相覆盖，避免意外数据污染。

2. Symbol 与 Set 配合实现 "唯一标识" 集合

Set 的核心特性是存储唯一值（不会有重复元素），而 Symbol 本身具有唯一性，两者结合可用于追踪 "唯一实体"：

// 创建一组唯一的 Symbol 作为实体标识
const entity1 = Symbol('entity1');
const entity2 = Symbol('entity2');
const entity3 = Symbol('entity1'); // 与 entity1 不同

// 用 Set 管理这些唯一标识
const entities = new Set([entity1, entity2, entity3]);

console.log(entities.size); // 3（三个都是唯一的）
console.log(entities.has(entity1)); // true

场景 ：比如在游戏开发中，可用 Symbol 作为每个角色 / 物品的唯一 ID，再用 Set 存储所有 "活跃对象"，确保不会有重复的 ID 导致逻辑混乱。

3. Symbol 定义 Set/Map 的 "私有" 扩展方法

利用 Symbol 作为键，可以给 Set 或 Map 添加 "私有" 扩展方法（不会污染原型链或与其他库冲突）：

// 定义一个 Symbol 作为扩展方法的键
const setLog = Symbol('setLog');

// 给 Set 原型添加自定义方法
Set.prototype[setLog] = function() {
  console.log(`Set 包含 ${this.size} 个元素:`, [...this]);
};

// 使用扩展方法
const mySet = new Set([1, 2, 3]);
mySet[setLog](); // 输出: "Set 包含 3 个元素: [1, 2, 3]"

// 不会干扰其他方法，也不会被 for...in 遍历到
console.log('setLog' in mySet); // false（安全隐藏）

优势 ：相比直接给原型添加字符串命名的方法（可能与原生方法或其他库冲突），Symbol 确保了方法名的唯一性，避免覆盖风险。

4. Symbol 作为 Map 的 "元数据" 键

在 Map 中，可以用 Symbol 存储与主数据相关的 "元数据"（如描述、版本信息等），与业务数据分离：

// 定义元数据的 Symbol 键
const metaKey = Symbol('metadata');

// 主数据 Map
const dataMap = new Map();
dataMap.set('user', { name: 'Alice' });
dataMap.set('posts', [/* 文章列表 */]);

// 用 Symbol 存储元数据（不影响主数据的遍历）
dataMap.set(metaKey, { version: '1.0', updated: '2023-01-01' });

// 遍历主数据（不会包含元数据）
for (const [key, value] of dataMap) {
  if (key !== metaKey) {
    console.log('业务数据:', key, value);
  }
}

// 单独获取元数据
console.log('元数据:', dataMap.get(metaKey));

优势：元数据和业务数据通过键类型分离，遍历主数据时无需过滤，逻辑更清晰。

5. 全局 Symbol 与跨模块的 Set/Map 共享

通过 Symbol.for() 创建全局共享的 Symbol，可以在不同模块中操作同一个 Set/Map 的特定键：

// 模块 A
const globalKey = Symbol.for('sharedKey');
const sharedMap = new Map();
sharedMap.set(globalKey, '模块A的数据');

// 模块 B（无需导入，直接通过全局 Symbol 获取）
const sameKey = Symbol.for('sharedKey');
console.log(sharedMap.get(sameKey)); // "模块A的数据"（跨模块共享）

场景 ：在大型应用中，多模块需要操作同一个 Map/Set 时，全局 Symbol 可作为 "约定的唯一键"，避免硬编码字符串导致的不一致。

总结：配合的核心价值

• 唯一性保障 ：Symbol 解决 Set/Map 中键名冲突的问题，尤其适合多模块协作。
• 逻辑分离 ：用 Symbol 区分普通数据与元数据、公共方法与 "私有" 方法，使代码结构更清晰。
• 安全性：避免扩展原生对象时的方法覆盖风险，同时隐藏内部实现细节。

Symbol 与 Set/Map 的结合，本质上是用 "唯一标识" 特性增强了新数据结构的灵活性和安全性，尤其在复杂应用或库开发中能显著减少潜在 bug。

你学废了吗？