promise的基础了解

promise的介绍

promise的基础使用

promise是异步编程的一种解决方案，一般在遇到网络请求时我们会使用异步编程，我们会传入另一个函数，在数据请求成功时，将数据通过传入的函数回调出去，但是当网络请求非常复杂时，可能会出现回调地狱（出现嵌套多层的回调函数），那么promise可以很好的解决这个问题。
首先要new一个promise对象，promise需要传入一个函数，在执行传入的回调函数时，会传入两个参数，resolve和reject，同时这两个参数本身也是函数。

new promise = ((resove,reject) => {
	setTimeout(() => {
		console.log('hello world')
	},1000)
})

promise的对象

首先了解promise的生命周期：
初始为挂起状态（pending）：表示异步操作尚未结束
异步操作结束（settled）：并可能进入以下两种状态：
已完成（fulfilled）：操作成功结束
已拒绝（rejected）：操作未成功结束，可能出现请求错误

promise对象拥有两个主要的方法：
promise.prototype.catch(onRejected)：当一个promise被reject时调用onRejected
promise.prototype.then(onFulfilled,onRejected)：当一个promise被resolve调用onFulfilled，被reject时调用onRejected
这两个方法都返回一个promise，所以.then和.catch可以进行链式书写，在异步任务执行成功时调用resolve()函数；在异步任务失败时调用reject()函数，例如：

        new Promise((resolve,reject) => {
            // 第一次请求代码
            setTimeout(() => {
                resolve()
        },1000)
        }).then(() => {
            // 第一次请求结果之后的操作
            console.log('hello world')

            return new Promise((resolve,reject) => {
                // 第二次请求代码
                setTimeout(() => {
                    resolve()
                },1000)
            }).then(() => {
                // 第二次结果后操作
                console.log('hello js');
            })
        })

在执行代码时会发现，promise构造器中的代码是最先执行的，then()中代码是最后执行的。当多个promise进行级联使用时，then()方法或者catch()会返回一个新的promise，仅当前一个promise处理完成之后，后一个promise才会被处理。
在promise链中也可以进行传值，promise链具有从一个promise传递数据给另一个promise的能力：

        new Promise((resolve,reject) => {
            // 第一次请求代码
            setTimeout(() => {
                resolve('hello')
        },1000)
        }).then((value) => {
            // 第一次请求结果之后的操作
            console.log(value +' world')

            return new Promise((resolve,reject) => {
                // 第二次请求代码
                setTimeout(() => {
                    resolve(value)
                },1000)
            }).then((value) => {
                // 第二次结果后操作
                console.log(value +' hello js');
            })
        })
        //输出结果为：
        //hello world
        //hello hello js

promise链中传递promise：
在完成或者拒绝处理函数中可以返回基本类型值，从而可以在promise链中进行传递。另外，在promise中也可以传递对象，但是需要额外的处理。
传递已完成状态的promise：

        let p1 = new Promise(function (resolve, reject) {
            resolve(111);
        });

        let p2 = new Promise(function (resolve, reject) {
            resolve(222);
        })

        p1.then(value => {
            console.log(value);
            return p2;
        }).then(value => {
            console.log(value);
        });

p1中返回promise对象p2，当p2完成时，才会调用第二个then方法，将value传到处理函数中，如果p2被拒绝，那么第二个then方法中的完成处理函数就不会执行，只能通过拒绝函数才能接收到p2的值：

let p1 = new Promise(function(resolve,reject){
    resolve(1);
});

let p2 = new Promise(function(resolve,reject){
    reject(2);
})

p1.then(value=>{
    console.log(value);
    return p2;
}).catch(value=>{
    console.log(value);
});