es6js学习笔记2

Symbol数据类型 
        ES5的对象属性名都是字符串类型，这容易造成属性名冲突，Symbol数据类型会
        保证值的唯一性
    数据类型：Number，String，Boolean，null，undefined，Symbol，BigInt，Object
        定义
             var s=Symbol("asd")
        主要用来让对象的属性不冲突
        第一种写法
            var obj={}
                    var sm=Symbol("schl")
                    obj[sm]="清华大学"
        第二种写法
            var sm=Symbol("schl")
                    var obj={[sm]:"清华大学"}
        第三种写法
            var obj={}
                    var sm=Symbol("schl")
                    Object.defineProperty(obj,sm,{value:"黑龙江大学"})
        属性和方法
            for() 如果有Symbol值，则返回，没有则新建
            keyfor() 返回Symbol的for函数的值
            replace()替换Symbol的值
            match()查找Symbol的值
            split()分割Symbol的值
            toString()转化成字符串
    面向对象
        定义对象用class声明，让js更接近于后台语言的写法，但是class是声明的语法糖，
        而对象本身和ES5的对象没有区别
        class Person{
                        constructor(name,age){  //构造器
                            this.name=name  //this调用属性和方法
                            this.age=age
                        }
                        say(){  //方法简写
                            console.log(this.name+","+this.age)
                        }
                }
                var p=new Person("liu",21)
        注意：class的定义默认使用了严格模式，所以无需自己在手动添加
        class声明的对象没有变量提升
           var p=new Person("liu",21)
           console.log(p)  //报错
           class Person{ }
        对象私有属性
           不用this关键字引用，建议“#”声明
        class Piont{
                        #x=2;  //私有变量
                        constructor(y){
                            this.y=y
                        }
                }
        对象私有方法
           不用this关键字引用，建议“_”声明
        class Piont{
                        say(){ console.log(this.y) }  //公有
                        _fun(){ console.log("111") }  //私有
                }
        静态属性和静态方法
        用static修饰静态，当被定义成静态属性和方法时，不能被实例继承，
        并且可以直接通过类调用该属性和方法
        静态属性
        class Emp{
                        name="lisi"  //方法1
                        static age=23  //方法2
                        constructor(x){ this.x=x }
                }
        console.log(Emp.age)  //没有new对象之前就可以调用
        静态方法
        class Emp{
                        static fun1(){ console.log("静态方法") }
                        fun2(){ console.log("普通方法") }
                }
        Emp.fun1()  //没有new对象之前就可以调用
    继承
        通过class声明的对象，用extends关键字进行继承
           class Father{
                           sing(){ console.log("唱京剧") }
                   }
                   class Son extends Father{ }
                   var s=new Son()
                   s.sing()
        super关键字调用父类构造器
           class Father{
                        constructor(name){ this.name=name }
                   }
                   class Son extends Father{
                        constructor(name,age){
                        super(name)  //必须先调用父类
                        this.age=age
                        }
                   }
                   var s=new Son("学生",23)
        注意：当super作为函数时，只能在构造器里调用
        super作为关键字来用，当做对象使用
           class Father{  }
           Father.prototype.sex="男"
           class Son extends Father{
                        sing(){
                            // super() 不能在其他函数调用父类构造器
                            return super.sex //只能调用原型上的，非构造器里的
                        }
                   }
           var s=new Son("学生",23)
                   var v=s.sing()  //输出父类的性别
    Proxy 拦截器
        用于修改某些操作的默认行为，称为对象的一个拦截器，访问对象时
        必须先通过这个拦截层，在拦截层里做限定和修改
        定义方式
            var p=new Proxy({},{
                            get:function(){ return "无权访问" }
                    })
            console.log(p.name)
        get下的参数值 （目标对象，当前访问的属性）
            var p = new Proxy(obj, {
                            get: function (tag, prop) {
                                if (prop == "age") {
                                        return "无权访问"
                                }
                                else{
                                        return tag[prop]
                                }
                            }
                    })
        属性和方法
             get（对象，属性）在获取时拦截
             set（对象，属性）在修改时拦截
             has（对象，属性）在判断属性时拦截
             deleteProperty在通过delete关键字删除时拦截
             ownkey（对象）在调用getOwnPropertyNames()方法时拦截
             defineProperty(对象，属性)在调用defineProperty方法时拦截
             apply(属性，对象，数组)在调用apply时拦截
             setPrototypeOf(对象，原型)调用setPrototypeOf时拦截
             getPrototypeOf(对象，原型)调用getPrototypeOf时拦截
    set和map的数据结构
        Set
           set集合类似数组，可以存储多个值，但是值必须唯一
           定义
            var s=new Set()
            var s=new Set([1,2,3,4])
           查询
            [...s]
           属性和方法
            add()添加值
            delete()删除值
            clear()清空
            has()判断某个值是否存在
            size()获得个数
            forEach()遍历集合
            keys()遍历所有key值
            values()遍历所有value值
            entries()遍历所有键值对
        Weakset
           Weakset和set一样，不能重复定义，但是区别在于，只能存储对象不能存储其他类型；
           垃圾回收机制不考虑Weakset对对象的引用，自动回收对象所占的内存，不管他是否
           在Weakset里定义了
           属性和方法都与Set集合一样，没有size函数
            var wx=new WeakSet()  //定义集合
                    // wx.add(1) 报错，不能添加非对象值
                    var obj={name:"lisi"}
            wx.add(obj)
        Map
           map的定义类似于对象，用键值对key->value存储，对象的属性名只能是字符串
           和symbol，而集合的key值可以是任何类型
           定义
            var m=new Map()
            var m=new Map([["name","lisi"],["age",23]])
           属性和方法
            set(key,value)新增或修改一个值 //存过就是修改，未存过就新增
            get(key)查询value值
            delete(key)删除值
            has(key)判断key是否存在
            clear()清空数据
            size获取个数
            keys()遍历所有key值
            values()遍历所有value值
            entries()遍历所有键值对
        Weakmap
           类似于map结构，用键值对存储，但是要求key值必须是对象类型，并且Weakmap
           指向的对象不计垃圾回收机制
            var vm=new WeakMap()
                    var obj={a:2}
                    vm.set(obj,"aa")