JS基础数据类型 — Symbol

在 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