相关疑难解决方法(0)

我看了一下bluebird promise FAQ,其中提到了这.then(success, fail)是一个反模式.我不太了解它对try和catch的解释.以下是什么问题？

some_promise_call()
.then(function(res) { logger.log(res) }, function(err) { logger.log(err) })

似乎这个例子建议以下是正确的方法.

some_promise_call()
.then(function(res) { logger.log(res) })
.catch(function(err) { logger.log(err) })

有什么不同？

我仍然是相当新的承诺,目前正在使用蓝鸟,但我有一个场景,我不太确定如何最好地处理它.

例如,我在快递应用程序中有一个承诺链,如下所示:

repository.Query(getAccountByIdQuery)
        .catch(function(error){
            res.status(404).send({ error: "No account found with this Id" });
        })
        .then(convertDocumentToModel)
        .then(verifyOldPassword)
        .catch(function(error) {
            res.status(406).send({ OldPassword: error });
        })
        .then(changePassword)
        .then(function(){
            res.status(200).send();
        })
        .catch(function(error){
            console.log(error);
            res.status(500).send({ error: "Unable to change password" });
        });

所以我追求的行为是:

• 通过Id获取帐户
• 如果此时存在拒绝,则弹出并返回错误
• 如果没有错误,则将文档转换为模型
• 使用数据库文档验证密码
• 如果密码不匹配则弹出并返回不同的错误
• 如果没有错误则更改密码
• 然后返回成功
• 如果出现其他任何问题,请返回500

所以,目前抓到似乎没有停止的链接,这是有道理的,所以我想知道如果有,我以某种方式迫使链停在基于错误的某一点的方式,或是否有更好的办法构造它以获得某种形式的分支行为,就像有一种情况一样if X do Y else Z.

任何帮助都会很棒.

我正在深入研究节点7 async/await功能,并在这样的代码中保持绊脚石

function getQuote() {
  let quote = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.";
  return quote;
} …

我正在使用MongoDB的Node.JS驱动程序,我想执行同步查询,如下所示:

function getAThing()
{
    var db = new mongo.Db("mydatabase", server, {});

    db.open(function(err, db)
    {
        db.authenticate("myuser", "mypassword", function(err, success)
        {
            if (success)
            {
                db.collection("Things", function(err, collection)
                {
                    collection.findOne({ name : "bob"}, function(err, thing)
                    {                           
                        return thing;
                    });
                });
            }
        });
    });
}

问题是,db.open是一个异步调用(它不会阻塞),因此getAThing返回"undefined",我希望它返回查询结果.我确信我可以使用某种阻塞机制,但我想知道做这样的事情的正确方法.

使用async/await和.then().catch()一起使用是否有任何危害，例如：

async apiCall(params) {
    var results = await this.anotherCall()
      .then(results => {
        //do any results transformations
        return results;
      })
      .catch(error => {
        //handle any errors here
      });
    return results;
  }

ES2017 async/await的一个很好的模式是:

async function () {
  try {
    var result = await some_promised_value()
  } catch (err) {
    console.log(`This block would be processed in
      a reject() callback with promise patterns
      but this is far more intuitive`)
    return false // or something less obtuse
  }
  result = do_something_to_result(result)
  return result;
}

能够处理这样的错误非常好.但是我想异步获取一个值,我想保护它不被重新分配(例如:数据库会话),但我仍然想使用async/await模式(纯粹因为我认为它更直观).

以下将不起作用,因为const是块作用域:

async function () {
  try {
    const result = await get_session()
  } catch (err) {
    console.log(`This block should catch any
      instantiation errors.`)
    return false
  }
  // Can't get at …

试图编写一个小的chrome扩展,它依赖于接口的回调密集查询功能chrome.*,我很快就登陆了promises和async/await,因为我需要保证某些操作的顺序,同时试图避免回调地狱.

但是,一旦我将async/await引入某些函数,使用它们的每个函数也必须转换为一个async function以便能够await返回值.最终甚至一些全局常量成为了承诺,例如

const DEBUG = new Promise(function(resolve){
    chrome.management.getSelf(resolve);
}).then(function(self){
    return self.installType == 'development';
});

但是,现在我需要在await任何地方写,并且引入奇怪的错误就像if(DEBUG){...}总是被执行变得太容易了.

虽然似乎可以使用ESLINT识别错误,但await在任何地方写入看起来都是不必要的麻烦,因此我想知道Javascript是否有一些我错过的更好的构造？

(主观上我当前使用的await/async似乎是向后的;除非明确等待,否则Promise保持原样,但我似乎更希望在异步函数中默认等待承诺,并且仅在明确请求时保持为裸承诺.)

let x;
try {
  x = ...;
} catch (e) { 
  return
}

// rest of the code that uses `x`
const y = x + ...;

x只分配一次,但我必须使用let而不是const.

另一种方式是:

try {
  const x = ...;
  // rest of the code that uses `x`
  const y = x + ...;
} catch (e) { 
  return
}

但是,这会增加嵌套并使得不清楚什么会引发错误.

有没有更好的办法？

我不必关心x如果try失败的价值,因为我将在catch块中返回.
我也不想将它解压缩到单独的函数中.

假设我们有一个在用户登录(express,node)上运行的动作.这是使用大量回调编写的代码:

checkIfEmailAndPasswordAreSet(email, password, (error, response) => {
  if (error) return errorResponse(403, 'validation error', error)
  findUserByEmail(email, (error, user) => {
    if (error) return errorResponse(500, 'db error', error)
    if (!user) return errorResponse(403, 'user not found')
    checkUserPassword(user, password, (error, result) => {
      if (error) return errorResponse(500, 'bcrypt error', error)
      if (!result) return errorResponse(403, 'incorrect password')
      updateUserLastLoggedIn(user, (error, response) => {
        if (error) return errorResponse(500, 'db error', error)      
        generateSessionToken(user, (error, token) => {
          if (error) return errorResponse(500, 'jwt error', error)
          return successResponse(user, token)
        }) …

通常，当涉及到 JavaScript 中async/ await 的错误处理时，人们默认使用try/ catch。但我想知道我是否可以使用.catch()，如

  const res = await fetch().catch((error) => (
    // error handling
  ));

  const json = await res.json();

try我想知道这是否与/catch块相同

  try {
    const res = await fetch()
    const json = await res.json();
  } catch(e) {
    // error handling
  }  

我知道从技术上讲try/catch块也可以捕获从中引发的错误res.json();，所以我想它仍然比示例更可取.catch()？