使用过nodejs的小伙伴们肯定会遇到过，有时候难免需要连续在几个数据库里面查找数据，由于nodejs的异步特性，就很容易产生“地狱回调”的恶心代码,例如下面是我自己曾经第一个项目的恶心代码（现在真的没眼看了T . T）

 News.find({putaway:true},{"_id":0}).sort({time:-1,id:-1,sort:1}).limit(4).exec(function (error, result2) {
    if (error) next(error);
    re.news=result2;
    Mediareport.find({putaway:true},{"_id":0}).sort({date:-1,id:-1,sort:1}).limit(4).exec(function (error, result3) {
      if (error) next(error);
      re.reps=result3;
      Active.find({putaway:true}).sort({date:-1}).exec(function (error, result4) {
        if (error) next(error);
        re.act=result4[0];
        Photo.find({putaway:true},{"_id":0}).sort({id:-1}).limit(12).exec(function (error, result5) {
          if (error) next(error);
          re.phos=result5;
          Product.find({putaway:true},{"_id":0}).sort({id:-1}).limit(12).exec(function (error, result1) {
            if (error) next(error);
            re.pros=result1;
            Nav.find({putaway:true}).sort({sort:-1}).exec(function (error, result6){
              if (error) next(error);
              re.navimgs=result6;
              res.render('index', re);
            });
          });
        });
      });
    });
  });

没错，这这是一个很常见的网站首页查询数据的代码，需要查到多个库拿出数据拼出首页所需的数据，于是很无奈的就出现了这么恶心的代码了。。。这个问题也是困扰了我一段时间。
直到我上网查nodejs资料看到了nodejs promise

那么，什么是promise呢？

promise是一个异步编程的抽象，它是一个返回值或抛出exception的代理对象，一般promise对象都有一个then方法，这个then方法是我们如何获得返回值(成功实现承诺的结果值，称为fulfillment)或抛出exception(拒绝承诺的理由，称为rejection)，then是用两个可选的回调作为参数，我们可以称为onFulfilled和OnRejected：

var promise = doSomethingAync()
promise.then(onFulfilled, onRejected)

当这个promise被解决了，也就是异步过程完成后，onFulfilled和OnRejected中任何一个将被调用，
因此，一个promise有下面三个不同状态：
pending待承诺 - promise初始状态
fulfilled实现承诺 - 一个承诺成功实现状态
rejected拒绝承诺 - 一个承诺失败的状态

以读取文件为案例，下面是使用回调实现读取文件后应该做什么事情(输出打印)：

readFile(function (err, data) {
  if (err) return console.error(err)
  console.log(data)
})

如果我们的readFile函数返回一个promise，那么我们可以如下实现同样的逻辑(输出打印)：

var promise = readFile()
promise.then(console.log, console.error)

这里我们有了一个值promise代表的是异步操作，我们能够一直传递这个值promise，任何人访问这个值都能够使用then来消费使用它，无论这个值代表的异步操作是否完成或没有完成，我们也能保证异步的结果不会改变，因为这个promise代表的异步操作只会执行一次，状态是要么fulfilled要么是rejected
看到这里相信大家对promise有了一个基本的了解

接下来，向大家重点介绍一个promise nodejs 模块：Q
关于Q模块，用法跟上述说的差不多，直接上代码：

Q.fcall(promisedStep1)
.then(promisedStep2)
.then(promisedStep3)
.then(promisedStep4)
.then(function (value4) {
    // Do something with value4
})
.catch(function (error) {
    // Handle any error from all above steps
})
.done();

需要注意的是，每个函数传入的值都是上一个函数返回的数据

在这，想重点介绍q模块的一个deferred函数，如果必须与基于回调而不是基于约定的异步函数交互，Q提供了一些快捷方式。但大多数情况下，解决办法是使用defer。

var deferred = Q.defer();
FS.readFile("foo.txt", "utf-8", function (error, text) {
    if (error) {
        deferred.reject(new Error(error));
    } else {
        deferred.resolve(text);
    }
});
return deferred.promise;

如何理解上面这段话呢？
按照我这个例子来说，需要连续查询好几个库，使用了promise后，就可以吧查库的代码都放在 then() 里面，但是每个then里面查询数据库的操作，也都是异步的（就是从数据库里面拿数据需要时间，无法直接返回）这时候，使用defer方法，就能够使进程等待数据库查询完毕后再返回其数据,这样就有效避免了 地狱回调

