resolve,reject

resolve相当于then，reject相当于catch

test1() {
    let p1 = new Promise((resolve, reject) => {
        reject();
    })
    p1
        .then(res => {
            console.log('成功');
        })
        .catch(err => {
            console.log('失败');
        })
}

//执行结果为 '失败'

test2() {
    let p2 = new Promise((resolve, reject) => {
        resolve(11);//带参数
    })
    p2
        .then(res => {
            console.log('成功');
            console.log(res);
        })
        .catch(err => {
            console.log('失败');
        })
}

//执行结果为 '成功'，11

链式调用

test3() {
    this.p1(true)
        .then(res => {
            console.log(res)
            return this.p2(false)
        })
        .then(res => {
            console.log(res)
        })
        .catch(err => {     //前面不管是哪一个promise走reject，都会走到catch
            console.log(err)
        })
    //结果为：
    //p1,promise成功
    //p1,promise返回数据成功
    //p2,promise失败
    //p2,promise返回数据失败
},
p1(status) {
    return new Promise((resolve, reject) => {
        if (status) {
            console.log('p1,promise成功');
            resolve('p1,promise返回数据成功')
        } else {
            console.log('p1,promise失败');
            reject('p1,promise返回数据失败')
        }
    })
},
p2(status) {
    return new Promise((resolve, reject) => {
        if (status) {
            console.log('p2,promise成功');
            resolve('p2,promise返回数据成功')
        } else {
            reject()
        }
    })
},

all

多个promise都成功的时候才走then。

Promise.all获得的成功结果的数组里面的数据顺序和Promise.all接收到的数组顺序是一致的，即p1的结果在前，即便p1的结果获取的比p2要晚。

test1() {
    Promise
        .all([
            this.p1(true),
            this.p2(true)
        ])
        .then(res => {
            console.log('全部成功')
            console.log(res)
        })
        .catch(err => {
            console.log(err)
        })
},
p1(status) {
    return new Promise((resolve, reject) => {
        if (status) {
            console.log('p1,promise成功');
            resolve('p1,promise返回数据成功')
        } else {
            console.log('p1,promise失败');
            reject('p1,promise返回数据失败')
        }
    })
},
p2(status) {
    return new Promise((resolve, reject) => {
        if (status) {
            console.log('p2,promise成功');
            resolve('p2,promise返回数据成功')
        } else {
            console.log('p2,promise失败');
            reject('p2,promise返回数据失败')
        }
    })
},
//this.p1(true),this.p2(true)的时候：
    //p1,promise成功
    //p2,promise成功
    //全部成功
    //["p1,promise返回数据成功", "p2,promise返回数据成功"] 
//this.p1(true),this.p2(false)的时候：
    //p1,promise成功
    //p2,promise失败
    //p2,promise返回数据失败

race

跟上面的all差不多，all是所有的promise都成功才走then。

race就是赛跑的意思，意思就是说，Promise.race([p1, p2, p3])里面哪个结果获得的快，就返回那个结果，不管结果本身是成功状态还是失败状态。

实战

getTreeNodeDetailInfo(menu) {
    let url = 'rest/v2/apply-spec-mng/get-tree-node-detail?key='
    return new Promise((resolve, reject) => {
        this.$http.get(url + menu.treeInfo.key).then(res => {
            this.applySpecInfo              = menu.treeInfo;
            this.currentTreeNodeMemoryPoint = menu;
            Object.assign(this.applySpecInfo, res.data);
            this.mode = 'READ';
            resolve();
        }).catch(err => {
            reject(err);
        })
    });
},
modify() {
    this.mode              = 'UPDATE';
    this.applySpecInfoTemp = JSON.parse(JSON.stringify(this.applySpecInfo));
},
editMenu(e, menu) {
    this.getTreeNodeDetailInfo(menu).then(res => {
        this.modify()
    });
},

promise是同步还是异步

1. promise本身是同步的

   let oP = new Promise( (res, rej) => {
        console.log(1);
   });
   console.log(2);
   
   //结果
   //1，2
   

2. promise的回调then，catch是异步的

   let oP = new Promise( (res, rej) => {
        console.log(1);
   });
   oP.then(res => {
        console.log(res); //3
   });
   console.log(2);
   
   //结果
   //1,2,3