在 ES5 中基础数据类型有 5 种：Boolean、Null、Undefined、Number、String，ES6 新增了基础数据类型 Symbol 符号、代号的意思，它是独一无二的，也就是说使用它声明的变量是独一无二的。引入这个数据类型有什么作用呢？

我们知道在 ES5 中， 对象的名都是字符串，容易造成名冲突。比如，你使用了他人提供的对象，但又想为这个对象新的（mixin 模式），新的名字就有可能与现有产生冲突，ES6 引入 Symbol 就可以这个问题。不仅如此 Symbol 的使用还有很多，在元编程中也发挥很大的作用。下面我们就来看看 Symbol 的 使用。

使用 Symbol() 会返回独一无二的变量，可以作为对象的 key 存在，返回的值是 symbol 类型，该类型具有静态和静态。

Symbol([description])

Symbol() 是，返回的值是 symbol 类型，使用如下：

var s1 = Symbol();
var s2 = Symbol();
console.log(s1 === s2)  // false
console.log(typeof s1)	// symbol

上面的中，使用 Symbol 声明的变量 s1 和 s2，虽然它们看上去是同 Symbol 定义的，但其实是不相等的。

在 Symbol 中可以传入一些参数，来描述定义的 Symbol 类型的值。

var s1 = Symbol('imooc');
var s2 = Symbol('imooc');
console.log(s1)         // Symbol(imooc)
console.log(s1 === s2)  // false

let s = Symbol({name: 'imooc'});
console.log(s);         // Symbol([object Object])

上面的中，Symbol 接收的参数是对 Symbol 的描述，即使两个 Symbol 接收相同值，两个值也是不一样的。另外，如果传入的描述符是对象类型，内部会将描述的进行 toString 操作，所以返回的结果是 [object Object]。

Symbol 经常会作为对象的存在，如果这个是用 symbol 来声明的，则不可枚举，也不能用 for...in、for...of 迭代。

对象上的 key，可以用取值表达式 (中括号) 的方式取出来，作为对象上的，如下：

var s = Symbol('imooc');
var obj = {
  [s]: 
}
obj     // {Symbol(imooc): 1}
obj[s]  // 1

上面的，使用 Symbol 声明了变量，然后作为对象的 key 给它赋值。取值的时候只能使用中括号的方式，因为这里的 s 是变量不能使用点的方式。下面是对 obj 对象用 for...in 进行的遍历。

for(let key in obj) {
  console.log(obj[key])
}
// undefined

上面的对 obj 对象进行迭代，但是没有打印出对应的值，说明用 Symbol 来声明的是不可枚举的。如果想要到这个可以使用 Object.getOwnPropertySymbols(obj) 。使用 Object.keys()、Object.getOwnPropertyNames()、JSON.stringify() 也是不能返回想要的结果。

Object.getOwnPropertySymbols(obj);   // [Symbol(imooc)]
Object.keys(obj);                    // []
Object.getOwnPropertyNames(obj);     // []
JSON.stringify(obj);                 // "{}"

从上面的中可以看到使用 Object.getOwnPropertySymbols() 可以对象上所有 Symbol 类型的，并返回数组。

另外，可以通过 description Symbol 类型描述。

var s = Symbol('imooc');
s.description;    // "imooc"

Symbol.for(key) 也是声明变量使用，不同的是 Symbol.for(key) 是在全局作用域下声明的。它会根据给定的键 key 从运行时的 symbol 表中找到对应的 symbol。如果找到了，则返回它。否则，新建与该键关联的 symbol，并放入全局的 symbol 表中，如果有已经声明了的 symbol 则不回重复声明。

let s1 = Symbol.for('imooc');  
let s2 = Symbol.for('imooc');
function fn() {
  return Symbol.for('imooc');
}
console.log(s1, s2)       // Symbol(imooc) Symbol(imooc)
console.log(s1 === s2)    // true
console.log(fn() === s1)    // true

上面的中可以看出来，使用 Symbol.for(key) 无论在哪里进行声明，都不会影响它们的值。

Symbol.keyFor() 通过 key 值 symbol 的描述:

let s1 = Symbol.for('imooc');  
console.log(Symbol.keyFor(s1))  // imooc

在现实中姓名重复是很常见的，但是在 JavaScript 对象中，名是唯一的存在。如果定义对象中有重复的则会被覆盖，这个现象叫做 “引用消除”。我们看下面的例子：

var person = {
  Tom: {sex: '男', age: },
  David: {sex: '男', age: },
  David: {sex: '女', age: },
}
console.log(person); // {Tom: {sex: "男", age: 18}, David: {sex: "女", age: 16}}

可以看到我们定义了 person 对象，第 David 对象被后 David 引用消除了，所以只有第二个 David 的数据。如果要这个问题可以使用 Symbol 来实现

var person = {
  Tom: {sex: '男', age: },
  [Symbol('David')]: {sex: '男', age: },
  [Symbol('David')]: {sex: '女', age: },
}
console.log(person) 
// {Tom: {sex: "男", age: 18}, Symbol(David): {sex: "男", age: 17}, Symbol(David): {sex: "女", age: 16}}

这样就可以名冲突的问题，需要注意的是使用这样的方式定义对象数据存在问题，就是使用 for...in 或者使用 Object.keys() 遍历时 Symbol 的数据不会被遍历到，上文有具体说明。所以，如果想要遍历到对象的值可以通过 Reflect.ownKeys() 去对象的 key，然后进行。

for (let key of Reflect.ownKeys(person)) {
	console.log(person[key])
}
// {sex: "男", age: 18}
// {sex: "男", age: 17}
// {sex: "女", age: 16}

魔术字符串 指的是在中多次出现与形成强耦合的某具体的字符串或者数值，看下面的例子：

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

  switch (shape) {
   	case 'Circle':
      area =  * Math.pow(options.radius, )
      break;
    case 'Square':
      area = options.width * options.height;
      break;
  }
  return area;
}

getArea('Circle', { radius:  });		// 314
getArea('Square', { width: , height:  });	 // 100

上面的中 ‘Circle’ 和 ‘Triangle’ 就属于魔术字符串，常见的消除魔术字符串的就是使用变量替代，如下：

const shapeType = {
  circle: 'Circle',
  triangle: 'Square'
}
function getArea(shape, options) {
  let area = ;

  switch (shape) {
   	case shapeType.circle:
      area =  * Math.pow(options.radius, )
      break;
    case shapeType.square:
      area = options.width * options.height;
      break;
  }
  return area;
}

getArea(shapeType.circle, { radius:  });		// 314
getArea(shapeType.square, { width: , height:  });	 // 100

上面的中就消除了的强耦合，其实我们不关注 shapeType 的值，只要他们不同即可，有了 Symbol 这时我们就可以使用 Symbol 进行描述，如下更改：

const shapeType = {
  circle: Symbol('Circle'),
  triangle: Symbol('Square')
}

本节学习了 ES6 新增数据类型 Symbol，使用它可以声明独一无二的变量，通常会作为对象的存在，名冲突的问题。注意这个是不能被迭代的，如果想要迭代它可以使用 Reflect.ownKeys() 的方式去 key 值。最后介绍了 Symbol 在实战中的应用。