回调函数callback及promise

同步与异步

javascript语言是一门“单线程”的语言，javascript就像一条流水线，仅仅是一条流水线而已，要么加工，要么包装，不能同时进行多个任务和流程,无论如何，js做事情的时候都是只有一条流水线（单线程），同步和异步的差别就在于这条流水线上各个流程的执行顺序不同。
同步任务：在主线程上排队执行的任务，只有前一个任务执行完毕，才能执行后一个任务；
异步任务：不进入主线程、而进入"任务队列"的任务，只有等主线程任务执行完毕，"任务队列"开始通知主线程，请求执行任务，该任务才会进入主线程执行。

回调函数

—函数当参数，传递另外一个函数
在JavaScript中，回调函数具体的定义为：函数A作为参数(函数引用)传递到另一个函数B中,并且这个函数B执行函数A。我们就说函数A叫做回调函数。如果没有名称(函数表达式)，就叫做匿名回调函数。
但是回调函数有一个弊端，多层嵌套可读性很差，这个称之为 “回调地狱”

—回调函数简单应用—
–回调函数将函数内部的值带出来

function fn(callback){
            $ajax({
                url:'数据接口地址',
                success:function(data){
                    let arrdata = JSON.parse(data);
                    callback(arrdata);
                }
            });
        }
        fn(function(d){
            console.log(d);
        });

–数组的一些方法：如every/some/filter/map/forEach

let arr = [1, 2, 3, 4];
        let arr2 = arr.filter((v) => {
            return v % 2;
        });
        console.log(arr2);

–定时器内部的函数
–事件处理回调函数

ES6新增—promise

Promise 异步编程的一种解决方案，比传统的解决方案——回调函数和事件——更合理和更强大。
Promise对象有以下两个特点：
（1）对象的状态不受外界影响。Promise对象代表一个异步操作，有三种状态：pending（进行中）、fulfilled（resolve已成功）和rejected（已失败）。
（2）一旦状态设定，就不会再变，任何时候都可以得到这个结果。Promise对象的状态改变，只有两种可能：从pending变为fulfilled和从pending变为rejected。只要这两种情况发生，状态就凝固了；
promise状态：pending(进行中) resolve(成功，已解决) reject(失败，未解决)
pending–>resolve 进行中–>成功
pending–>reject 进行中–>失败

resolve, reject这里两个形参是两个函数， 用来设定状态。
resolve(‘设置状态里面的参数’); //成功–>找实例对象下面的then方法 ，括号里面的参数传给then里面函数。
reject(); //失败–>找实例对象下面的catch方法，括号里面的参数传给catch里面函数。
});

   let promise = new Promise((resolve, reject) => { 
   resolve('设置状态里面的参数');
   reject();
  }
    //写法1
    promise.then((info) => {
        console.log('成功的回调');
        console.log(info);
    }).catch(() => {
        console.log('失败的回调');
    });

    //写法2
    promise.then(() => { //成功的回调
        console.log('成功的回调');
    }, () => { //失败的回调
        console.log('失败的回调');
    })

    //写法3
    promise
        .then(() => {
            console.log('成功的回调1');
        })
        .then(() => {
            console.log('成功的回调2');
        })
        .catch(() => {
            console.log('失败的回调');
        });

promise原型下面两个常用的方法：
Promise.prototype.then / Promise.prototype.catch
resolve函数的作用是， 将Promise对象的状态从“ 未完成” 变为“ 成功”（ 即从 pending 变为 resolved）， 在异步操作成功时调用， 并将异步操作的结果， 作为参数传递出去；
reject函数的作用是， 将Promise对象的状态从“ 未完成” 变为“ 失败”（ 即从 pending 变为 rejected）， 在异步操作失败时调用， 并将异步操作报出的错误， 作为参数传递出去。
此外还有Promise.prototype.finally，
finally方法用于指定不管 Promise 对象最后状态如何，都会执行的操作。该方法是 ES2018 引入标准的。

promise下面的两个静态方法：
Promise.all()：用于将多个 Promise 实例，包装成一个新的 Promise 实例，接受一个数组作为参数，只有数组里面的每个状态都变成resolve，则新的Promise实例状态才会变成resolve.
Promise.race():赛跑的意思。那个状态改变最快，跟着状态。

let p1 = new Promise((resolve, reject) => {
            setTimeout(() => {
                reject('任务1');
            }, 3000);
        });
        let p2 = new Promise((resolve, reject) => {
            setTimeout(() => {
                reject('任务2');
            }, 1000);
        });
        let p3 = new Promise((resolve, reject) => {
            setTimeout(() => {
                resolve('任务3');
            }, 500);
        });

        let newpromise = Promise.all([p1, p2, p3]);
        newpromise.then(function(data) {
            console.log(data); //数组  ["任务1", "任务2", "任务3"],，接受一个数组作为参数，只有数组里面的每个状态都变成resolve，则新的 Promise 实例状态才会变成resolve
        }).catch(function() {
            console.log('失败的状态');
        })

        let newpromise2 = Promise.race([p1, p2, p3]);
        newpromise2.then(function(data) {
            console.log(data); //数组  ["任务1", "任务2", "任务3"]
        }).catch(function(data) {
            console.log(data);
        });