Javascript 如何使代码异步？_Javascript_Mysql_Node.js

Javascript 如何使代码异步？

javascript mysql node.js

Javascript 如何使代码异步？,javascript,mysql,node.js,Javascript,Mysql,Node.js,好的，我有一个函数，它调用MySQL数据库，获取一些信息，并对其进行处理。然后它应该比较一下。函数是异步的，但问题是调用MySQL数据库的部分在For循环中，当我尝试在那里wait时，它说“wait仅在异步函数中有效” 正如我所说，如果我将await放在con.query（）行中，它会给出错误“await仅在异步函数中有效”。我怎样才能解决这个问题？我希望它首先定义maxID，然后在控制台中写入它完全错误是： C:\...\Sentry\cmds\setkills.js:33

好的，我有一个函数，它调用MySQL数据库，获取一些信息，并对其进行处理。然后它应该比较一下。函数是异步的，但问题是调用MySQL数据库的部分在For循环中，当我尝试在那里

wait

时，它说“wait仅在异步函数中有效”

正如我所说，如果我将

await

放在

con.query（）

行中，它会给出错误“await仅在异步函数中有效”。我怎样才能解决这个问题？我希望它首先定义maxID，然后在控制台中写入它

完全错误是：

C:\...\Sentry\cmds\setkills.js:33
         await con.query(`SELECT * FROM Callers WHERE id = '${uID}';`, (e, curr) => {
         ^^^^^

SyntaxError: await is only valid in async function
    at createScript (vm.js:80:10)
    at Object.runInThisContext (vm.js:139:10)
    at Module._compile (module.js:616:28)
    at Object.Module._extensions..js (module.js:663:10)
    at Module.load (module.js:565:32)
    at tryModuleLoad (module.js:505:12)
    at Function.Module._load (module.js:497:3)
    at Module.require (module.js:596:17)
    at require (internal/module.js:11:18)
    at jsFiles.forEach (C:\...\Sentry\bot.js:93:20)

在

bot.js

第93行：

let properties = require(`./cmds/${file}`);

第92行：

jsFiles.forEach((file) => {

编辑：包括全部功能。

我使用了promise和then来实现这一点

async function savePosition(con) {
    let IDs = [];
    let finished = false;
    con.query(`SELECT * FROM Callers;`, (err, callers) => {

        if (err) throw err;

        if (callers.length < 1) throw 'No callers';

        for (let i = 0; i < callers.length; i++) {
            let maxCalls = -1;
            let maxID = "";
            let maxLast = "";

            for (let j = 0; j < callers.length; j++) {
                const uID = callers[j].id;

                let isWritten = false;
                for (let a = 0; a < IDs.length; a++) {
                    if (uID == IDs[a]) isWritten = true;
                }

                if (isWritten) continue;

                con.query(`SELECT * FROM Callers WHERE id = '${uID}';`, (e, curr) => {
                    if (e) throw e;
                    if (Number(curr[0].calls) > maxCalls) {
                        maxID = curr[0].id;
                        console.log(maxID)
                        maxCalls = curr[0].calls;
                    }
                })
            }

            IDs[i] = maxID;
            console.log("maxid" + maxID);
            con.query(`UPDATE Callers SET position = ${i + 1} WHERE id = '${maxID}';`);
        }
    })
}

var Promise = require('promise');
....
function savePosition(con) {
  let getMaxId = ()=>{
      return new Promise((resolve,reject)=>{
          let maxID;
          let counter=callers.length-1;
          for (let i = 0; i < callers.length; i++) {

            con.query(`SELECT * FROM Callers WHERE id = '${uID}';`, (e, curr) => {
              if (e)
                throw e;
              if (Number(curr[0].calls) > maxCalls) {
                maxID = 'some id';
                maxCalls = curr[0].calls;
              }
               if(counter===0) resolve(maxID);
               else couonter--;
            })

          }
      })
  }

  getMaxId().then((maxID)=>{
      IDs[i] = maxID;
      console.log("maxid" + maxID);
      con.query(`UPDATE Callers SET position = ${i + 1} WHERE id = '${maxID}';`);
  })
}

var Promise=require（'Promise'）；
....
功能保存位置（con）{
让getMaxId=（）=>{
返回新承诺（（解决、拒绝）=>{
让maxID；
let counter=callers.length-1；
for（设i=0；i{
如果（e）
投掷e；
if（数字（当前[0].calls）>maxCalls）{
maxID='someid'；
maxCalls=curr[0]。调用；
}
如果（计数器===0）解析（maxID）；
否则，我就；
})
}
})
}
getMaxId（）。然后（（maxID）=>{
IDs[i]=maxID；
console.log（“maxid”+maxid）；
con.query（`updatecallers SET position=${i+1}，其中id='${maxID}'；`）；
})
}

