es6相关总结

「本文已参与好文召集令活动，点击查看：后端、大前端双赛道投稿，2万元奖池等你挑战！」

记录知识点、每天进步一点一点点~
学习过程中将笔记跟大家分享，希望对大家也有所帮助，共同成长进步~

Map、Set

参考：www.runoob.com/w3cnote/es6…

Map
Map是一组键值对的结构，具有极快的查找速度。
举个例子，假设要根据同学的名字查找对应的成绩，如果用Array实现，需要两个Array：

var names = ['Michael', 'Bob', 'Tracy'];
var scores = [95, 75, 85];

给定一个名字，要查找对应的成绩，就先要在names中找到对应的位置，再从scores取出对应的成绩，Array越长，耗时越长。
如果用Map实现，只需要一个“名字”-“成绩”的对照表，直接根据名字查找成绩，无论这个表有多大，查找速度都不会变慢。用JavaScript写一个Map如下：

var m = new Map([['Michael', 95], ['Bob', 75], ['Tracy', 85]]);
m.get('Michael'); // 95

初始化Map需要一个二维数组，或者直接初始化一个空Map。Map具有以下方法：

var m = new Map(); // 空Map
m.set('Adam', 67); // 添加新的key-value
m.set('Bob', 59);
m.has('Adam'); // 是否存在key 'Adam': true
m.get('Adam'); // 67
m.delete('Adam'); // 删除key 'Adam'
m.get('Adam'); // undefined
由于一个key只能对应一个value，所以，多次对一个key放入value，后面的值会把前面的值冲掉：
var m = new Map();
m.set('Adam', 67);
m.set('Adam', 88);
m.get('Adam'); // 88

Set
Set和Map类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在Set中，没有重复的key。
要创建一个Set，需要提供一个Array作为输入，或者直接创建一个空Set：

var s1 = new Set(); // 空Set
var s2 = new Set([1, 2, 3]); // 含1, 2, 3

重复元素在Set中自动被过滤：

var s = new Set([1, 2, 3, 3, '3']);
s; // Set {1, 2, 3, "3"}

注意数字3和字符串'3'是不同的元素。
通过add(key)方法可以添加元素到Set中，可以重复添加，但不会有效果：

s.add(4);
s; // Set {1, 2, 3, 4}
s.add(4);
s; // 仍然是 Set {1, 2, 3, 4}

通过delete(key)方法可以删除元素：

var s = new Set([1, 2, 3]);
s; // Set {1, 2, 3}
s.delete(3);
s; // Set {1, 2}

Maps 和 Objects 的区别?

一个 Object 的键只能是字符串或者 Symbols，但一个 Map 的键可以是任意值。

Map 中的键值是有序的（FIFO 原则），而添加到对象中的键则不是。

Map 的键值对个数可以从 size 属性获取，而 Object 的键值对个数只能手动计算。

Object 都有自己的原型，原型链上的键名有可能和你自己在对象上的设置的键名产生冲突。

for in 、for of区别？

例一：

   const obj = {
        a: 1,
        b: 2,
        c: 3
    }
    for (let i in obj) {
        console.log(i) // a、 b、c 
    }
    for (let i of obj) {
        console.log(i)// Uncaught TypeError: obj is not iterable 报错了
    }

例二：

    const arr = ['a', 'b', 'c']
    // for in 循环
    for (let i in arr) {
        console.log(i)//0,1,2 返回的数据下标
    }
    // for of
    for (let i of arr) {
        console.log(i)//a,b,c
    }

例三：

    const arr = ['a', 'b']
    // 手动给 arr数组添加一个属性
    arr.name = 'qiqingfu'
    // for in 循环可以遍历出 name 这个键名
    for (let i in arr) {
        console.log(i) // 0，1，name 
    }
    for (let i of arr) {
        console.log(i)//a,b
    }

结合上面的例子,分析得出：
for...in 语句用于遍历数组或者对象的属性（对数组或者对象的属性进行循环操作）。
for in得到对对象的key或数组,字符串的下标
for of和forEach一样,是直接得到值
for of不能对象,会报错
简单说，for in是遍历键名，for of是遍历键值。

