Discord.js 为什么我的帮助命令不起作用？

Question

I have created a dynamic help command following the instructions on the documantation of discord.js. When I'm using //help, it's working properly, but //help ping, for example, is not.I'm not sure why this is happening, I've tried many things to fix that and nothing has worked. Any insight? code below:

index.js

// nodejs for filesystem
const fs = require("fs");
// require the discord.js module
const Discord = require("discord.js");
global.Discord = Discord;
// require canvas module for image manipulation
const Canvas = require("canvas");
// link to .json config file
const { prefix, token, adminRole } = require("./config.json");

// create a new discord client
const client = new Discord.Client();
client.commands = new Discord.Collection();
global.client = client;

const commandFiles = fs.readdirSync("./commands").filter(file => file.endsWith(".js"));

// ...
let target;
let targetName;
global.target = "000000000000000000";
global.targetName = "null";
global.adminRole = "738499487319720047";
// 737693607737163796
let hasRun = false;

for (const file of commandFiles) {
    const command = require(`./commands/${file}`);

    // set a new item in the Collection
    // with the key as the command name and the value as the exported module
    client.commands.set(command.name, command);
}

const cooldowns = new Discord.Collection();

// event triggers only once, right after bot logs in
client.once("ready", () => {
    console.log("Ready!");
    console.log(adminRole);
    client.user.setActivity("You", { type: "WATCHING" });
});

// for new member join - sends message including attachent
client.on("guildMemberAdd", async member => {
    const channel = member.guild.channels.cache.find(ch => ch.name === "welcome");
    global.channel = channel;
    if (!channel) return;

    const canvas = Canvas.createCanvas(700, 250);
    const ctx = canvas.getContext("2d");

    const background = await Canvas.loadImage("./wallpaper.jpg");
    ctx.drawImage(background, 0, 0, canvas.width, canvas.height);

    ctx.strokeStyle = "#74037b";
    ctx.strokeRect(0, 0, canvas.width, canvas.height);

    // Slightly smaller text placed above the member's display name
    ctx.font = "28px sans-serif";
    ctx.fillStyle = "#ffffff";
    ctx.fillText("Welcome to the server,", canvas.width / 2.5, canvas.height / 3.5);

    // Add an exclamation point here and below
    ctx.fillStyle = "#ffffff";
    ctx.fillText(`${member.displayName}!`, canvas.width / 2.5, canvas.height / 1.8);

    ctx.beginPath();
    ctx.arc(125, 125, 100, 0, Math.PI * 2, true);
    ctx.closePath();
    ctx.clip();

    const avatar = await Canvas.loadImage(member.user.displayAvatarURL({ format: "jpg" }));
    ctx.drawImage(avatar, 25, 25, 200, 200);

    const attachment = new Discord.MessageAttachment(canvas.toBuffer(), "welcome-image.png");

    channel.send(`Welcome to the server, ${member}!`, attachment);
});

// listening for messages.
client.on("message", message => {
    hasRun = false;

    // if (!message.content.startsWith(prefix) || message.author.bot) return;

    // log messages
    console.log(`<${message.author.tag}> ${message.content}`);

    // create an args var (const), that slices off the prefix entirely, removes the leftover whitespaces and then splits it into an array by spaces.
    const args = message.content.slice(prefix.length).trim().split(/ +/);
    global.args = args;

    // Create a command variable by calling args.shift(), which will take the first element in array and return it
    // while also removing it from the original array (so that you don't have the command name string inside the args array).
    const commandName = args.shift().toLowerCase();
    const command = client.commands.get(commandName) ||
        client.commands.find(cmd => cmd.aliases && cmd.aliases.includes(commandName));

    if (message.author.id === global.target) {

        // more code (excluded because its too long)
    }


    if (!command) return;

    if (command.guildOnly && message.channel.type !== "text") {
        return message.reply("I can't execute that command inside DMs!");
    }


    if (command.args && !args.length) {

        let reply = `You didn't provide any arguments, ${message.author}!`;

        if (command.usage) {
            reply += `\nThe proper usage would be: \`${prefix}${command.name} ${command.usage}\``;
        }

        return message.channel.send(reply);

    }

    if (!cooldowns.has(command.name)) {
        cooldowns.set(command.name, new Discord.Collection());
    }

    const now = Date.now();
    const timestamps = cooldowns.get(command.name);
    const cooldownAmount = (command.cooldown || 3) * 1000;

    if (timestamps.has(message.author.id)) {
        const expirationTime = timestamps.get(message.author.id) + cooldownAmount;

        if (now < expirationTime) {
            const timeLeft = (expirationTime - now) / 1000;
            return message.reply(`please wait ${timeLeft.toFixed(1)} more second(s) before reusing the \`${command.name}\` command.`);
        }
    }

    timestamps.set(message.author.id, now);
    setTimeout(() => timestamps.delete(message.author.id), cooldownAmount);


    try {
        target, targetName = command.execute(message, command, args, target, targetName);
    }
    catch (error) {
        console.error(error);
        message.reply("there was an error trying to execute that command!");
    }

});

