前言

实际上，Symbol 的很多特性都无法模拟实现……所以先让我们回顾下有哪些特性，然后挑点能实现的……当然在看的过程中，你也可以思考这个特性是否能实现，如果可以实现，该如何实现。

回顾

ES6 引入了一种新的原始数据类型 Symbol，表示独一无二的值。

1. Symbol 值通过 Symbol 函数生成，使用 typeof，结果为 "symbol"

  1. var s = Symbol();
  2. console.log(typeof s); // "symbol"

2. Symbol 函数前不能使用 new 命令，否则会报错。这是因为生成的 Symbol 是一个原始类型的值，不是对象。

3. instanceof 的结果为 false

  1. var s = Symbol('foo');
  2. console.log(s instanceof Symbol); // false

4. Symbol 函数可以接受一个字符串作为参数，表示对 Symbol 实例的描述，主要是为了在控制台显示，或者转为字符串时，比较容易区分。

  1. var s1 = Symbol('foo');
  2. console.log(s1); // Symbol(foo)

5. 如果 Symbol 的参数是一个对象，就会调用该对象的 toString 方法，将其转为字符串，然后才生成一个 Symbol 值。

  1. const obj = {
  2.   toString() {
  3.     return 'abc';
  4.   }
  5. };
  6. const sym = Symbol(obj);
  7. console.log(sym); // Symbol(abc)

6. Symbol 函数的参数只是表示对当前 Symbol 值的描述，相同参数的 Symbol 函数的返回值是不相等的。

  1. // 没有参数的情况
  2. var s1 = Symbol();
  3. var s2 = Symbol();
  4.  
  5. console.log(s1 === s2); // false
  6.  
  7. // 有参数的情况
  8. var s1 = Symbol('foo');
  9. var s2 = Symbol('foo');
  10.  
  11. console.log(s1 === s2); // false

7. Symbol 值不能与其他类型的值进行运算，会报错。

  1. var sym = Symbol('My symbol');
  2.  
  3. console.log("your symbol is " + sym); // TypeError: can't convert symbol to string

8. Symbol 值可以显式转为字符串。

  1. var sym = Symbol('My symbol');
  2.  
  3. console.log(String(sym)); // 'Symbol(My symbol)'
  4. console.log(sym.toString()); // 'Symbol(My symbol)'

9. Symbol 值可以作为标识符，用于对象的属性名，可以保证不会出现同名的属性。

  1. var mySymbol = Symbol();
  2.  
  3. // 第一种写法
  4. var a = {};
  5. a[mySymbol] = 'Hello!';
  6.  
  7. // 第二种写法
  8. var a = {
  9.   [mySymbol]: 'Hello!'
  10. };
  11.  
  12. // 第三种写法
  13. var a = {};
  14. Object.defineProperty(a, mySymbol, { value: 'Hello!' });
  15.  
  16. // 以上写法都得到同样结果
  17. console.log(a[mySymbol]); // "Hello!"

10. Symbol 作为属性名，该属性不会出现在 for…in、for…of 循环中，也不会被 Object.keys()、Object.getOwnPropertyNames()、JSON.stringify() 返回。但是，它也不是私有属性，有一个 Object.getOwnPropertySymbols 方法，可以获取指定对象的所有 Symbol 属性名。

  1. var obj = {};
  2. var a = Symbol('a');
  3. var b = Symbol('b');
  4.  
  5. obj[a] = 'Hello';
  6. obj[b] = 'World';
  7.  
  8. var objectSymbols = Object.getOwnPropertySymbols(obj);
  9.  
  10. console.log(objectSymbols);
  11. // [Symbol(a), Symbol(b)]

11. 如果我们希望使用同一个 Symbol 值，可以使用 Symbol.for。它接受一个字符串作为参数，然后搜索有没有以该参数作为名称的 Symbol 值。如果有，就返回这个 Symbol 值，否则就新建并返回一个以该字符串为名称的 Symbol 值。

  1. var s1 = Symbol.for('foo');
  2. var s2 = Symbol.for('foo');
  3.  
  4. console.log(s1 === s2); // true

12. Symbol.keyFor 方法返回一个已登记的 Symbol 类型值的 key。

  1. var s1 = Symbol.for("foo");
  2. console.log(Symbol.keyFor(s1)); // "foo"
  3.  
  4. var s2 = Symbol("foo");
  5. console.log(Symbol.keyFor(s2) ); // undefined

