1、箭头函数一般是针对匿名函数来使用的，形如var fun = function(a,b,c){ }的形式，写成var fun => (a,b,c){ }的样式。
2、函数体内的this对象，就是定义时所在的对象，而不是调用时所在的对象(以前的js语法this指向是调用它的对象)。
3、扩展运算符(...)，可以用于拼接数组(a.push(...b))；解构(let {a,b,c} = {a:1,b:2,c:3,d:4})。
4、模板字符串()，模板字符串会保留换行，如果需要使用变量(${变量名})来调用。
5、解构赋值:
数组解构:let arr = [a,b,c] = [1,2,3]
对象解构：
1）、let obj = {id,name} = {id:1,name:'小明'}
2）、let id=1；let name='小明'； let obj = {id,name}；即可解构对象。
嵌套解构：let user = '';
let obj = {
id:1,
prop:[3,{name:'小明'}]
};
let objClone = {prop:[,{name:user}]} = obj;
其中user便被解构赋值为小明了！
6、Promise对象
创建Promise对象
var promiseObj = new Promise(function (resolve, reject) {
setTimeout(() => {
resolve('111111');
}, 5000);
});
promiseObj.then((data) => {
console.log(data);
}).catch((error) => {
console.log(error);
});
7、async awite(异步函数)
async 函数的返回值很特殊: 不管在函数体内 return 了什么值, async 函数的实际返回值总是一个 Promise 对象.
async function foo () {
var a = await new Promise((resolve) => {
setTimeout(() => {
resolve(1);
}, 2000);
});
console.log(a);
}
foo();
Promise对象会顺序执行，如下date2会等待date1执行完毕后才会执行，
这对于date2需要使用date1的数据的情况非常有用
async function getData () {
// 假装请求数据1
var data1 = await new Promise((resolve) => {
setTimeout(() => {
resolve('data1');
}, 5000);
});
// 假装请求数据2且此请求依赖数据1
return new Promise((resolve) => {
setTimeout(() => {
resolve('data2');
}, 1000);
});
}
getData().then((v) => {
console.log(v);
});
8、calss
类的初始化方法
class Person {
constructor (x, y) {
this.x = x;
this.y = y;
}
foo () {
console.log('我是类的方法！');
console.log(this.x + this.y);
return this.x + this.y;
}
}
var man = new Person(1, 2);
man.foo();
类的继承,需要注意extends和super()关键字；
class Teacher extends Person {
constructor (x, y, job) {
super(x, y);
this.job = job;
}
teacherfoo () {
var count = super.foo();
console.log(this.job);
}
}
var te = new Teacher(2, 3, '教师');
te.teacherfoo();
原生javascript类和继承：
function Person(name,age){
this.name = name;
this.age = age;
this.jos = function(){
console.log('前端开发工程师');
}
}
function Man(name,age,body){
Person.call(this,name,age);//构造函数式继承，继承父类的name和age
this.body = body;
this.fun = function(){
console.log('男人');
}
}
Man.prototype = new Person();//类式继承，子类原型继承
Man.prototype.constructor = Man;// 修正子类构造函数的指向
9、Proxy（代理）
Proxy 可以理解成，在目标对象之前架设一层“拦截”，外界对该对象的访问，都必须先通过这层拦截，因此提供了一种机制，可以对外界的访问进行过滤和改写。Proxy 这个词的原意是代理，用在这里表示由它来“代理”某些操作，可以译为“代理器”。
let targetObj = {
_name:'小明',
_age:18,
score:90
};
let handlerFun = {
set:()=>{
},
get:(target,key)=>{
if(key.startsWith('_')){
console.log('私有变量');
return false;
}
return target[key];
},
};
let targetProxy = new Proxy(targetObj,handlerFun);
console.log(targetProxy._name);
console.log(targetProxy._age);
console.log(targetProxy.score);
上面的例子重写了对象的get方法，每次在调用对象的属性时都会经过这个函数，以上添加的是判断私有变量的代码，是私有变量就会返回false。