以下是您最新代码的一个版本，它使用Promissions和

async/await

允许您在异步查询中使用更同步的编码样式：

const util = require('util');

async function savePosition(con) {
    con.queryPromise = util.promisify(con.query);
    let IDs = [];
    let finished = false;
    let callers = await con.queryPromise(`SELECT * FROM Callers;`);

    if (callers.length < 1) throw new Error('No callers');

    for (let i = 0; i < callers.length; i++) {
        let maxCalls = -1;
        let maxID = "";
        let maxLast = "";

        for (let j = 0; j < callers.length; j++) {
            const uID = callers[j].id;

            let isWritten = false;
            for (let a = 0; a < IDs.length; a++) {
                if (uID == IDs[a]) isWritten = true;
            }

            if (isWritten) continue;

            let curr = await con.queryPromise(`SELECT * FROM Callers WHERE id = '${uID}';`);
            if (Number(curr[0].calls) > maxCalls) {
                maxID = curr[0].id;
                console.log(maxID)
                maxCalls = curr[0].calls;
            }
        }

        IDs[i] = maxID;
        console.log("maxid" + maxID);
        await con.queryPromise(`UPDATE Callers SET position = ${i + 1} WHERE id = '${maxID}';`);
    }
}

错误：

await仅在异步函数中有效

在该代码中不会发生，因此如果您需要帮助，请发布触发该错误的代码。您是对的，我经历了错误，它说错误在：array.foreach（（file）=>{let properties=require（

/cmds/${file}

）；这似乎很奇怪，因为只有在我发送的函数中有

await

时才会发生此错误。否则就不会有错误。@Lolization是

await

关键字用作

await con.query（）

或在

con.query（）的回调中

？此代码非常奇怪，因为您在循环中执行查询，但每次查询都完全相同，并且您在

调用方上循环，但从不引用i
或调用方[i]
因此，确实没有理由一遍又一遍地执行相同的查询，甚至根本没有理由进行循环。因此，要么这只是您代码的一部分，您需要向我们展示真实的代码，要么您可以完全摆脱for
循环。这个问题无法回答，因为您尝试的内容描述不足这应该如何解决问题？resolve（maxID）
将在任何查询con.query
完成之前被调用。因此maxID
将始终是未定义的
。我编辑了答案，添加了一个计数器以确保所有回拨都已返回。现在，只有在所有回拨都执行时才会调用resolved。请检查。如果它有效，请接受t他是堆栈溢出社区的负责人。您可以解释一下为什么在循环中使用await
关键字/。然后
/等等。它会生成“await仅在异步函数中有效”错误，当在外部使用它时，它不会发生错误？我现在尝试做其他事情，它会产生相同的错误。await
关键字在async
函数中，但因为它在中。然后
它会产生错误。将它放在外部效果很好。@Lolization-要使用await
，它一定很可怕直接位于异步
函数内部。不是上面某个地方的父函数，而是它所在的实际函数体必须声明为async
。因此，在的回调函数内部。forEach（）
或。然后（）
，回调本身必须声明为async
。此外，在调用方不希望返回承诺的回调中，它可能不会真正执行您想要的操作（如.forEach（）
）。请记住，所有async
函数返回的承诺只有在函数中的所有await
语句都完成时才会得到解决。@Lolization-如果父函数是async
，那么await
在for
循环中（但在.forEach（）中）就不会像在我的答案中那样正常工作。
const util = require('util');

async function savePosition(con) {
    con.queryPromise = util.promisify(con.query);
    let IDs = [];
    let finished = false;
    let callers = await con.queryPromise(`SELECT * FROM Callers;`);

    if (callers.length < 1) throw new Error('No callers');

    for (let i = 0; i < callers.length; i++) {
        let maxCalls = -1;
        let maxID = "";
        let maxLast = "";

        for (let j = 0; j < callers.length; j++) {
            const uID = callers[j].id;

            let isWritten = false;
            for (let a = 0; a < IDs.length; a++) {
                if (uID == IDs[a]) isWritten = true;
            }

            if (isWritten) continue;

            let curr = await con.queryPromise(`SELECT * FROM Callers WHERE id = '${uID}';`);
            if (Number(curr[0].calls) > maxCalls) {
                maxID = curr[0].id;
                console.log(maxID)
                maxCalls = curr[0].calls;
            }
        }

        IDs[i] = maxID;
        console.log("maxid" + maxID);
        await con.queryPromise(`UPDATE Callers SET position = ${i + 1} WHERE id = '${maxID}';`);
    }
}

savePosition(con).then(() => {
    console.log("savePosition() completed successfully");
}).catch(err => {
    console.log("Error in savePosition(), err);
});