在 ES6 中，Symbol是一种新的原始数据类型，表示独一无二的值。
一、特点
1、唯一性
每次调用Symbol()函数都会返回一个独一无二的值。即使使用相同的描述参数，也不会得到相同的Symbol值。
例如：
const symbol1 = Symbol('description');
const symbol2 = Symbol('description');
console.log(symbol1 === symbol2); // false
2、不可枚举性
使用Symbol创建的属性不会出现在for...in循环、Object.keys()或Object.getOwnPropertyNames()方法中，除非明确使用Object.getOwnPropertySymbols()方法或Reflect.ownKeys()方法。
例如：
const obj = {
[Symbol('property1')]: 'value1',
property2: 'value2'
};
for (const key in obj) {
console.log(key); // 只输出 property2
}
console.log(Object.keys(obj)); // ['property2']
console.log(Object.getOwnPropertySymbols(obj)); // [Symbol(property1)]
console.log(Reflect.ownKeys(obj)); // ['property2', Symbol(property1)]
二、用途
1、用作对象属性名
Symbol可以作为对象的属性名，确保属性名的唯一性，避免属性名冲突。
例如：
const obj = {};
const symbolProp = Symbol('mySymbolProp');
obj[symbolProp] = 'This is a symbol property';
console.log(obj[symbolProp]); // 'This is a symbol property'
2、定义常量
可以使用Symbol来定义常量，确保常量的唯一性，避免常量被意外修改或覆盖。
例如：
const DIRECTION_UP = Symbol('up');
const DIRECTION_DOWN = Symbol('down');
const DIRECTION_LEFT = Symbol('left');
const DIRECTION_RIGHT = Symbol('right');
3、实现私有属性
通过使用Symbol作为属性名，可以模拟私有属性，因为外部代码不能轻易访问到以Symbol为属性名的属性。
例如：
const _privateProperty = Symbol('private');
class MyClass {
constructor() {
this[_privateProperty] = 'private value';
}
getPrivateValue() {
return this[_privateProperty];
}
}
const instance = new MyClass();
console.log(instance.getPrivateValue()); // 'private value'
console.log(instance[_privateProperty]); // undefined (外部无法直接访问)
Symbol类型为 JavaScript 提供了一种更强大的方式来管理对象的属性和实现特定的编程模式。
三、内置属性
Symbol.hasInstance //当其他对象使用instanceof运算符，判断是否为该对象的实例时，会调用这个方法
Symbol.isConcatSpreadable //对象的Symbol.isConcatSpreadable属性等于的是一个布尔值，标识该对象用于Array.prototype.concat()时，是否可以展开
Symbol.species //创建衍生对象时会使用该属性
Symbol.match //当执行str.match(myObject)时，如果该属性存在，会调用他，返回该方法的返回值
Symbol.replace //当该对象被str.replace(myObject)方法调用时，会返回该方法的返回值
Symbol.search //当该对象被str.search(myObject)方法调用时，会返回该方法的返回值
Symbol.split //当该对象被str.split(myObject)方法调用时，会返回该方法的返回值
Symbol.iterator //当该对象进行for...of循环时，会调用，Symbol.iterator方法，返回该对象的默认遍历器
Symbol.toPrimitive //该对象被转为原始类型的值时，会调用这个方法，返回该对象对应的原始类型值
Symbol.toStringTag //在该对象上面调用toString方法时，返回该方法的返回值
Symbol.unscopables //该对象制定使用with关键字时，哪些属性会被with环境排除
1.Symbol.hasInstance
当该对象使用instanceof时，会调用这个方法，代码如下：
let Animal = {
[Symbol.hasInstance](foo){
return true
}
}
let obj = {};
console.log(obj instanceof Animal); // true
另外写下对于原始instaceoOf的原理：
function instanceOf(L,R){
var R_temp = R.prototype; // 获取右侧对象的原型对象
L = L.__proto__; // 获取左侧对象的原型对象
while(true){
if(L == null){// 若左侧对象的原型对象是空，则返回false
return false;
}
if(L === R_temp){ // 若二者的原型对象相等，则说明L是由R直接或间接创建的
return true;
}
L = L.__proto__; // 通过原型链不断向上原型对象
}
}
2.Symbol.isConcatSpreadable
这个属性为一个布尔值，用来表示该对象是否在Array.prototype.concat()时可以展开，干说不懂，代码如下：
let arr = [1,2,3];
let arr1 = [4,5];
console.log(arr1[Symbol.isConcatSpreadable]); // undefined
console.log(arr.concat(arr1)); // [ 1, 2, 3, 4, 5 ], 数组的Symbol.isConcatSpreadable默认为undefined,可以展开（true更可以）
arr1[Symbol.isConcatSpreadable] = false;
console.log(arr.concat(arr1)); // [ 1, 2, 3, [ 4, 5, [Symbol(Symbol.isConcatSpreadable)]: false ] ] 设置为false后不可展开
3.Symbol.match
这个属性指向一个方法，当执行str.match(obj)时，会调用这个函数并返回其返回值，代码如下：
class Person{
[Symbol.match](num){
return parseInt(num) > 100; // 自定义方法内的逻辑
}
}
console.log("123".match(new Person())); // true
console.log("12".match(new Person())); // false
4.Symbol.replace
这个属性指向一个方法，当执行str.replace(obj)时，会调用这个方法并返回其返回值，代码如下：
class Person{
[Symbol.replace](obj,rst){ // 两个参数，第一个是对象，第二个是返回的结果
console.log(rst); // wss
return "hello"; // 自定义返回值
}
}
console.log("jyy".replace(new Person(), "wss")); // hello
5.Symbol.toPrimitive
这个属性指向一个方法，当对象被转为原始类型时，会调用这个方法，代码如下：
let Person = {
[Symbol.toPrimitive](type){ // 参数为三种： string,number,default
switch(type){
case "string":
return "jyy";
case "number":
return 28;
default:
return "Beijing"
}
}
};
console.log("my name: " + String(Person)); //my name: jyy
console.log("my age: " + Number(Person)); // my age: 28
console.log("my address is: " + Person); // my address is: Beijing
