Symbol概述

es5对象属性名都是字符串，但想要为对象混入mixin新的方法与属性时，新方法名字与现有方法产生冲突

Symbol就是在这种需求下诞生的

ES6 引入了一种新的原始数据类型Symbol，表示独一无二的值。它是 JavaScript 语言的第七种数据类型，前六种是：

undefined、
null、
Boolean
String
Number
Object

Symbol 值通过Symbol函数生成。这就是说，对象的属性名现在可以有两种类型，一种是原来就有的字符串，另一种就是新增的 Symbol 类型。凡是属性名属于 Symbol 类型，就都是独一无二的，可以保证不会与其他属性名产生冲突。

1. Symbol的创建

let s = Symbol()
typeof s // logs symbol

注意 : Symbol不能使用new创建

Symbol函数可以接受一个字符串参数，表示对Symbol实例的描述

let s1 = Symbol('foo');
console.log(s1) // logs Symbol(foo)

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

2. Symbol特性

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

s1 === new Symbol('foo')  // false 
s1 + '' // TypeError: can't convert symbol to string

symbol可以显式转为字符串

String(s1) // Symbol('foo')

symbol可以转为布尔值，但不能转为数值

let sym = Symbol();
Boolean(sym) // true
!sym  // false
Number(sym) // TypeError

3. Symbol用途

Symbol可以作为对象的属性名，能在写入时不改变原有对象的属性。

let s = new Symbol()
let a = {} 
// 1. 
a[s] = 'Hello!';
//2 . 
a = { 
  [s] : 'hello'
}

// 3 
Object.defineProperty(a,s,{value : 'hello'})

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

Symbol还可以作为常量使用

function a(type) { 
  switch(type) { 
    case "caonima" : { 
      ...
      break;
    }
  }
}

这种字符串写死在代码里，不利于维护，我们常见的一种解决方法时

const CAONIMA = 'caonima'
function a(type) { 
  switch(type) { 
    case CAONIMA : { 
      ...
      break;
    }
  }
}
a(CAONIMA)

这个时候，CAONIMA变量的值是什么就不重要了

const CAONIMA = Symbol()
function a(type) { 
  switch(type) { 
    case CAONIMA : { 
      ...
      break;
    }
  }
}
a(CAONIMA)

4. 属性名的遍历

这个要注意啊，面试可能会考

Symbol 作为属性名，遍历对象的时候，该属性不会出现在for...in、for...of循环中，也不会被Object.keys()、Object.getOwnPropertyNames()、JSON.stringify()返回。

Object.getOwnPropertySymbols()方法，可以获取指定对象的所有 Symbol 属性名。该方法返回一个数组，成员是当前对象的所有用作属性名的 Symbol 值。

const a = {} 
let sa = Symbol('a')
let sb = Symbol('b')
a[sa] = 'hello'
a[sb] = 'world'

const objectSymbols = Object.getOwnPropertySymbols(a);
objectSymbols
// [Symbol(a), Symbol(b)]

Object.hasOwnProperty可以证实是否有该符号属性在

a.hasOwnProperty(sa)    //  true

5. 创建相同的Symbol

Symbol.for()可以接受一个字符串，然后在内部搜索有没有以这个字符串相同的Symbol，有则返回，没有则创建

并注册到全局

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

s1 === s2 // true

Symbol.for与Symbol都返回一个布尔值，但是前者会进行全局注册功能

Symbol.keyFor()可以接受一个Symbol并返回它的key

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

Symbol.for()的这个全局登记特性，可以用在不同的 iframe 或 service worker 中取到同一个值。

iframe = document.createElement('iframe');
iframe.src = String(window.location);
document.body.appendChild(iframe);

iframe.contentWindow.Symbol.for('foo') === Symbol.for('foo')
// true

6. 实现模块的单例(Singleton)模式

Singleton指每次调用一个类，任何时候都返回一个实例

global.foo = new A()  // 挂载到global身上
// 但是window是可以写入的，于是这些人又想，不行，不够安全
const FOO_KEY = Symbol.for('foo');
global[FOO_KEY] = new A();
// 这样保证不会被人无意覆盖，但是还是能够改写

没用过node 实在知道怎么写这一章节

7. es6语言内部实现

ES6 还提供了 11 个内置的 Symbol 值

1. Symbol.hasInstance

在ES6里面，调用instanceof其实是调用了类的[Symbol.hasInstance]属性

class MyClass {
  [Symbol.hasInstance](foo) {
    return foo instanceof Array;
  }
}

[1, 2, 3] instanceof new MyClass() // true

这意味着我可以改写Symbol.hasInstance属性，从而改变instanceof的行为

2. Symbol.isConcatSpreadable

我们知道，concat可以接受一个数组或者其他类型的参数

当它接收的参数是数组类型时，可自动将他拆开，拼接到结果中，而不是以矩阵的形式返回

我们称这种行为叫做展开，

而Symbol.isConcatSpreadable属性可以控制这种行为

Symbol.isConcatSpreadable默认为undefined，表示可展开，true也是一样

当他为false时，就不能展开了

const a = [3,4]
console.log([1,2].concat(a))  // [1,2,3,4]
a[Symbol.isConcatSpreadable] = false 
console.log([1,2].concat(a))  // [1,2,[3,4]]

它也可以定义在原型上

3. Symbol.species

如果类里面挂载了Symbol.species这个属性，并实现了它的get取值器方法

则它创建的类的衍生实例的propt将会指向该取值器方法返回的类

什么时衍生实例?

class A extends Array {}

let a = new A(1,2,3,4)
console.log(a instanceof A) // true 
console.log(a instanceof Array) // true 
let b = a.map(item=>(item))
console.log(b instanceof A) // true 注意这里
console.log(b instanceof Array) // true

