引言

ES5 的对象属性名都是字符串，易造成属性名冲突。比如，你使用了一个他人提供的对象，但又想为这个对象添加新的方法（mixin 模式），新方法的名字就有可能与现有方法产生冲突。 ES6 引入Symbol就可以解决这个问题。

一、Symbole初始化

无参数初始化

它是一种 类似于字符串 的数据类型，Symbol函数前不能使用new命令，否则会报错。

let s = Symbol();

typeof s
// "symbol"

凡是属性名属于 Symbol 类型，就都是 独一无二 的，可以保证不会与其他属性名产生冲突。

接受字符串作参数

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

let s1 = Symbol('foo');
let s2 = Symbol('bar');

s1 // Symbol(foo)
s2 // Symbol(bar)

s1.toString() // "Symbol(foo)"
s2.toString() // "Symbol(bar)"

注意：

1.若参数的值是对象，会调用对象的toString方法

const obj = {
  toString() {
    return 'abc';
  }
};
const sym = Symbol(obj);
sym // Symbol(abc)

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

// 没有参数的情况
let s1 = Symbol();
let s2 = Symbol();

s1 === s2 // false

// 有参数的情况
let s1 = Symbol('foo');
let s2 = Symbol('foo');

s1 === s2 // false

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

let sym = Symbol('My symbol');

"your symbol is " + sym
// TypeError: can't convert symbol to string

`your symbol is ${sym}`
// TypeError: can't convert symbol to string

4.Symbol可以显示转化为字符串和布尔类型，但是不可转化为Number类型。

let sym = Symbol('My symbol');

String(sym) // 'Symbol(My symbol)'
sym.toString() // 'Symbol(My symbol)'

Boolean(sym)  // true

Number(sym) // TypeError

二、Symbol作为属性名

常见的三种属性声明方式：

let mySymbol = Symbol();

// 第一种写法
let a = {};
a[mySymbol] = 'Hello!';

// 第二种写法（最常见）
let a = {
  [mySymbol]: 'Hello!'
};

// 第三种写法
let a = {};
Object.defineProperty(a, mySymbol, { value: 'Hello!' });

// 以上写法都得到同样结果
a[mySymbol] // "Hello!"

作为对象属性名时，不能用点运算符。

同理，在对象的内部，使用 Symbol 值定义属性时，Symbol 值必须放在方括号之中。

const mySymbol = Symbol();
const a = {};

a.mySymbol = 'Hello!';  //点运算符后面总是字符串

a[mySymbol] // undefined
a['mySymbol'] // "Hello!"

const b = {
    [mySymbol](arg){
        //...
    }
}

Symbol 类型用于定义一组常量，保证这组常量的值都是不相等的。

示例：

const log = {};

log.levels = {
  DEBUG: Symbol('debug'),
  INFO: Symbol('info'),
  WARN: Symbol('warn')
};
console.log(log.levels.DEBUG, 'debug message');
console.log(log.levels.INFO, 'info message');

特别注意

该属性不会出现在for...in、for...of循环中，也不会被

Object.keys()、
Object.getOwnPropertyNames()、
JSON.stringify()
而且还 不是私有属性。

Symbol属性访问方法：

1.ES6提供了Object.getOwnPropertySymbols方法来获取，得到的是一个数组。

const obj = {};
let a = Symbol('a');
let b = Symbol('b');

obj[a] = 'Hello';
obj[b] = 'World';

const objectSymbols = Object.getOwnPropertySymbols(obj);

objectSymbols
// [Symbol(a), Symbol(b)]

2.Reflect.ownKeys方法可以返回所有类型的键名，包括常规键名和 Symbol 键名。

let obj = {
  [Symbol('my_key')]: 1,
  enum: 2,
  nonEnum: 3
};

Reflect.ownKeys(obj)
//  ["enum", "nonEnum", Symbol(my_key)]

以 Symbol 值作为名称的属性，不会被常规方法遍历得到。我们可以利用这个特性，为对象定义一些非私有的、但又希望只用于内部的方法。

let size = Symbol('size');

class Collection {
  constructor() {
    this[size] = 0;
  }

  add(item) {
    this[this[size]] = item;
    this[size]++;
  }

  static sizeOf(instance) {
    return instance[size];
  }
}

let x = new Collection();
Collection.sizeOf(x) // 0

x.add('foo');  //增加了属性 0: 'foo'，并将内部Symbol属性值增加了1
Collection.sizeOf(x) // 1

Object.keys(x) // ['0']  只能便利到增加了的属性0
Object.getOwnPropertyNames(x) // ['0']
Object.getOwnPropertySymbols(x) // [Symbol(size)]

三、Symbol消除魔术字符串

魔术字符串 指的是，在代码中多次出现、与代码形成强耦合的某一个具体的字符串或者数值。

function getArea(shape, options) {
  let area = 0;

  switch (shape) {
    case 'Triangle': // 魔术字符串
      area = .5 * options.width * options.height;
      break;
    /* ... more code ... */
  }

  return area;
}

getArea('Triangle', { width: 100, height: 100 }); // 魔术字符串'Triangle'

常用的消除魔术字符串的方法，就是把'Triangle'写成一个变量。

const shapeType = {
    triangle: 'Triangle'
}
function getArea(shape, options) {
  let area = 0;

  switch (shape) {
    case shapeType.triangle: // 魔术字符串
      area = .5 * options.width * options.height;
      break;
    /* ... more code ... */
  }

  return area;
}

getArea(shapeType.triangle, { width: 100, height: 100 }); // 魔术字符串'Triangle'

这样就消除了代码的强耦合性。分析发现shapeType.triangle的值是什么无关紧要，只要保证不与shapeType其他属性值冲突就好。

const shapeType = {
    triangle: Symbol()
}

四、Symbol.for()

使用同一个 Symbol 值，Symbol.for方法可以做到这一点。

let s1 = Symbol.for('foo');
let s2 = Symbol.for('foo');

s1 === s2 // true

Symbol.for()不会每次调用就返回一个新的 Symbol 类型的值，而是会先检查给定的key是否已经存在，如果不存在才会新建一个值。

Symbol.for("bar") === Symbol.for("bar")
// true

Symbol("bar") === Symbol("bar")
// false 由于Symbol()写法没有登记机制

检查某个属性是否已经登记，Symbol.keyFor()方法返回已登记的 Symbol 类型值的参数值。

let s1 = Symbol.for("foo");
Symbol.keyFor(s1) // "foo"

let s2 = Symbol("foo");
Symbol.keyFor(s2) // undefined