Symbol_symbol创建唯一标识符的原理是什么

概述

ES6 引入了一种新的原始数据类型 Symbol，表示独一无二的值。它是JavaScript语言的第七种数据类型，是一种类似于字符串的数据类型。
为什么要引入Symbol：ES5 的对象属性名都是字符串，这容易造成属性名的冲突。比如，你使用了一个他人提供的对象，但又想为这个对象添加新的方法，新方法的名字就有可能与现有方法产生冲突。引入Symbol 就是为了给对象的属性,提供独一无二的名字。

创建 Symbol

Symbol()

Symbol 值通过Symbol()函数生成
使用Symbol函数可以生成一个Symbol类型的值，但是你不能在调用Symbol时使用new关键字，因为Symbol是基本数据类型，而不是对象。

let s = Symbol()
let s1 = Symbol('aa') 
let s2= Symbol('aa') 
console.log(s1===s2)      //false

const a = new Symbol();  //报错，Symbol is not a constructor
1
2
3
4
5
6

symbol好比身份证号，参数是姓名,姓名可以重复，但身份证号不行

const a = Symbol();
console.log(a);  //Symbol()
const b = Symbol();
a !== b;  //a和b持有的是两块内存的引用

const c = a;  //手动把a里保存的地址保存在c变量中
a === c;  //c和a现在指向同一块内存，因为它们保存了同样的地址
1
2
3
4
5
6
7

实际上，a变量拿到了内存中某块内存的唯一引用（这里所说的引用，其实就是该内存的地址）。如果不借助a变量，你不可能再得到这个地址。
它与对象遵循相同的规则

const o = {}
const oo = {}
console.log(o === oo); // false
1
2
3

但是对于同为基本数据类型的字符串来说，它不遵循类似的规则。

var a = "123";
var b = "123";

console.log(a === b);  //返回true。两者在常量区引用同一个字符串
1
2
3
4

我们首先通过变量a在内存中创建了字符串“123”，然后在不借助变量a的情况下，又通过var b = "123"拿到了对“123”这个字符串的引用，两者指向内存中的同一块内存地址。
因此我们说，a无法确保别的变量无法拿到它保存的地址（前提是不通过a）。但是对于var a = Symbol()这样的语句，a变量内保存的值是唯一的，因为除了借助a变量，你永远无法得到a中保存的值。这也是Symbol的本质。

Symbol类型的变量只是为了标记一块唯一的内存而存在的。

Symbol.for()

Symbol提供了一种可以创建相同Symbol的机制，就是使用Symbol.for()方法进行注册。通过该方法生成的Symbol会根据描述符进行全局注册，之后再次通过Symbol.for()传入相同的描述符时，就可以得到相同的Symbol值。

//symbol当做对象使用
let s3 = Symbol.for('bb') 
let s4 = Symbol.for('bb') 
console.log(s3===s4)     //true
1
2
3
4

Symbol.for()方法它接受一个字符串作为参数，然后搜索有没有以该参数作为名称的 Symbol 值。如果有，就返回这个 Symbol 值，否则就新建一个以该字符串为名称的 Symbol 值，并将其注册到全局。
所以上面的s3 s4 是同一个值，但是使用Symbol() 创建的两个看起来一样的变量，实际上是两个不同的东西。

Symbol.for()与Symbol()这两种写法，都会生成新的 Symbol。它们的区别是，区别是你调用30个Symbol() 会得到30个不一样的值，但是Symbol.for() 会得到一个相同的值

如果你想得到一个全局注册的Symbol的描述符，可以使用Symbol.keyFor()方法：
Symbol.keyFor()方法返回一个已登记的 Symbol 类型值的key。

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

let s2 = Symbol("foo");
Symbol.keyFor(s2) // undefined
1
2
3
4
5

注意，Symbol.for()为 Symbol 值登记的名字，是全局环境的，不管有没有在全局环境运行。

作为属性名的Symbol

如果直接向对象中添加属性或方法，则原来对象中可能已经存在了同名属性或方法，会覆盖掉原来的。所以使用 Symbol 生成唯一的属性或方法名，可以更加安全的添加。

//注意，Symbol 值作为对象属性名时，不能用点运算符。
const mySymbol = Symbol();
const a = {};

a.mySymbol = 'Hello!';
console.log(a); //{ mySymbol: 'Hello!' } 添加的这个属性名mySymbol是一个字符串类型的，这个属性名不是Symbol类型的
a[mySymbol] // undefined
a['mySymbol'] // "Hello!"
//上面代码中，因为点运算符后面总是字符串，所以不会读取mySymbol作为标识名所指代的Symbol 类型值，导致a的属性名实际上是一个字符串，而不是一个 Symbol 值。
1
2
3
4
5
6
7
8
9

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

let s = Symbol('say')
let c = Symbol('close')
let youxi = {
    name: '狼人杀',
    //s 放在方括号里，表示属性的键名是Symbol类型
    [s]: function () {
        console.log('狼');
    },
    // [c]: function () {
    //     console.log('人');
    // }
    //采用增强的对象写法，代码更简洁
    [c]() {
        console.log('人');
    }
}
console.log(youxi);
/* {
    name: '狼人杀',
    [Symbol(say)]: [Function: [say]],
    [Symbol(close)]: [Function: [close]]
} */
youxi[s]() //狼
youxi[c]() //人
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

