ES6的Class类和Symbol符号

class类

ES6的class可以看作只是一个语法糖，新的class写法只是让对象原型的写法更加清晰、更像面向对象编程的语法

class 函数名{
constructor(){
// 构造器
}//必须要写，就算不写也会默认添加
}

class类的使用注意点

1. 可以写成计算属性名

const person="text"
class Person{
    [person+"1"](){
        console.log("大哥大姐过年好")
    }
}
const a=new Person();
console.log(a.text1())

2. 可以使用getter和setter方法 取值必走get方法，赋值必走set方法

    const printName = "print";
        const test = "job";
        class Person{
            constructor(job,name,age,sex){
                this[test] = job;
                this.name = name;
                this.age = age;
                this.sex = sex;
            }
            [printName](){
                console.log(`工作：${this.job}姓名：${this.name}年龄：${this.age}性别：${this.sex}`)
            }
            get age(){
                console.log("取值的时候走进来")
                return this._age;
            }
            set age(val){
                // console.log(val)
                // console.log("赋值的时候走进来")
                if(typeof val !== "number"){
                    throw new TypeError("age nust a number")
                }
                if(val < 0 ){
                    val = 0
                }else if(val > 200){
                    val = 200;
                }
                this._age = val;
            }
        }
        const a = new Person("程序猿","张三",12,"男")
        console.log(a)
        a[printName]()
        a.age = 1000;

4. 静态成员：属于当前自己所有，不能够被实例出来与其他人共享

普通数据成员属于类的一个对象，只有对象被创建了，普通数据成员才会被分配内存而静态成员属于整个类，即使没有实例对象创建，类的静态数据也存在。

class Car{
    constructor(name){
        this.name=name;
    
    }
    static money=100000;
    static width=1000;
}
const car=new Car("宝马");
console.log(car)
自身自带的价格属性和宽度属性

6. 字段初始器(ES7)：简写constructor

 class Test{
  字段初始器 ：做构造器的初始化工作，如果没有使用static,就是实例成员
            a = 1;
            b = 2;
            static c = 3;
                // print(){
                //     // 原型
                //     console.log(this.a)
                // }
                print = ()=>{
                    // 实例
                    console.log(this.a)
                }
        }
        const t = new Test()
        console.log(t)
       箭头函数在字段初始器的中this指向当前对象

对象的继承

extends 继承
super
1.当成函数用，表示父类的构造器
2.当成对象使用，表示父类的原型

  class Amimal{
            constructor(type,name,age,sex){
                this.type = type;
                this.name = name;
                this.age = age;
                this.sex = sex;
            }
            print(){
                console.log(`种类：${this.type}`)
                console.log(`名字：${this.name}`)
                console.log(`性别：${this.sex}`)
                console.log(`年龄：${this.age}`)
            }
        }
        
        class Dog extends Amimal{
            constructor(name,age,sex){
            //当函数用的时候是父类的构造器 默认是犬类 传三个参数即可
                super("犬类",name,age,sex)
            }
            print(){
                console.log(`汪`)
            //当对象用的时候，表示的是父亲的原型 
                super.print()
            }
        }
         const d = new Dog("旺财",5,"公")
        console.log(d)
        d.print()

Symbol 符号

Symbol创建的原因是，希望有一种机制，保证每一个属性的名字都是独一无二的，防止属性名冲突

创建符号

可以接受一个字符串作为参数，表示对Symbol实例的描述，主要是为了在控制台现实或者转换为字符串时比较容易区分

const syb1 = Symbol(“符号描述”)
生成symbol是一个原始类型的值，不是对象，所以不需要new关键字调用，并且Symbol函数没有构造器

  let syb1 = Symbol("abc")
  let syb2 = Symbol("abc")
  let syb3 = Symbol()
  console.log(syb1,syb2,syb3)//Symbol(abc) Symbol(abc) Symbol()
  console.log(syb1 == syb2)//false
  console.log(typeof syb1)//symbol

由于以Symbol值作为对象的键名，不会被常规的方法所遍历。利用这个特性我们可以给对象定义一些非私有，但是只在内部使用的方法，通过设计来增加只能在内部访问的方法（for…in遍历、Object.keys()、Object.getOwnPropertyNames()…）

共享符号

Symbol.for() 当符号描述相同，则可以得到同一个符号

        const syb1 = Symbol.for("abc")
        const syb2 = Symbol.for("abc")
        console.log(syb1,syb2)//Symbol(abc) Symbol(abc)
        console.log(syb1 === syb2)//true

知名符号

Symbol.hasInstance

对象的Symbol.hasInstance属性，指向一个内部方法。当其他对象使用instanceOf运算符时，判断是否为该对象的实例时，会调用这个方法。

 function A(){}
 const a=new A();
//defineProperty的作用就是直接在一个对象上定义一个新属性，或者修改一个已经存在的属性
Object.defineProperty(A,Symbol.hasInstance,{
     value:function(obj){
       console.log(obj)
        return false
 })
 //false 不加这个为ture

Symbol.isConcatSpreadable决定是否展开数组

//Symbol.isConcatSpreadable  true为展开 flase为不展开
let arr=[3]
let arr2=[1,2,3]
arr[Symbol.isConcatSpreadable]=false;
const result=arr.concat(arr2)
console.log(result)

Symbol.toPrimitive指向一个内部方法,该对象被转换成原始类型的值时，会调用该方法

//Symbol.toPrimitive
const obj={name:1,age:2}
obj[Symbol.toPrimitive]=function(){
    return 100
}
console.log(obj+111)//2111

Symbol.toStringTag指向一个内部方法。在该对象上调用Object.prototype,toString方法时，如果这个属性存在，它的返回值会出现在toString的返回值中，表示对象的类型

  class Person{
            [Symbol.toStringTag] = "qwe"
        }
        const p = new Person()
        console.log(p)
        const arr = [12,1,3]
        console.log(Object.prototype.toString.call(p))//[object Object]  [object qwe]