标签: bluebird

考虑到这个例子:

app.get('/url/:param', function(req, res, next) {
  var param = req.params.param;
  method1(param, function(err, model) {
    if(err) return next(err);
    method2(model, function(err, models) {
      if(err) return next(err);
      if(models.length > 0) {
        method3(mode, models, function(err, models2) {
          res.render("index.html", {model: model, models: models, models2: models2});
        });
      } else {
        res.render("index.html", {model: model, models: models});
      }
    });
  });
}

有没有办法使用promises简化这个例子？看看所有方法都是dependents并且有类似的验证.if(models.length > 0) 此外,我需要res.render在一个独特的地方进行分组.

"可能"一词表明,在某些情况下,即使您自己发现错误,也可以在控制台中收到此警告.

这些情况是什么？

鉴于,我有一些像这样的代码:

// code bits to be executed
var X = ...;
var pre = ...;
var success = ...;
var error = ...;
var post = ...;

我会像这样用Bluebird运行它:

X
.then(function(val) {
    pre(val);
    success(val);
    post(val);
})
.catch(function(err) {
    pre();
    error(err);
    post();
});

我正在寻找更简单的东西(在那里,我可以定义更少的functions),沿着这样的方向:

X
.complete(function(err, val) {
    pre(val);
    if (err) {
        error(err);
    }
    else {
        success(val);
    }
    post(val);
});

请注意,我无法使用finally,因为它没有参数,也err没有val.另请注意,val假设是null或undefined出现错误.

PS:我想的越多,我就越觉得CoffeeScript可以修复冗长问题,同时保持整洁干净(保持if外观并保持"可链接")......

如果我有一个像下面这样的简单函数,addTwo我可以使用bluebird Promise.method(addTwo)来使它成为一个承诺,即使它不执行任何异步操作.有没有办法对此做相反的事情？

function addTwo(num){
  return num + 2
}

var newValue = addTwo(2) // => 4

addTwoPromise = Promise.method(addTwo)

addTwoPromise(2).then(function(newValue){
  console.log(newValue) // == 4
})

有没有办法再次addTwoPromise从承诺转换为同步功能？我知道关于异步/等待的所有内容,我不是那样寻找答案.

我有一个Promise链,我执行了许多操作.当我达到某个then陈述时,我想创建一个可以继续链的分叉,否则,将解决整个即将到来的承诺链.

readFile('example.json').then(function (file) {
    const entries = EJSON.parse(file);
    return Promise.each(entries, function (entry) {
      return Entries.insertSync(entry);
    });
  }).then(function () {
    if (process.env.NODE_ENV === 'development') {
      return readFile('fakeUsers.json');
    } else {
      // I am done now. Finish this chain.
    }
  })
  // conditionally skip these.
  .then(() => /** ... */)
  .then(() => /** ... */)
  // finally and catch should still be able to fire
  .finally(console.log.bind('Done!'))
  .catch(console.log.bind('Error.'));

这可能与承诺有关吗？

我正在看这个问题,答案是有道理的

什么是明确的承诺构建反模式,我该如何避免它？

但是,如果你只想简单地在函数中添加一条日志消息或者简单的东西有什么方法可以避免创建像这样的新承诺

function getStuffDone(param) {
    return new Promise(function(resolve, reject) {
        // using a promise constructor
        myPromiseFn(param+1)
        .then(function(val) {
            console.log("getStuffDone executing");
            resolve(val);
        }).catch(function(err) {
            console.log("getStuffDone error");
            reject(err);
        });
    });
}

如果你想在这个位置运行promise之前想要一条日志消息怎么办？这会让事情变得更加困难吗？

function getStuffDone(param) {
    return new Promise(function(resolve, reject) {
        // using a promise constructor
        console.log("getStuffDone starting");
        myPromiseFn(param+1)
        .then(function(val) {
            console.log("getStuffDone executing");
            resolve(val);
        }).catch(function(err) {
            console.log("getStuffDone error");
            reject(err);
       });
   });
}

我正在使用Koa和Bluebird并正在尝试协同程序.我发现下面给出了一个错误.但如果我替换yield initRouters()它的内容initRouters()工作.这是为什么？

'use strict';

const fs = require('fs');
const Promise = require('bluebird');
const readdir = Promise.promisify(fs.readdir);

let app = require('koa')();

let initRouters = function *() {
  const routerDir = `${__dirname}/routers`;
  let routerFiles = yield readdir(routerDir);
  return Promise.map(routerFiles, function *(file) {
    var router = require(`${routerDir}/${file}`);

    app
      .use(router.routes())
      .use(router.allowedMethods());
  });
}

Promise.coroutine(function *() {
  yield initRouters();

  const PORT = process.env.PORT || 8000;
  app.listen(PORT);
  console.log(`Server listening on ${PORT}`);
})();

我得到的错误是

Unhandled rejection TypeError: A value [object Generator] was yielded …

这个安全装置是否必要？

Promise.all([...].map((thenable) => Promise.resolve(thenable)));

是否有可能和安全供应thenables到采集方法- Promise.all,Promise.race等？任何陷阱？

问题涉及Bluebird,以及polyfilled和所有本机ES6承诺实现.

我有这个问题 我很累 我无法解决这个问题Cast to string failed for value \"{}\" at path \"post\

{
  "confirmation": "fail",
  "message": {
    "message": "Cast to string failed for value \"{}\" at path \"post\"",
    "name": "CastError",
    "stringValue": "\"{}\"",
    "kind": "string",
    "value": {

    },
    "path": "post"
  }
}

希望你能帮助我

索引.html

    <h1>CreateComment</h1>
    <form action="/api/comment" method="post">
      <input type="text" name="post" placeholder="Post" /><br />
      <input type="text" name="text" placeholder="Text"><br />
      <input type="submit" value"Create" />
    </form>

评论.js

var mongoose = require('mongoose')

var CommentSchema = new mongoose.Schema({
  profile: {type: mongoose.Schema.Types.Mixed, default: {}},
  post: …

所以,我有4项任务:getStatus(),updateStatus(A),getTask(),updateTask(),它应该以这种方式执行:

getStatus(function(status) {
  // A
  updateStatus(status, function(status) {
    // B
    getTask(function(task) {
      // C
      updateTask(task, function(task) {
        // D
      })
    })
  })
})

所以为了避免回调地狱,我用了诺言,现在所有这四个任务都返回了一个Promise,然后我改成了这个方式

getStatus().then(function(status) {
  // A
  updateStatus(status).then(function(status) {
    // B
    getTask().then(function(task) {
      // C
      updateTask(task).then(function(task) {
        //D
      })
    })
  }) 
}) 

如你所见,它仍然有then hell,

我对Promise做错了吗？