Symbol 的特点

1. Symbol的值是唯一的，用来解决命名冲突的问题

2. Symbol()函数会返回symbol类型的值

3. Symbol值不能与其他数据进行运算

4. Symbol定义的对象属性不能使用for…in循环遍历，但是可以使用Reflect.ownKeys来获取对象的所有键名

获取Symbol 类型值的描述

Symbol.prototype.description

创建 Symbol 的时候，可以添加一个描述。

const sym = Symbol('foo');
1

上面代码中，sym的描述就是字符串foo。

但是，读取这个描述需要将 Symbol 显式转为字符串，即下面的写法。

String(sym) // "Symbol(foo)"
sym.toString() // "Symbol(foo)"
1
2

上面的用法不是很方便。ES2019 提供了一个实例属性description，直接返回 Symbol 的描述。

const sym = Symbol('foo');
sym.description // "foo"
1
2

属性名的遍历

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

//属性名的遍历
const obj = {};
let a = Symbol('a');
let b = Symbol('b');

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

console.log(obj); //{ [Symbol(a)]: 'Hello', [Symbol(b)]: 'World' }
//都没有进去for...in 遍历里面
for (let i in obj) {
    console.log(i); // 无输出
}
console.log(Object.keys(obj)); //[]
console.log(Object.getOwnPropertyNames(obj)); //[]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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

//Object.getOwnPropertySymbols()方法，可以获取所有 Symbol 属性名。
const objSymbols = Object.getOwnPropertySymbols(obj);
console.log(objSymbols); //[ Symbol(a), Symbol(b) ]
1
2
3

另一个新的 API，Reflect.ownKeys()方法可以返回所有类型的键名，包括常规键名和 Symbol 键名。

console.log(Reflect.ownKeys(obj)); //[ Symbol(a), Symbol(b) ]
1

内置的 Symbol 值

除了定义自己使用的Symbol值以外，ES6还提供了11个内置的Symbol值，指向语言内部使用的方法。

• Symbol.hasInstance
  对象的Symbol.hasInstance 属性，指向一个内部方法。该对象使用 instanceof 运算符时，会调用这个方法， 判断该对象是否为某个构造函数的实例。比如，foo instanceof Foo在语言内部，实际调用的是 Foo[Symbol.hasInstance] (foo)。

• Symbol.isConcatSpreadable
  对象的Symbol.isConcatSpreadable 属性等于一个布尔值，表示该对象使用Array.prototype.concat()时，是否可以展开。

• Symbol.species
  对象的Symbol.species属性，指向一个方法。该对象作为构造函数创造实例时，会调用这个方法。即如果this.constractor[Symbol.species]存在，就会使用这个属性作为构造函数，来创造新的实例对象。

• Symbol.match
  对象的Symbol.match 属性，指向一个函数。当执行str.match(myObject)时，如果该属性存在，会调用它，返 回该方法的返回值。

• Symbol.replace
  对象的Symbol.replace 属性，指向一个方法，当该对象被String.prototype.replace方法调用时，会返回该方法的返回值。

• Symbol.search
  对象的Symbol.search属性，指向一个方法，当该对象被String.prototype.search 方法调用时，会返回该方 法的返回值。

• Symbol.split
  对象的Symbol.split 属性，指向一个方法，当该对象被String.prototype.split 方法调用时，会返回该方法 的返回值。

• Symbol.iterator
  对象的Symbol.iterator属性，指向该对象的默认遍历器方法，即该对象进行for…of循环时，会调用这个方 法，返回该对象的默认遍历器。

• Symbol.toPrimitive
  对象的Symbol.toPrimitive 属性，指向一个方法。该对象被转为原始类型的值时，会调用这个方法，返回该对 象对应的原始类型值。
  Symbol.toPrimitive 被调用时，会接受一个字符串参数，表示当前运算的模式，一共有三种模式。
  Number：该场合需要转成数值
  String：该场合需要转成字符串
  Default：该场合可以转成数值，也可以转成字符串

• Symbol.toStringTag
  对象的Symbol.toStringTag属性，指向一个方法。在该对象上面调用Object.prototype.toString方法时，如 果这个属性存在，它的返回值会出现在toString 方法返回的字符串之中，表示对象的类型。也就是说，这个属 性可以用来定制 [object Object]或 [object Array]中object后面的那个字符串。

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

总结 js 八大数据类型

JS数据类型：JS 的数据类型有几种？

 8种。Number、String、Boolean、Null、undefined、object、symbol、bigInt（es11 新增）。
1

JS数据类型：Object 中包含了哪几种类型？

  其中包含了Data、function、Array等。这三种是常规用的。
1

JS数据类型：JS的基本类型和引用类型有哪些呢？

基本类型（值类型/原始类型）：除Object。 String、Number、boolean、null、undefined。

引用类型：object。里面包含的 function、Array、Date。
1
2
3