技术累积Day3

ES6

let、const、var的区别

1. 块级作用域：let和const具有块级作用域，但是var不存在块级作用域。
2. 变量提升：let和const必须声明之后才能使用，但是var不需要。
3. 重复声明：let和const不能重复声明，但是va可以。
4. 初始值设置：var和let可以不设置初始值，但是const必须要。

箭头函数与普通函数的区别

1. 箭头函数是匿名函数比普通函数更加简洁，不能使用构造函数，不能使用new关键字
2. 箭头函数没有this指向，但是会获取上下文自己的this
3. 箭头函数没有arguments对象，但是普通函数有
4. call()、applay()、bind()、方法不能改变箭头函数中的this指向
5. 箭头函数没有prototype        

Set、Map的区别

Set 

set和数组类似，但是他不能有重复值

1. new Set([1,2,3.1])
2. add(value)添加某个值
3. delete(value)删除某个值
4. has(value)返回布尔值，是否存在这个set成员
5. clear()清除所有元素

Map

map是键值对，键可以是任意值

1. new Map()        
2. set(key, val)添加新元素
3. get(key)根据key查找值
4. has(key)判断Map中是否有存在的key有返回true
5. delete(key)根据key删除元素
6. clear()清除所有元素

Map和Objcet的区别

1. Map和Object都是用键值对存储集合
2. Map的键可以是任意的数据类型，Object只能是字符串或者Symbol类型
3. Map是按照顺序插入的，Object无序
4. Map可使用for of循环，但是Object不行
5. Objcet是所有对象的基类       

说说你对Promiss的理解

异步的解决方案，避免了回调地狱

promise的三个状态

• pending 初始
• fulfilled 成功
• rejected 失败

 两个过程

• pending-fulfiled：resolved 已完成
• pending-rejected：rejected 已拒绝

一旦开始进入状态就永远不能更改状态。不可逆的。

promise接受两个参数：resolve，reject参数的回调函数

• resolve对应两个过程中的pending-fulfilled状态，异步操作成功后将成功结果返回出去
• reject是pending-rejected状态，异步操作失败，将失败的结果返回出去

promise的缺点

• 一旦开始状态无法中途取消
• 需要设置回调函数，否则无法反应到外部
• 当处于pending状态时候，无法得知目前进行到哪一步  

Promise的方法

• promise.then() 对resolve成功的处理
• promise.catch() 对reject失败的处理
• promise.all() 处理多个异步请求，并且可以并行完成任务，将多个promise实例数组包装成一个新的Promise实例，但其中有一个Promise执行失败就会失败
• promise.race() 和all()类似但是有一个成功就算完成
• promise.allSettled() 会把执行的异步函数分组分成成功的和失败的，fulfilled和rejected

总结：all()和race()是和逻辑与和逻辑或类似，这样更容易理解，allSettled()有点特殊，他对成功和失败的都去做总结。

export const demo = () => {
    // Promise 公共方法 测试 Promise.all() Promise.race()  allSettled
    const publicPromise = (num) => {
        return new Promise((resolve, reject) => {
            if(num % 2 == 0) {
                resolve({
                    data: {
                        message: '数字是偶数哦~',
                        num
                    }
                })
            } else {
                reject({
                    data: {
                        message: `数字${num}不是偶数重新输入`
                    }
                })
            }
        })
    }
    publicPromise(1).then(res => {
        console.log(res)
    }).catch(error => {
        console.log(error)
    })
    Promise.all([publicPromise(2), publicPromise(3)]).then(res => {
        console.log('all', res)
    }).catch(error => {
        console.log('all', error)
    })

    Promise.race([publicPromise(2), publicPromise(3)]).then(res => {
        console.log('race', res)
    }).catch(error => {
        console.log('race', error)
    })

    Promise.allSettled([publicPromise(2), publicPromise(3)]).then(res => {
        console.log('allSettled', res)
    }).catch(error => {
        console.log('allSettled', error)
    })
}
// { data: { message: '数字1不是偶数重新输入' } }
// race { data: { message: '数字是偶数哦~', num: 2 } }
// allSettled [
//  { status: 'fulfilled', value: { data: [Object] } },
//  { status: 'rejected', reason: { data: [Object] } }
// ]
// all { data: { message: '数字3不是偶数重新输入' } }

ES6模块和CommonJs模块有什么区别

语法有变化，es6的导入导出是 import和export，commonJs驶入require和module.exports或exportys来导入导出

es6支持加载模块，提高性能 commonJs没有异步加载模块