Javascript 在callback中使用wait-关键字'；等待&x27；保留

在node.js中，我有一个数据库事务，我想在

中调用
异步
方法，然后

回调，但我得到错误消息

关键字“wait”被保留

这是异步

saveImage

函数：

const saveImage = async (parsedLink) => {
  AWS.config.region = config.awsSettings.region;
  AWS.config.accessKeyId = config.awsSettings.accessKeyId;
  AWS.config.secretAccessKey = config.awsSettings.secretAccessKey;
  const bucket = new AWS.S3({
    params: {
      Bucket: config.awsSettings.images_bucket_name,
    },
  });

  const currentDateString = new Date().toISOString().replace(/\:|\./g, '-');
  const bodystream = new Buffer(parsedLink.imgUrl, 'binary');
  const imageUrlDomain = parseDomain(parsedLink.linkUrl).domain;

  const params = {
    Key: `${parsedLink.id}/${imageUrlDomain}_${currentDateString}${parsedLink.imgType}`,
    ContentType: parsedLink.imageMime,
    ContentEncoding: 'base64',
    Body: bodystream,
  };

  const resultPromise = await bucket.upload(params).promise();
  return resultPromise.Location;
};

 async function getUsername() { // <-- async keyword here
    return (await getUser()).name; // <-- await can be used inside
 }

如果我想使用

saveImage

函数，我会收到错误消息

module.exports.addTestObject = async (ctx) => {
  const testObj = ctx.request.body;
  try {
    switch (testObj.type) {
      case interestT.getType.link: {
        const knexTestObject = TestObject.knex();
        transaction(knexTestObject, trx =>
            TestObject.query(trx)
              .insert({
                interestDate: testObj.date,
              })
              .then(newInterest => {
                // save image
                if (parsedLink.saveImg) {
                  parsedLink.imgUrl = await saveImage(testObj);
                }

                newInterest.$relatedQuery('linkInterestsRel', trx).insert({
                  linkHeader: testObj.linkHeader,
                }),
              }
              ),
          )
          .then((linkInterest) => {
            console.log(linkInterest);
          })
          .catch((err) => {
            throw err;
          });
        break;
      }
      default:
        break;
    }
    ctx.response.body = interestObj;
  } catch (err) {
    const statusCode = err.status || 400;
    ctx.throw(statusCode, err.message);
  }
};

---

常规

函数

s同步运行，直到返回。因此，不能在它们内部使用

wait

，因为不能以同步方式等待异步事件

JavaScript还有

异步函数

s，这些函数看起来像常规函数，但在概念上完全不同：它们同步运行，直到到达

等待

，然后在等待的承诺解决后停止并继续。因此，它们不能同步返回结果，而是返回一个承诺，然后在函数完成执行时解析

因此，您需要将函数转换为异步函数：

const saveImage = async (parsedLink) => {
  AWS.config.region = config.awsSettings.region;
  AWS.config.accessKeyId = config.awsSettings.accessKeyId;
  AWS.config.secretAccessKey = config.awsSettings.secretAccessKey;
  const bucket = new AWS.S3({
    params: {
      Bucket: config.awsSettings.images_bucket_name,
    },
  });

  const currentDateString = new Date().toISOString().replace(/\:|\./g, '-');
  const bodystream = new Buffer(parsedLink.imgUrl, 'binary');
  const imageUrlDomain = parseDomain(parsedLink.linkUrl).domain;

  const params = {
    Key: `${parsedLink.id}/${imageUrlDomain}_${currentDateString}${parsedLink.imgType}`,
    ContentType: parsedLink.imageMime,
    ContentEncoding: 'base64',
    Body: bodystream,
  };

  const resultPromise = await bucket.upload(params).promise();
  return resultPromise.Location;
};

 async function getUsername() { // <-- async keyword here
    return (await getUser()).name; // <-- await can be used inside
 }

但这在某种程度上混合了抽象异步函数和它们的基本承诺。如果您只是

等待

承诺，而不是添加一个

。然后

回调，代码的可读性就会大大提高：

 (async function() {
    const user    = await getUser();
    const friends = await getFriends(user);
 })();

---

具体问题可以改写为：

 const linkInterest = await transaction(knexTestObject, async trx =>
     const newInterest = await TestObject.query(trx)
          .insert({  interestDate: testObj.date,   });

     if (parsedLink.saveImg) {
       parsedLink.imgUrl = await saveImage(testObj);
     }

    await newInterest.$relatedQuery('linkInterestsRel', trx)
       .insert({  linkHeader: testObj.linkHeader, }),
});

---

您只能在

async

函数中使用

wait

，并且您的

.then（）

回调不是

async

->

.then（async（newInterest）=>{

@JonasW.谢谢，你能把它写下来作为答案吗？然后我可以结束这个问题。呃，不要在

异步

函数中使用

然后

回调。

事务

回调仍然需要是一个

异步函数

，如果你想使用

等待

进行查询（你确实应该这样做）。