es6 语法

/---字符串---/

let str="string"
str.includes("c"))     //判断字符串是否包含“c”，是返回true，否者返回false
str.startWith("str")   //判断字符串是否以“str”开头，是返回true，否者返回false
str.endWith("ng")      //判断字符串是否以“ng”结尾
str.repeat(2)          //字符串复制两次 ，返回“stringstring”
'1'.padStart(2 ,'0')   //字符串从头开始补全 长度为2 ，以 '0 '补全， 返回 “01”
‘1’.padEnd(2 ,'0')   //字符串以尾开始补全 长度为2 ，以‘0’补全，返回‘10’
String.raw`Hi
${1+2}` //阻止正则表达式进行转义


/---数字---/
Number.isInteger(25)           //判断这个是否是一个整数
Number.isSafeInteger(10)       //判断这个数是不是在一个安全范围
Number.MAX_SAFE_INTEGER  数字最大的安全范围
Number.MIN_SAFE_INTEGER  数字最小的安全范围
//数字取整
Math.trunc(4.1)//返回‘4’  Math.trunc(4.9)//返回‘4’

//判断是否是正负数
Math.sign(-5)//返回-1    Math.sign(0)//返回0    Math.sign(5)//返回1    Math.sign("-50")//返回-1    Math,sign("sdfs")//返回NaN 不是一个数字
    

/---map和array的对比---/
let map=new Map();
let array=[];        
//增
map.set('t',1)
array.push({t:1})
//查
map.has('t');
array.find(item=>item.t)
//改
map.set('t',2)
array.forEach(item=>item.t?item.t=2:"")
//删
map.delete('t')
let index=array.findIndex(item=>item.t)
array.splice(index,1)

/---set和array的对比---/
let set=new Set();
let array=[];
//增
set.add({t:1})
array.push({t:1})
//查
set.has({t:1})
array.find(item=>item.t)
//改
set.forEach(item=>item.t?item.t=2:"")
array.forEach(item=>item.t?item.t=2:"")
//删
set.forEach(item=>item.t?set.delete(item):'')
let index=array.findIndex(item=>item.t)
array.splice(index,1)

/---map,set,object对比---/
let item={t:1}
let map=new Map()
let set=new Set()
let obj={}
//增
map.set('t',1)
set.add(item)
obj['t']=1
//查
console.info(
 map.has('t')
 set,has(item)
 't' in obj
)
//改
map.set('t',2)
item.t=2
obj['t']=2
//删
map.delete('t')
set.delete(item)
delete obj['t']


/---Proxy用法---/
let obj={
  time:'2017-03-11',
  name:'net',
  _r:123
}
let monitor =new Proxy(obj,{
  //拦截对象属性的获取
  get(target,key){
     return target[key].replace('2017','2019') //把2017改成2019
  }，
  //拦截对象设置属性
  set(target，key,value）{
     if(key==='name'){
       return target[key]=value;
     }else{
       return target[key];
     }
  },
  //拦截key in object操作
  has(target,key){
    if(key==="name"){
    return target[key]
    }else{
     return false
    }
  }，
  //拦截delete
  deleteProperty(target,key){
    it(key.indexOf('_'){
    delete target[key];
    return true;
    }else{
        return target[key];
    }
  }，
  //拦截object.key，object.getOwnPropertySymbols，object.getOwnPropertyNames
  ownKeys(target){
    return Object.keys(target).filter(item=>item!='time')
  }

});
console.log(monitor.time)         //monitor属性的获取，这个返回2019-03-11
monitor.time='2018'               //monitor属性的修改，这个没有修改，被拦截了
monitor.name='finghi'             //monitor属性的修改，设置成功
 
console.log('name' in monitor ,'time' in monitor)   //返回 true false

delete monitor.time;              //monitor属性的删除，没有成功，被拦截了
delete monitor._r;                //monitor属性的删除，成功

console.log(Object.keys(monitor));//time被拦截了 返回name _r ，

/---Reflect---/
//Reflect和上面的proxy用法一样，但不需要new
{
  let obj={
    time:'2017-03-11',
    name:'net',
    _r:123
  }

console.log(Reflect.get(obj,'time'))               //返回2017-03-11
Reflect.set(obj,'name','www');                     //设置name属性
console.log(Reflect.has(obj,'name'))               //返回true
}

/---Proxy和Reflect的经典应用场景---/
function validator(targer,validator){
  return Proxy(target,{
    _val=validator,
    set(target,key,value,proxy){
      if(target.hasOwnProperty(key)){
    let va=this._val[key]
    if(!!va(value)){
      return Peflect.set(target,key,value,proxy)
    }else{
      throw Error(`不能设置${key}到${value}`)
    }
      }else{
    throw Error(`${key}不存在`)
      }
    }
  })
}


const personValidators={
  name(val){
    return typeof val==='string'
  }
  age(val){
    return typeof val==='number' && val>18
  }
  mobile(val){
    return typeof val==='number'
  }
}

class Person{
  constructor（name，age）{
     this.name=name;
     this.age=age;
     this.modile=123456789
     return validator(this,personValidators)
  }
}

const person =new Person('lilei',30)
console.info(preson);
person.name="Han mei mei"
console.info(person);