ES6学习笔记

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。