分析

看完以上的特性，你觉得哪些特性是可以模拟实现的呢？

如果我们要模拟实现一个 Symbol 的话，基本的思路就是构建一个 Symbol 函数，然后直接返回一个独一无二的值。

不过在此之前，我们先看看规范中调用 Symbol 时到底做了哪些工作：

Symbol ( [ description ] )

When Symbol is called with optional argument description, the following steps are taken:

  1. If NewTarget is not undefined, throw a TypeError exception.
  2. If description is undefined, var descString be undefined.
  3. Else, var descString be ToString(description).
  4. ReturnIfAbrupt(descString).
  5. Return a new unique Symbol value whose [[Description]] value is descString.

当调用 Symbol 的时候，会采用以下步骤：

  • 如果使用 new ，就报错
  • 如果 description 是 undefined，让 descString 为 undefined
  • 否则 让 descString 为 ToString(description)
  • 如果报错，就返回
  • 返回一个新的唯一的 Symbol 值，它的内部属性 [[Description]] 值为 descString
    考虑到还需要定义一个 [[Description]] 属性，如果直接返回一个基本类型的值，是无法做到这一点的，所以我们最终还是返回一个对象。

第一版

参照着规范，其实我们已经可以开始写起来了：

  1. // 第一版
  2. (function() {
  3.     var root = this;
  4.  
  5.     var SymbolPolyfill = function Symbol(description) {
  6.  
  7.         // 实现特性第 2 点：Symbol 函数前不能使用 new 命令
  8.         if (this instanceof SymbolPolyfill) throw new TypeError('Symbol is not a constructor');
  9.  
  10.         // 实现特性第 5 点：如果 Symbol 的参数是一个对象，就会调用该对象的 toString 方法，将其转为字符串，然后才生成一个 Symbol 值。
  11.         var descString = description === undefined ? undefined : String(description)
  12.  
  13.         var symbol = Object.create(null)
  14.  
  15.         Object.defineProperties(symbol, {
  16.             '__Description__': {
  17.                 value: descString,
  18.                 writable: false,
  19.                 enumerable: false,
  20.                 configurable: false
  21.             }
  22.         });
  23.  
  24.         // 实现特性第 6 点，因为调用该方法，返回的是一个新对象，两个对象之间，只要引用不同，就不会相同
  25.         return symbol;
  26.     }
  27.  
  28.     root.SymbolPolyfill = SymbolPolyfill;
  29. })();

只是参照着规范，我们已经实现了特性的第 2、5、6 点。

第二版

我们来看看其他的特性该如何实现：

1. 使用 typeof，结果为 "symbol"。

利用 ES5，我们并不能修改 typeof 操作符的结果，所以这个无法实现。

3. instanceof 的结果为 false

因为不是通过 new 的方式实现的，所以 instanceof 的结果自然是 false。

4. Symbol 函数可以接受一个字符串作为参数，表示对 Symbol 实例的描述。主要是为了在控制台显示，或者转为字符串时，比较容易区分。

当我们打印一个原生 Symbol 值的时候：

  1. console.log(Symbol('1')); // Symbol(1)

可是我们模拟实现的时候返回的却是一个对象，所以这个也是无法实现的，当然你修改 console.log 这个方法是另讲。

8. Symbol 值可以显式转为字符串。

  1. var sym = Symbol('My symbol');
  2.  
  3. console.log(String(sym)); // 'Symbol(My symbol)'
  4. console.log(sym.toString()); // 'Symbol(My symbol)'

当调用 String 方法的时候，如果该对象有 toString 方法，就会调用该 toString 方法，所以我们只要给返回的对象添加一个 toString 方法，即可实现这两个效果。

  1. // 第二版
  2.  
  3. // 前面面代码相同 ……
  4.  
  5. var symbol = Object.create({
  6.     toString: function() {
  7.         return 'Symbol(' + this.__Description__ + ')';
  8.     },
  9. });
  10.  
  11. // 后面代码相同 ……

第三版

9. Symbol 值可以作为标识符，用于对象的属性名，可以保证不会出现同名的属性。