var let const的区别？

 var声明变量可以重复声明，而let不可以重复声明
 var是不受限于块级的，而let是受限于块级
 var会与window相映射（会挂一个属性），而let不与window相映射
 var可以在声明的上面访问变量，而let有暂存死区，在声明的上面访问变量会报错
 const声明之后必须赋值，否则会报错
 const定义不可变的量，改变了就会报错
 const和let一样不会与window相映射、支持块级作用域、在声明的上面访问变量会报错  

箭头函数的理解？

1、箭头函数基本形式

let func = (num) => num;
let func = () => num;
let sum = (num1,num2) => num1 + num2;
[1,2,3].map(x => x * x);

2、箭头函数基本特点

(1). 箭头函数this为父作用域的this，不是调用时的this
箭头函数的this永远指向其父作用域，任何方法都改变不了，包括call，apply，bind。
普通函数的this指向调用它的那个对象。

let person = {
    name:'jike',
    init:function(){
        //为body添加一个点击事件，看看这个点击后的this属性有什么不同
        document.body.onclick = ()=>{
            alert(this.name);//?? this在浏览器默认是调用时的对象,可变的？                  
        }
    }
}
person.init();

上例中，init是function，以person.init调用，其内部this就是person本身，而onclick回调是箭头函数， 其内部的this，就是父作用域的this，就是person，能得到name。

let person = {
    name:'jike',
    init:()=>{
        //为body添加一个点击事件，看看这个点击后的this属性有什么不同
        document.body.onclick = ()=>{
            alert(this.name);//?? this在浏览器默认是调用时的对象,可变的？                  
        }
    }
}
person.init();

上例中，init为箭头函数，其内部的this为全局window，onclick的this也就是init函数的this，也是window，得到的this.name就为undefined。

(2). 箭头函数不能作为构造函数，不能使用new

//构造函数如下：
function Person(p){
    this.name = p.name;
}
//如果用箭头函数作为构造函数，则如下
var Person = (p) => {
    this.name = p.name;
}

由于this必须是对象实例，而箭头函数是没有实例的，此处的this指向别处，不能产生person实例，自相矛盾。

(3). 箭头函数没有arguments，caller，callee

箭头函数本身没有arguments，如果箭头函数在一个function内部，它会将外部函数的arguments拿过来使用。
箭头函数中要想接收不定参数，应该使用rest参数...解决。

let B = (b)=>{
  console.log(arguments);
}
B(2,92,32,32);   // Uncaught ReferenceError: arguments is not defined

let C = (...c) => {
  console.log(c);
}
C(3,82,32,11323);  // [3, 82, 32, 11323]

(4). 箭头函数通过call和apply调用，不会改变this指向，只会传入参数

let obj2 = {
    a: 10,
    b: function(n) {
        let f = (n) => n + this.a;
        return f(n);
    },
    c: function(n) {
        let f = (n) => n + this.a;
        let m = {
            a: 20
        };
        return f.call(m,n);
    }
};
console.log(obj2.b(1));  // 11
console.log(obj2.c(1)); // 11

(5). 箭头函数没有原型属性

var a = ()=>{
  return 1;
}

function b(){
  return 2;
}

console.log(a.prototype);  // undefined
console.log(b.prototype);   // {constructor: ƒ}

(6). 箭头函数不能作为Generator函数，不能使用yield关键字

(7). 箭头函数返回对象时，要加一个小括号

var func = () => ({ foo: 1 }); //正确
var func = () => { foo: 1 };   //错误

(8). 箭头函数在ES6 class中声明的方法为实例方法，不是原型方法

//deom1
class Super{
    sayName(){
        //do some thing here
    }
}
//通过Super.prototype可以访问到sayName方法，这种形式定义的方法，都是定义在prototype上
var a = new Super()
var b = new Super()
a.sayName === b.sayName //true
//所有实例化之后的对象共享prototypy上的sayName方法

//demo2
class Super{
    sayName =()=>{
        //do some thing here
    }
}
//通过Super.prototype访问不到sayName方法，该方法没有定义在prototype上
var a = new Super()
var b = new Super()
a.sayName === b.sayName //false
//实例化之后的对象各自拥有自己的sayName方法，比demo1需要更多的内存空间

因此，在class中尽量少用箭头函数声明方法。

(9). 多重箭头函数就是一个高阶函数，相当于内嵌函数

const add = x => y => y + x;
//相当于
function add(x){
  return function(y){
    return y + x;
  };
}

(10). 箭头函数常见错误

let a = {
  foo: 1,
  bar: () => console.log(this.foo)
}

