node.js - Node.js 异步和同步集成

Question

简而言之，我正在使用 discord.js 制作一个 Discord 机器人，但我在使用异步和同步功能时遇到了问题。为了分配变量，函数的最后一部分循环遍历每个变量，然后将其转换为所需的类型，可以在这里看到：

      argsList.forEach((argument, index) => {
            let finalArgument = argument

            const type = args[index].type
            if (type === UserArgument) {
                new UserArgument(argument).result
                .then(userObject => {
                    finalArgument = userObject
                })
                .catch(error => {
                    throw error
                })
            } else if (type === MemberArgument) {
                new MemberArgument(argument, guild).result
                .then(memberObject => {
                    finalArgument = memberObject
                })
                .catch(error => {
                    throw error
                })
            } else if (type === ChannelArgument) {
                new ChannelArgument(argument, guild).result
                .then(channelObject => {
                    finalArgument = channelObject
                })
                .catch(error => {
                    throw error
                })
            } else if (type === RoleArgument) {
                new RoleArgument(argument, guild).result
                .then(roleObject => {
                    finalArgument = roleObject
                })
                .catch(error => {
                    throw error
                })
            }

            finalArgList.push(finalArgument)
        })
        return finalArgList
      }

这是 UserArgument 类的外观示例（所有其他参数基本看起来都一样）

class UserArgument {
    constructor(user) {
        this.result = new Promise((resolve, reject) => {
            if (typeof(user) === "string") {
                if (user.match(/^<@!([0-9]+)>$/)) {
                    user = user.match(/[0-9]+/)
                }
                if (isNumeric(user)) {
                    ArgumentBase.client.users.fetch(user)
                    .then(userObject => {
                        resolve(userObject)
                        return userObject
                    })
                }
                this.#getUserFromName(user)
                .then(userObject => {
                    resolve(userObject)
                    return userObject
                })
            } else if (user instanceof DiscordJS.User) {
                resolve(user)
                return user
            } else if (user instanceof DiscordJS.GuildMember || user instanceof DiscordJS.ThreadMember) {
                resolve(user.user)
                return user.user
            }
            let userObject = ArgumentBase.client.users.resolve(user)
            if (userObject) {
                resolve(userObject)
                return userObject
            }
            reject(new UserNotFound(toString(user)))
        })
    }

    async #getUserFromName(username) {
        return new Promise((resolve, reject) => {
            for (const user in ArgumentBase.client.users.cache) {
                if (user.username === username) {
                    resolve(user)
                    return user
                }
            }
            throw new UserNotFound(username)
        })
    }
}

我遇到的问题是处理每个参数的代码不会等待函数完成而是跳过它。这当然会导致在处理参数之前执行命令。对于我的测试，我正在测试从 UserArgument 类中抛出错误，并且确实抛出了错误，但只是在命令已经执行之后，因为那是它决定完成的时候。

我的假设是，由于 Promise 是一个异步函数，因此代码会一直运行并且不会等待它。我尝试将参数函数转换为异步函数并使用等待，但我一直得到SyntaxError: await is only valid in async functions and the top level bodies of modules，即使该函数是异步函数（函数声明为static async getCommandArgs(invokedString, args, guild = undefined)）。如果有人可以帮助我，那就太棒了。感谢您的时间和帮助。

标签： node.jsasynchronousdiscord.js