day20

1-js 是单线程还是多线程？

　　单线程，单位时间内只能处理一个进程

2-let 和 var 声明变量的区别？

　　1、var属于ES5规范，let属于ES6规范。

　　2、var有预处理机制，let没有。 即预处理机制也就是说变量提升。

　　3、  作用域的不同，var是全局作用域，let是局部作用域。

　　注意：

　　　　1、声明变量时，一定要初始化。即var a =1；

　　　　2、 即使在内部，声明变量一定要加上var，不要直接写a =1 ；否则 变量a也会被提升为全局变量。 

　　　　　　比如说在for循环里面声明的值，就不是全局的　如：for {var a = 'xxx'}

3-说说 async/await 的使用方式和场景

const promise =new Promise(function(resolve,reject){
	setTimeout(function(){
		resolve('执行成功')
	},3000)
})

promise.then(res=>{
	console.log(res)
}).catch(err=>{
	console.log(err)
})
console.log(111)

　　等待三秒后输出 ‘执行成功’,也就是说当异步操作完成，即执行resolve或者reject之后，才会执行then中的操作

假设有这么两个方法：

function convertToBase64Data(url) { // 转成base64格式
    return new Promise( resolve => {
      setTimeout( () => {
        resolve('img');
      }, 1000);
    });
  }
  function saveToLocal(img) { // 保存到本地
    return new Promise( resolve=> {
      setTimeout( () => {
        resolve('success');
      }, 200);
    });
  }

场景1：多个异步需要按顺序：图片处理完成然后保存在本地

用promise：

function fn1() {
        return convertToBase64Data('http://1.jpg').then( base64Data => {
            return saveToLocal(base64Data);
        })
    }

使用await：

async function fn1() {
    const base64Data = await download('http://1.jpg');
    const result = await saveToLocal(base64Data); 
    return result;
  }

场景2：图片需要同时处理，但是要按顺序一张一张保存在本地

　　不使用await:

function fn2() {
       const promise1 = convertToBase64Data('http://1.jpg');
       const promise2 = convertToBase64Data('http://1.jpg');
       Promise.all([promise1,promise2]).then( datas => {
           saveToLocal(datas[0]).then( result1 => {
               saveToLocal(datas[1]).then(result2 => {
                   console.log(result2);
               })
           })
       })
    }

回调很多，很不方便，下面是使用await:

 async function fn2() {
        // 同时处理两张
        const promise1 = convertToBase64Data('http://1.jpg');
        const promise2 = convertToBase64Data('http://2.jpg');
        const [data1, data2] = await Promise.all([promise1, promise2]);
        // 先保存第一张
        const result = await saveToLocal(data1);
        // 再保存第二张
        const result2 = await saveToLocal(data2);
    }

4-谈谈对 promise 的理解

　　1、Promise是一个构造函数，可以通过 new Promise()得到一个 Promise 的实例；

　　2、在 Promise 上，有两个函数，分别叫做 resolve（成功之后的回调函数） 和 reject（失败之后的回调函数） ；

　　3、在 Promise 构造函数的 Prototype 属性上，有一个 .then() 方法，也就说，只要是 Promise 构造函数创建的实例，都可以访问到这个  .then() 方法 ；

　　4、Promise 表示一个 异步操作；每当我们 new 一个 Promise 的实例，这个实例，就表示一个具体的异步操作；

　　5.、既然 Promise 创建的实例，是一个异步操作，那么，这个 异步操作的结果，只能有两种状态：

　　　　状态1： 异步执行成功了，需要在内部调用 成功的回调函数 resolve 把结果返回给调用者；
　　　　状态2： 异步执行失败了，需要在内部调用 失败的回调函数 reject 把结果返回给调用者；
　　6、由于 Promise 的实例，是一个异步操作，所以，内部拿到 操作的结果后，无法使用 return 把操作的结果返回给调用者； 这时候，只能使用回调函数的形式，来将成功 或 失败的结果，返回给调用者；

　　7、我们可以在 new 出来的 Promise 实例上，调用 .then() 方法，【预先】为 这个 Promise 异步操作，指定成功（resolve） 和 失败（reject） 回调函数；

5-箭头函数有什么作用和实际应用场景？

　　1.箭头函数适合于无复杂逻辑或者无副作用的纯函数场景下，例如：用在 map、reduce、filter 的回调函数定义中

　　2.箭头函数的亮点是简洁，但在有多层函数嵌套的情况下，箭头函数反而影响了函数的作用范围的识别度，这种情况不建议使用箭头函数

　　3.箭头函数要实现类似纯函数的效果，必须剔除外部状态。所以箭头函数不具备普通函数里常见的 this、arguments 等，当然也就不能用 call()、apply()、bind() 去改变 this 的指向

　　4.箭头函数不适合定义对象的方法（对象字面量方法、对象原型方法、构造器方法），因为箭头函数没有自己的 this，其内部的 this 指向的是外层作用域的 this

　　5.箭头函数不适合定义结合动态上下文的回调函数（事件绑定函数），因为箭头函数在声明的时候会绑定静态上下文