a.bar()  //undefined

bar函数中的this指向父作用域，而a对象没有作用域，因此this不是a，打印结果为undefined

function A() {
  this.foo = 1
}

A.prototype.bar = () => console.log(this.foo)

let a = new A()
a.bar()  //undefined

原型上使用箭头函数，this指向是其父作用域，并不是对象a，因此得不到预期结果

普通函数和箭头函数区别？

//箭头函数
let fun = () => {
    console.log('lalalala');
}
//普通函数
function fun() {
    console.log('lalla');
}

使用箭头函数应注意什么？

（1）用了箭头函数，this就不是指向window，而是父级（指向是可变的）
（2）不能够使用arguments对象
（3）不能用作构造函数，这就是说不能够使用new命令，否则会抛出一个错误
（4）不可以使用yield命令，因此箭头函数不能用作 Generator 函数

promise原理实现

1、最简单的实现
基于上面的应用场景发现promise可以有三种状态，分别是pedding、Fulfilled、Rejected.

pedding Promise对象实例创建时候的初始状态
Fulfilled可以理解为成功的状态
Rejected可以理解为失败的状态

2、异步操作
Promise被设计用于处理异步操作，它使得回调函数更加简洁和直观。

3、链式调用
Promise支持链式调用，通过.then()方法和.catch()方法，使得多个异步操作可以按顺序执行。

4、错误处理
通过.catch()方法，可以捕获Promise链中的错误并进行统一处理。

5、并行处理
使用Promise.all()方法可以并行处理多个Promise，等待所有Promise完成后才执行下一步操作。

6、首个完成处理
使用Promise.race()方法可以处理多个Promise，只要有一个Promise完成，就执行相应的处理。

7、Promise的所有优缺点

1 优点

• 更清晰的异步代码流程，避免回调地狱。

• 支持链式调用，使代码更加优雅。

• 提供统一的错误处理机制。

• 支持并行处理，提高异步操作的执行效率。

• 可以很好地和其他异步技术（如async/await）结合使用。

• 1、可以很好地解决回调地狱的问题（避免了层层嵌套的回调函数）。

• 2、语法简洁、可读性强，便于后期维护。

• 3、Promise 对象提供了简洁的 API，使得管理异步操作更加容易。比如多任务等待合并。

2 缺点

• 无法取消Promise，一旦创建就会执行，无法中途取消。
• 当处于Pending状态时，无法得知异步操作的进度。
• 如果不正确处理错误，可能导致未捕获的异常。
• 链式调用过长时，可能会导致代码可读性下降。

关于then()方法的理解

then()只有在Promise对象中才有。
1.then()方法是异步执行
2.意思是：就是当then()前的方法执行完成后在执行then()内部的程序，这样就避免了，数据没获取到等的问题。
3.语法：promise.then(onCompleted,onRejected);
4.参数

1.必需。(promise)  
    Promise对象  
2.必需。(onCompleted)  
    承诺成功完成时要运行的履行处理程序函数  
3.可选。(onRejected)  
    承诺被拒绝时要运行的错误处理程序函数  
    

手写promise

const p1 = new Promise((resolve, reject) => {
  console.log('create a promise');
  resolve('成功了');
})
const p2 = p1.then(data => {
  console.log(data)
  throw new Error('失败了')
})
const p3 = p2.then(data => {
  console.log('success', data)
}, err => {
  console.log('faild', err)
})

Promise.all 方法

Promise.all可以将多个Promise实例包装成一个新的Promise实例。同时，成功和失败的返回值是不同的，成功的时候返回的是一个结果数组，而失败的时候则返回最先被reject失败状态的值。 具体代码如下：

let p1 = new Promise((resolve,reject)=>{
   resolve('成功了')
})
let p2 = new Promise((resolve,reject)=>{
   resolve('success')
}) 
let p3 = Promise.reject('失败')
Promise.all([p1,p2]).then((result)=>{
   console.log(result) //['成功了','success']
}).catch((error)=>{
   console.log(error)
})
Promise.all([p1,p3,p2]).then((result)=>{
   console.log(result) 
}).catch((error)=>{
   console.log(error)  //失败了，打出'失败'
})

Promise.all在处理多个异步处理时非常有用，比如说一个页面上需要等两个或多个ajax的数据回来以后才正常显示，在此之前只显示loading图标。