看着好像没什么，这点其实和第 8 点是冲突的，这是因为当我们模拟的所谓 Symbol 值其实是一个有着 toString 方法的 对象，当对象作为对象的属性名的时候，就会进行隐式类型转换，还是会调用我们添加的 toString 方法，对于 Symbol('foo') 和 Symbol('foo')两个 Symbol 值，虽然描述一样，但是因为是两个对象，所以并不相等，但是当作为对象的属性名的时候，都会隐式转换为 Symbol(foo) 字符串，这个时候就会造成同名的属性。举个例子：

  1. var a = SymbolPolyfill('foo');
  2. var b = SymbolPolyfill('foo');
  3.  
  4. console.log(a ===  b); // false
  5.  
  6. var o = {};
  7. o[a] = 'hello';
  8. o[b] = 'hi';
  9.  
  10. console.log(o); // {Symbol(foo): 'hi'}

为了防止不会出现同名的属性，毕竟这是一个非常重要的特性，迫不得已，我们需要修改 toString 方法，让它返回一个唯一值，所以第 8 点就无法实现了，而且我们还需要再写一个用来生成 唯一值的方法，就命名为 generateName，我们将该唯一值添加到返回对象的 Name 属性中保存下来。

  1. // 第三版
  2. (function() {
  3.     var root = this;
  4.  
  5.     var generateName = (function(){
  6.         var postfix = 0;
  7.         return function(descString){
  8.             postfix++;
  9.             return '@@' + descString + '_' + postfix
  10.         }
  11.     })()
  12.  
  13.     var SymbolPolyfill = function Symbol(description) {
  14.  
  15.         if (this instanceof SymbolPolyfill) throw new TypeError('Symbol is not a constructor');
  16.  
  17.         var descString = description === undefined ? undefined : String(description)
  18.  
  19.         var symbol = Object.create({
  20.             toString: function() {
  21.                 return this.__Name__;
  22.             }
  23.         })
  24.  
  25.         Object.defineProperties(symbol, {
  26.             '__Description__': {
  27.                 value: descString,
  28.                 writable: false,
  29.                 enumerable: false,
  30.                 configurable: false
  31.             },
  32.             '__Name__': {
  33.                 value: generateName(descString),
  34.                 writable: false,
  35.                 enumerable: false,
  36.                 configurable: false
  37.             }
  38.         });
  39.  
  40.         return symbol;
  41.     }
  42.  
  43.  
  44.     root.SymbolPolyfill = SymbolPolyfill;
  45.  
  46. })()

此时再看下这个例子：

  1. var a = SymbolPolyfill('foo');
  2. var b = SymbolPolyfill('foo');
  3.  
  4. console.log(a ===  b); // false
  5.  
  6. var o = {};
  7. o[a] = 'hello';
  8. o[b] = 'hi';
  9.  
  10. console.log(o); // Object { "@@foo_1": "hello", "@@foo_2": "hi" }

第四版

我们再看看接下来的特性。

7.Symbol 值不能与其他类型的值进行运算，会报错。

以 + 操作符为例，当进行隐式类型转换的时候，会先调用对象的 valueOf 方法，如果没有返回基本值，就会再调用 toString 方法，所以我们考虑在 valueOf 方法中进行报错，比如：

  1. var symbol = Object.create({
  2.     valueOf: function() {
  3.         throw new Error('Cannot convert a Symbol value')
  4.     }
  5. })
  6.  
  7. console.log('1' + symbol); // 报错

看着很简单的解决了这个问题，可是如果我们是显式调用 valueOf 方法呢？对于一个原生的 Symbol 值：

  1. var s1 = Symbol('foo')
  2. console.log(s1.valueOf()); // Symbol(foo)

是的，对于原生 Symbol，显式调用 valueOf 方法，会直接返回该 Symbol 值，而我们又无法判断是显式还是隐式的调用，所以这个我们就只能实现一半，要不然实现隐式调用报错，要不然实现显式调用返回该值，那……我们选择不报错的那个吧，即后者。

我们迫不得已的修改 valueOf 函数：

  1. // 第四版
  2. // 前面面代码相同 ……
  3.  
  4. var symbol = Object.create({
  5.     toString: function() {
  6.         return this.__Name__;
  7.     },
  8.     valueOf: function() {
  9.         return this;
  10.     }
  11. });
  12. // 后面代码相同 ……

第五版

10. Symbol 作为属性名，该属性不会出现在 for…in、for…of 循环中，也不会被 Object.keys()、Object.getOwnPropertyNames()、JSON.stringify() 返回。但是，它也不是私有属性，有一个 Object.getOwnPropertySymbols 方法，可以获取指定对象的所有 Symbol 属性名。