class A extends Array{
  static get [Symbol.species]() { return Array; }
}
let a = new A(1,2,3,4)
console.log(a instanceof A) // true 
console.log(a instanceof Array) // true 
let b = a.map(item=>(item))
console.log(b instanceof A) // false 注意这里
console.log(b instanceof Array) // true

而且 b实例会丢失A的原型方法，这是显而易见的

所以，Symbol.species 它的作用是当实例需要再次调用自身构造创建衍生对象时，会调用指定的Symbol.species的类

它主要的用途是，有些类库是在基类的基础上修改的，那么子类使用继承的方法时，作者可能希望返回基类的实例，而不是子类的实例

4. Symbol.match(字符串陷阱)

如果某个类含有Symbol.match属性的一个函数，当字符串.match(这个类的实例)

会反向操作

class Baba {
  [Symbol.match](string) {
    return '弟弟是你吗?'.includes(string);
  }
}
'弟弟'.match(new Baba)  // true

所以，当字符串调用

'弟弟'.match(/弟弟/)
// 实际上，是调用RegExp的Symbol.match方法，这一点可以看正则的扩展哪一张

5. Symbol.replace(字符串陷阱)

Symbol.replace同上，当字符串调用replace方法是，恰巧这个实例有这个属性

const a = {}
a[Symbol.replace] = function(str,coverStr){ 
  return "你敢搞黄色 ? " + str  + coverStr
}
'臭弟弟'.replace(a,'你别让我逮着了')  // logs "你敢搞黄色 ? 臭弟弟你别让我逮着了"

6. Symbol.search (字符串陷阱)

同上，当字符串调用search并将实例作为参数传入，会反向调用实例的Symbol.search方法

String.prototype.search(regexp)
// 等同于
regexp[Symbol.search](this)

class A { 
  constructor(value) {
    this.value = value;
  }
  [Symbol.search](string) { 
     return string.indexOf(this.value);
  }
}
'将那头颅击穿 nananana'.search(new A('nananana')) // 7

7. Symbol.split (字符串陷阱)

同上，当字符串调用split并将实例作为参数传入，会反向调用实例的Symbol.split方法

class A { 
  constructor(value) {
    this.value = value;
  }
  [Symbol.split](arg1,arg2) { 
     console.log(arg1,arg2) // 即时说了多少次未完成 nanana 10
  }
}
'即时说了多少次未完成 nanana'.split(new A('咚咚'), 10)

8. Symbol.iterator

对象的Symbol.iterator属性，指向该对象的默认遍历器方法。

使用for .... of 时会调用该方法

class Collection {
  *[Symbol.iterator]() {
    let i = 0;
    while(this[i] !== undefined) {
      yield this[i];
      ++i;
    }
  }
}

let myCollection = new Collection();
myCollection[0] = 1;
myCollection[1] = 2;

for(let value of myCollection) {
  console.log(value);
}
// 1
// 2

9. Symbol.toPrimitive

对象转为原始类型时，会调用这个方法，也就是toPrimitive，这很常见于==运算

该方法可以接收一个字符串，表示当前运算的模式，一共有三种模式

Number 该场合需要转成数值
String 该场合需要转成字符串
Default 该场合可以转成数值，也可以转成字符串

let obj = {
  [Symbol.toPrimitive](hint) {
    switch (hint) {
      case 'number':
        return 123;
      case 'string':
        return 'str';
      case 'default':
        return 'default';
      default:
        throw new Error();
     }
   }
};

2 * obj // 246
3 + obj // '3default'
obj == 'default' // true
String(obj) // 'str'

难在判断哪个情景会做出怎样的转换

10. Symbol.toStringTag

当对象尝试调用toString方法时，如果对象有这个属性，则会调用该属性方法，它可以返回[[class]]的一部分

class A { 
  get [Symbol.toStringTag](){
    return 'Nananananana';
  }
}
Object.prototype.toString.call(new A()) // "[object Nananananana]"

ES6 新增内置对象的Symbol.toStringTag属性值如下。

JSON[Symbol.toStringTag]：'JSON'
Math[Symbol.toStringTag]：'Math'
Module 对象M[Symbol.toStringTag]：'Module'
ArrayBuffer.prototype[Symbol.toStringTag]：'ArrayBuffer'
DataView.prototype[Symbol.toStringTag]：'DataView'
Map.prototype[Symbol.toStringTag]：'Map'
Promise.prototype[Symbol.toStringTag]：'Promise'
Set.prototype[Symbol.toStringTag]：'Set'
%TypedArray%.prototype[Symbol.toStringTag]：'Uint8Array'等
WeakMap.prototype[Symbol.toStringTag]：'WeakMap'
WeakSet.prototype[Symbol.toStringTag]：'WeakSet'
%MapIteratorPrototype%[Symbol.toStringTag]：'Map Iterator'
%SetIteratorPrototype%[Symbol.toStringTag]：'Set Iterator'
%StringIteratorPrototype%[Symbol.toStringTag]：'String Iterator'
Symbol.prototype[Symbol.toStringTag]：'Symbol'
Generator.prototype[Symbol.toStringTag]：'Generator'
GeneratorFunction.prototype[Symbol.toStringTag]：'GeneratorFunction'

11. Symbol.unscopables

对象的Symbol.unscopables属性，指向一个对象。该对象指定了使用with关键字时，哪些属性会被with环境排除。

别用with

本章小结

Symbol完全撒花，算是好好的过了一遍了，感觉功能非常的多，但是使用场景却很少

而且部分功能有点鸡肋

轮子哥也不会用这个吧

Symbol