client.login(token);

help.js

const { prefix } = require("../config.json");

module.exports = {
    name: "help",
    description: "List all of my commands or info about a specific command.",
    aliases: ["commands"],
    usage: "[command name]",
    cooldown: 5,
    execute(message, args) {
        const data = [];
        const { commands } = message.client;

        if (!args.length) {
            data.push("Here's a list of all my commands:");
            data.push(commands.map(command => command.name).join(", "));
            data.push(`\nYou can send \`${prefix}help [command name]\` to get info on a specific command!`);

            return message.author.send(data, { split: true })
                .then(() => {
                    if (message.channel.type === "dm") return;
                    message.reply("I've sent you a DM with all my commands!");
                })
                .catch(error => {
                    console.error(`Could not send help DM to ${message.author.tag}.\n`, error);
                    message.reply("it seems like I can't DM you!");
                });
        }

        const name = args[0].toLowerCase();
        const command = commands.get(name) || commands.find(c => c.aliases && c.aliases.includes(name));

        if (!command) {
            return message.reply("that's not a valid command!");
        }

        data.push(`**Name:** ${command.name}`);

        if (command.aliases) data.push(`**Aliases:** ${command.aliases.join(", ")}`);
        if (command.description) data.push(`**Description:** ${command.description}`);
        if (command.usage) data.push(`**Usage:** ${prefix}${command.name} ${command.usage}`);

        data.push(`**Cooldown:** ${command.cooldown || 3} second(s)`);

        message.channel.send(data, { split: true });
    },
};

Answer 1

I'd need to see your ping command, and the error itself to know for sure, but I think your problem is in your index.js file. I followed the same guide for my bots, and I haven't run into this issue. Without being able to see the error and the ping command, here are some places to look to help your troubleshooting:

• If your problem is in your index.js file, my guess is it'll be in your try, catch statement, possibly where you're passing in arguments, it could be that help isn't receiving the arguments properly. For example:

Function(arg1, arg2) and Function(arg1) aren't the same thing. They may be named the same, and share an argument, but the arguments you pass in determine which one is executed, so if you pass in two arguments, then it should execute the first function, and ignore the second. If you pass in only one, then it should execute the second function, and ignore the first.

I see in your try catch, that you're passing in a ton of arguments to the command, but the arguments help accepts don't match what you're trying to pass in, therefore it may not be seeing the arguments at all, which could explain why it works with no arguments, but fails when you try to pass one in.

This is where seeing the error/result could help, as you only said it doesn't work properly, you didn't say what it did. If the command executed as if there was no arguments despite one existing, then that would count as "not working properly", but if the command gave you an error due to it not being able to process the parameters properly, then the issue would be in your help.js command

• If your problem is in your help.js file, since you said it works with no arguments, and the error occurs when you try to get info on a specific command, then the problem will be closer to the bottom of the code provided, as that's where the info is gathered, and printed.

The issue may be that it's not seeing which command you're talking about, doesn't know you're asking for it, or it can't get the requested information because it doesn't exist.

• If your problem is in your ping.js file, it could be because you're help.js is working fine, but ping.js might not have the information that help is looking for, for instance, if it didn't have a name, or the name in the code doesn't match the name of the file (i've run into that issue a lot...). It could also be that you're missing a "}" in the file, as that would wreck it as well.

Answer 2

Added args = global.args; in the top of my help file, after the modules.export, it fixed the issue.