嗯，无法实现。

11. 有时，我们希望重新使用同一个Symbol值，Symbol.for方法可以做到这一点。它接受一个字符串作为参数，然后搜索有没有以该参数作为名称的Symbol值。如果有，就返回这个Symbol值，否则就新建并返回一个以该字符串为名称的Symbol值。

这个实现类似于函数记忆，我们建立一个对象，用来储存已经创建的 Symbol 值即可。

12. Symbol.keyFor 方法返回一个已登记的 Symbol 类型值的 key。

遍历 forMap,查找该值对应的键值即可。

  1. // 第五版
  2. // 前面代码相同 ……
  3. var SymbolPolyfill = function() { ... }
  4.  
  5. var forMap = {};
  6.  
  7. Object.defineProperties(SymbolPolyfill, {
  8.     'for': {
  9.         value: function(description) {
  10.             var descString = description === undefined ? undefined : String(description)
  11.             return forMap[descString] ? forMap[descString] : forMap[descString] = SymbolPolyfill(descString);
  12.         },
  13.         writable: true,
  14.         enumerable: false,
  15.         configurable: true
  16.     },
  17.     'keyFor': {
  18.         value: function(symbol) {
  19.             for (var key in forMap) {
  20.                 if (forMap[key] === symbol) return key;
  21.             }
  22.         },
  23.         writable: true,
  24.         enumerable: false,
  25.         configurable: true
  26.     }
  27. });
  28. // 后面代码相同 ……

完整实现

综上所述：

无法实现的特性有：1、4、7、8、10

可以实现的特性有：2、3、5、6、9、11、12

最后的实现如下:

  1. (function() {
  2.     var root = this;
  3.  
  4.     var generateName = (function(){
  5.         var postfix = 0;
  6.         return function(descString){
  7.             postfix++;
  8.             return '@@' + descString + '_' + postfix
  9.         }
  10.     })()
  11.  
  12.     var SymbolPolyfill = function Symbol(description) {
  13.  
  14.         if (this instanceof SymbolPolyfill) throw new TypeError('Symbol is not a constructor');
  15.  
  16.         var descString = description === undefined ? undefined : String(description)
  17.  
  18.         var symbol = Object.create({
  19.             toString: function() {
  20.                 return this.__Name__;
  21.             },
  22.             valueOf: function() {
  23.                 return this;
  24.             }
  25.         })
  26.  
  27.         Object.defineProperties(symbol, {
  28.             '__Description__': {
  29.                 value: descString,
  30.                 writable: false,
  31.                 enumerable: false,
  32.                 configurable: false
  33.             },
  34.             '__Name__': {
  35.                 value: generateName(descString),
  36.                 writable: false,
  37.                 enumerable: false,
  38.                 configurable: false
  39.             }
  40.         });
  41.  
  42.         return symbol;
  43.     }
  44.  
  45.     var forMap = {};
  46.  
  47.     Object.defineProperties(SymbolPolyfill, {
  48.         'for': {
  49.             value: function(description) {
  50.                 var descString = description === undefined ? undefined : String(description)
  51.                 return forMap[descString] ? forMap[descString] : forMap[descString] = SymbolPolyfill(descString);
  52.             },
  53.             writable: true,
  54.             enumerable: false,
  55.             configurable: true
  56.         },
  57.         'keyFor': {
  58.             value: function(symbol) {
  59.                 for (var key in forMap) {
  60.                     if (forMap[key] === symbol) return key;
  61.                 }
  62.             },
  63.             writable: true,
  64.             enumerable: false,
  65.             configurable: true
  66.         }
  67.     });
  68.  
  69.     root.SymbolPolyfill = SymbolPolyfill;
  70.  
  71. })()

ES6 系列

ES6 系列目录地址：https://github.com/mqyqingfeng/Blog

ES6 系列预计写二十篇左右，旨在加深 ES6 部分知识点的理解，重点讲解块级作用域、标签模板、箭头函数、Symbol、Set、Map 以及 Promise 的模拟实现、模块加载方案、异步处理等内容。

如果有错误或者不严谨的地方，请务必给予指正，十分感谢。如果喜欢或者有所启发，欢迎 star，对作者也是一种鼓励。