相关疑难解决方法(0)

我写了这段代码 lib/helper.js

var myfunction = async function(x,y) {
   ....
   reutrn [variableA, variableB]
}
exports.myfunction = myfunction;

然后我试着在另一个文件中使用它

 var helper = require('./helper.js');   
 var start = function(a,b){
     ....
     const result = await helper.myfunction('test','test');
 }
 exports.start = start;

我收到了一个错误

"await仅在异步函数中有效"

有什么问题？

使用简单回调时,例如下面的示例:

test() {
  api.on( 'someEvent', function( response ) {
    return response;
  });
}

如何将函数更改为使用async/await？具体来说,假设'someEvent'保证只被调用一次,我希望函数test是一个异步函数,在执行回调之前不会返回,例如:

async test() {
  return await api.on( 'someEvent' );
}

鉴于下面的代码示例,行为是否存在差异,如果是,那么这些差异是什么？

return await promise

async function delay1Second() {
  return (await delay(1000));
}

return promise

async function delay1Second() {
  return delay(1000);
}

据我了解,第一个会在异步函数中进行错误处理,并且错误会从异步函数的Promise中冒出来.但是,第二个需要少一个滴答.它是否正确？

此片段只是返回Promise以供参考的常用函数.

function delay(ms) {
  return new Promise((resolve) => {
    setTimeout(resolve, ms);
  });
}

有什么区别

return await foo()

和

const t = await foo();
return t

http://eslint.org/docs/rules/no-return-await

await 的可能重复 仅在 async 函数中有效。

我是新手NodeJS，我发现这个概念async-await有点混乱。经过一些阅读和混乱之后，这就是我的理解。

假设，我有一个sum这样的功能。

function sum(a, b) {
  // print the numbers
  for (var i = 0; i < 100000; i++) {
    console.log(i);
  }
  // settimeout
  new Promise (resolve => {
    setTimeout(resolve, 1000);
  });
  return a+b;
}

function main() {
  let a = sum(5,2);
  console.log(a);
}

main();

它为计时器分配一个新线程并继续正常流程。它首先打印所有数字，返回a 7，然后在退出前等待1 秒。

但是现在我想按照它们的写入顺序执行这些行。await在 timer 之前放置一个关键字是有意义的Promise。

async function sum(a, b) {
  // print the numbers
  for (var …

这是我在单元测试时遇到的一个设计问题。\n让我们深入研究示例：

想象一下：

async function foo()\xc2\xa0{\n    try {\n        return apiCall()\n    }\n    catch (e) {\n        throw new CustomError(e);\n    } \n}\n\n\n\nasync function bar() {\n    return foo()\n}\n\n\n\nasync function main() {\n    try {\n        await bar()\n    }catch(e) {\n        console.error(e)\n    }\n}\n\nmain()\n

我们在这里看到什么？唯一没有 try-catch 块的函数是 bar。\n但是如果 foo 失败，它应该被 main catch 捕获。

虽然像这样进行单元测试

describe(\'testing bar\', () => {\n    it(\'foo should throw\', () => {\n        foo.mockImplementantion(() => { throw new CustomError(\'error\')});\n        bar()\n        .then((result) => console.log(result))\n        .catch((err) => { exepect(err).toBeInstanceOf(CustomError)}) // this is what we are …

我正在阅读有关Bookshelf的本教程.Bookshelf使用Bluebird承诺.有很多例子看起来像这样:

var getEvents = function(participantId) {  
  return new models.Participant()
    .query({where: {id: participantId}})
    .fetch({withRelated: ['events'], require: true})
    .then(function(model) {
      return model;
    });
};

我对承诺仍然不满意,但从我到目前为止所学到的东西看起来很奇怪.我的问题是,上述功能是否与fetch()直接返回并离开最终版本完全相同then():

var getEvents = function(participantId) {  
  return new models.Participant()
    .query({where: {id: participantId}})
    .fetch({withRelated: ['events'], require: true});
};

也就是说,它仍然做同样的事情,返回相同的承诺,可以以相同的方式调用,等等？

根据我的理解,传递给函数的参数then获取链中前一个promise的返回值.所以,在我看来.then(function (a) { return a; }),一般来说只是一个无操作.对？

如果它们不一样,有什么区别？发生了什么,为什么作者这样写呢？

链中的所有函数都async/await必须使用async/await关键字吗？

async function one() {
  return await fetch(.....);
}

async function two() {
  return await one();
}

async function three() {
  return await two();
}

我在教程中看到了一些示例，其中调用者不必使用关键字。

我已经使用Promise很长一段时间了,它们总是我用来控制程序工作流程的"东西".例:

Promise
  .resolve(obj)
  .then(doSomething1)
  .then(doSomething2)
  .catch(handleError)

而现在,我想改为试用风格,但我不知道究竟什么是正确的方法.

V1:

try {
  var body = await Promise
               .resolve(obj)
               .then(doSomething1)
               .then(doSomething2)
} catch (error) {
  callback(error)
}
callback(null, {
  statusCode: 200,
  body
})

V2:

try {
  var body = await Promise
               .resolve(obj)
               .then(doSomething1)
               .then(doSomething2)
               .then(body => {
                 callback(null, {
                   statusCode: 200,
                   body
                 })
               })
} catch (error) {
  callback(error)
}

什么是正确的方法？

我想知道如何避免这段代码的厄运金字塔：

原码

var PlayerService = {
    getPlayerTeamId: function(playerId, callback) {
        $.ajax({
            url: "/player/" + playerId + "/team",
            success: function(team) {
                callback(team.id)
            }
        });
    },
    getPlayers: function(teamId, callback) {
        $.ajax({
            url: "/team/" + teamId + "/player",
            success: callback
        });
    }
};

var PlayerDetailsController = {
    playerId: 8,
    showTeammatesClick: function() {
        PlayerService.getPlayerTeamId(this.playerId, function(teamId) {
            PlayerService.getPlayers(teamId, function(playerList) {
                // Render playerList
            });
        });
    }
};

这是我的 async/await 版本，以避免出现金字塔： 我的版本

var PlayerService = {
    getPlayerTeamId: async function(playerId, callback) {
        return await $.ajax({
                   url: "/player/" …

这里我有一个函数，可以很好地捕获同步错误，并在重新抛出错误之前对它们进行处理。

    function logExceptions<T extends (...args: any[]) => any>(func: T): (...funcArgs: Parameters<T>) => ReturnType<T> {
      return (...args: Parameters<T>): ReturnType<T> => {
        try {
          return func(...args);
        } catch (err) {
          console.log(func.name + " caused an error")
          throw err;
        }
      };
    }

function syncExample() { 
  throw new Error()
}

logExceptions(syncExample)();

控制台日志

“syncExample 导致错误”

我可以重写此函数以使其与异步无关并且也适用于异步函数吗？

async function asyncExample() { 
  throw new Error()
}
logExceptions(asyncExample)();

所需的控制台.log

“asyncExample 导致错误”

实际的console.log

””