附上我自己的代码

    getPermissionLevel({
        //可传入初始数据
      }).then(appendFace_token)//appendFace_token 函数 
        .then(appendFace_token2)//
        .done(function(obj){   //done 函数两个参数，第一个是成功，第二个是失败
             //do somethings
        }, function (obj) {
              //do somethings
        }
    )

var getFace_token = function(obj){
    //返回值为获取到当前图片脸的face数组（可能包含多个face_token）
    var deferred = Q.defer();//创建一个pomisse对象
    needle.post('https://*******',//一个接口拿数据，在这使用到 defer来让他等待数据请求的过程
        { multipart: true },
        function(err, resp, body) {
            deferred.resolve(body);
    });
    return deferred.promise;
};

到这一步，大家应该知道如何解决刚刚的地狱回调问题吧~

好不容易写到尾声了，附上一个小彩蛋
再看会我刚刚的第一段代码：

 News.find({putaway:true},{"_id":0}).sort({time:-1,id:-1,sort:1}).limit(4).exec(function (error, result2) {
    if (error) next(error);
    re.news=result2;
    Mediareport.find({putaway:true},{"_id":0}).sort({date:-1,id:-1,sort:1}).limit(4).exec(function (error, result3) {
      if (error) next(error);
      re.reps=result3;
      Active.find({putaway:true}).sort({date:-1}).exec(function (error, result4) {
        if (error) next(error);
        re.act=result4[0];
        Photo.find({putaway:true},{"_id":0}).sort({id:-1}).limit(12).exec(function (error, result5) {
          if (error) next(error);
          re.phos=result5;
          Product.find({putaway:true},{"_id":0}).sort({id:-1}).limit(12).exec(function (error, result1) {
            if (error) next(error);
            re.pros=result1;
            Nav.find({putaway:true}).sort({sort:-1}).exec(function (error, result6){
              if (error) next(error);
              re.navimgs=result6;
              res.render('index', re);
            });
          });
        });
      });
    });
  });

通过观察，发现其实里面多数都是重复的代码，于是就想，能否把他们都整合到一起呢？
苦思许久，然后，把上面代码改为（代码稍微有点复杂，但请一定耐心品读完哦~相信对你会有很大帮助）：

//封装成一个使用promise查询数据库的函数
var getPutawayDataByArray = function (obj) {
    var deferred = Q.defer()
      ,model=''//model是查询的库
      ,limit=4,query={putaway:{$ne:false}};
    if (typeof obj.getData[0] == "string" || typeof obj.getData[0] == "String"){
        //如果没有其他查询参数，使用该数值，否则要解析
        model = obj.getData[0]
    }else {
        model = obj.getData[0].name;
        limit = obj.getData[0].limit || limit;
        //若有查询条件，添加到查询里面
        if(obj.getData[0].query){
            obj.getData[0].query.putaway= obj.getData[0].query.putaway || {$ne:false};
            query = obj.getData[0].query
        }
    }
    mongoose.model(model).find(query).sort({sort:-1})
        .limit(limit).exec(function (err,doc) {
        if(err)next(err);
        obj[model]= doc;
        obj.getData.shift();//删除已经获取数据的数组值
        deferred.resolve(obj);
    });
    return deferred.promise;
};

调用方法：

  var reGetData = function(obj){
    var deterred = Q.defer();
    if(obj.getData.length){
      deterred.resolve( DataGet.getPutawayDataByArray(obj)
          .then(function(obj){
            reGetData(obj);
          })
      );
    }else{
      res.jsonp(obj);
    }
  };
//需要拿的数据
  var getdata = {
    getData: [
      {name:'team',limit:10}, 'topbarnd','info',{name:'news',limit:4},{name:'alldata',limit:1}
      ,{name:'serviceItem',limit:5},{name:'mediacase',limit:4}
    ]
  };
  getdata = req.query.getdata || getdata;
  reGetData(getdata);

使用这个这种方式后，只需将需要查询的库，查询的长度（limit）以及查询的条件（query）写在getData这个数组里面，然后把它传入reGetData方法，利用递归的方式，就可以之前的效果了~而且更加高效，利用这个方法，我把原来的代码精简到原来的四分之一，效率还显著提升了

结语

最后，希望我的经验帮助到您，欢迎大家在底下留言讨论，多多指教~