es6冲刺02

1、Symbol

es6新增的数据类型

1）概念

提供一个独一无二的值

let a=Symbol()

let b=Symbol()

或

let c=Symbol.for(‘c‘)

let d=Symbol.for(‘c‘)

c是一个key，标识着这个独一无二的变量

2、数据结构

1)set

Set中的元素不可重复

其长度用.size表征

添加重复元素（严格相等）后不会报错，但不生效，

用来去重很方便

{

let list=new Set()

list.add(1)//用add来添加元素

list.add(2)

}

{

let arr=[1,2,3,4,5]

let list=new Set(arr)

}

方法有

.add(obj)//添加

.delete(obj)//删除某一指定元素

.has(obj)//判断有无某一指定元素

.clear()//清空set

WeakSet主要的区别是

支持的数据类型只能是对象，弱引用，没有size属性，没有clear

方法，

2）Map

Map的键可以是任意类型，不一定是字符串

.size表征长度

 {

let map=new Map()

let arr=[‘123‘]

map.set(arr,123)//键，值新增元素

map.get(‘‘键)//获取元素

}

{

let map=new Map([key1,val1],[[key2,val2],...)

//另一种定义方式

}

方法：

.delete(key) 删除

.clear() 清空

WeakMap()所接受键必须是对象，不可遍历，即和weakset的特性一致

3）与数组的对比

数组修改比较难，要先遍历。而Map

只需map.set即可

数组做删除较难，需要先知道索引，现在我们只需要

map.delete即可

4）与对象的对比

Obj/set/map增加都很简单

3、Reflect/Proxy

1）Proxy

Proxy实例成为某一对象的代理，它将拦截对该对象的部分

或所有操作

monitor成为对象的代理

2)Reflect是一个映射

{

let obj={

name:‘cc‘,

age:25

}

Reflect.get(obj,‘name‘)//静态方法，获取属性

Reflect.set(obj,‘name‘,‘ee‘)//设置属性

}

Proxy和Refelct常用于数据校验

            {
    
            function
             validate(target, validator) {
        
            return
            new
             Proxy(target, {
            _validator: validator,
            set(target, key, value, proxy) {
                
            if
             (target.hasOwnProperty[key]) {
                    let va = this._validator[key]
                    if (va(value)) {
                        return Reflect.set(target, key, value, proxy)
                    } else {
                        throw Error(`${key} failed`)
                    }
                }
            }
        })
    }
    const validator={
        name(val){
            returntypeof val === string
        },
        age(val){
            returntypeof val <= 18
        }
    }
    
    Class Person{
        constructor(name,age){
            this.name=name
            this.age=age
            return validator(this,validator)
        }
    }
}

4、类与对象

1)

class ClassName{

　　constructor(prop1,...){

}

}

2）继承：

{

class A{}

class B extends A{

}

}

{

class A{

constructor(name=‘cc‘){

this.name=name

}

}

class B extends A{

constructor(name,age){

super(name)

this.age=age//子类特有属性应该在继承属性之后

}

}

}

3）getter/setter、

            class Parent{
    constructor(name=‘cc‘){
        this.name=name
    }

    get newName(){
        return ‘lisa‘+this.name
    }

    set newName(value){
        this.name=value
    }

    //get和set都是属性，不要当成方法}

let mom=new Parent()
mom.newName=‘linda‘
console.log(mom.newName)

4）静态方法/属性

用类直接调用

定义：

class Parent{

static put(){

console.log(‘put‘)

}

}

Parent.type=‘静态‘//定义静态属性

5、Promise

1)解决异步操作问题

在es5中，我们常用回调函数解决异步问题,我们用定时器模拟了异步操作问题

let ajax = () => {
    console.log("this is an ajax")
    returnnew Promise((resolve, rejrect) => {
        setTimeout(() => {
            resolve()
        }, 1000)
    })
}
ajax().then(()=>{
    console.log("this is first resolve function")
    returnnew Promise((resolve,reject)=>{
        setTimeout(()=>{
            resolve()
        },1000)
    })
}).then(()=>{
    console.log(‘this is second resolve function‘)
})

原文：https://www.cnblogs.com/Tanqurey/p/10590349.html