JS Promise

Promise 是异步编程的一种解决方案，比传统的解决方案——回调函数和事件——更合理和更强大。它由社区最早提出和实现，ES6 将其写进了语言标准，统一了用法，原生提供了Promise对象。

对象的状态不受外界影响。Promise对象代表一个异步操作，有三种状态：pending（进行中）、fulfilled（已成功）和rejected（已失败）。只有异步操作的结果，可以决定当前是哪一种状态，任何其他操作都无法改变这个状态。

Promise对象是一个构造函数，用来生成Promise实例

const promise = new Promise(function(resolve, reject) {
  // ... some code

  if (/* 异步操作成功 */){
    resolve(value);
  } else {
    reject(error);
  }
});

Promise构造函数接受一个函数作为参数，该函数的两个参数分别是resolve和reject。

resolve函数的作用是，将Promise对象的状态从“未完成”变为“成功”（即从 pending 变为 resolved），在异步操作成功时调用，并将异步操作的结果，作为参数传递出去；reject函数的作用是，将Promise对象的状态从“未完成”变为“失败”（即从 pending 变为 rejected），在异步操作失败时调用，并将异步操作报出的错误，作为参数传递出去。

Promise实例生成以后，可以用then方法分别指定resolved状态和rejected状态的回调函数。

promise.then(function(value) {
  // success
}, function(error) {
  // failure
});

例子实现简单的Promise

example1

<script type="text/javascript">
  function test(resolve, reject) {
    var timeOut = Math.random() * 2;
    console.log('set timeout to: ' + timeOut + ' seconds.');
    setTimeout(function () {
        if (timeOut < 1) {
            console.log('call resolve()...');
            resolve('200 OK');
        }
        else {
            console.log('call reject()...');
            reject('timeout in ' + timeOut + ' seconds.');
        }
    }, timeOut * 1000);
}

var p1 = new Promise(test);
var p2 = p1.then(function (result) {
    console.log('成功：' + result);
});
var p3 = p2.catch(function (reason) {
    console.log('失败：' + reason);
});
</script>

example2 in Nodejs

//db.js
findDemandManger = (data) => {
    // need change to promise
    return new Promise((resolve, reject)=> {
        //async
        maggie.view('all', 'new', { include_docs: true }, function(err, body) {
        let userid = '';
        if (!err) {
            const BreakException = {};
            try {
                body.rows.forEach(function(doc) {
                    if (doc.doc.DomainOwner && doc.doc.DomainOwner === data) {
                        userid = doc.doc.Userid
                    }
                });
            } catch (e) {
                reject('err');
                if (e !== BreakException) throw e;
            }
            resolve(userid);
            }
        });
    })
}

sendEmailToDemandManager = (req, res) => {
  let f1 = db.findDemandManger(req.body.domainOwner);
  f1.then((userid) =>{
    if (userid !== ''){
     //ajax
      })
    } else {
      res.send(Object.assign({status:3}))
    }
  })
}

example3 in browser

// 多个promise
function runAsync1(){
    var p = new Promise(function(resolve, reject){
        //做一些异步操作
        setTimeout(function(){
            console.log('异步任务1执行完成');
            resolve('随便什么数据1');
        }, 1000);
    });
    return p;            
}
function runAsync2(){
    var p = new Promise(function(resolve, reject){
        //做一些异步操作
        setTimeout(function(){
            console.log('异步任务2执行完成');
            resolve('随便什么数据2');
        }, 2000);
    });
    return p;            
}
function runAsync3(){
    var p = new Promise(function(resolve, reject){
        //做一些异步操作
        setTimeout(function(){
            console.log('异步任务3执行完成');
            resolve('随便什么数据3');
        }, 50);
    });
    return p;            
}
runAsync1()
.then(function(data){
    console.log(data);
    return runAsync2();
})
.then(function(data){
    console.log(data);
    return runAsync3();
})
.then(function(data){
    console.log(data);
});

使用Promise.all()

Promise.all() 方法接收单个可迭代对象（如数组）作为参数，并返回一个promise。

let promises = arr.map((item)=>{
  return new Promise ((resolve, reject)=>{
    // run async
    alice.destroy(item.id, item.rev).then((body) => {
      console.log('suc deleted');
      resolve('suc deleted')
    });
  })  
});
// done all the delete then run the rest code
Promise.all(promises).then(()=>{
  console.log('suc deleted all')
})
.catch(err=>{
  console.log(err)
})