This tutorial is made by Fyrlex#2740

Command and Event Handler
Please make sure you have read Startup Configuration before reading this.

Command/Event Handlers are the best way for you to organize all commands and events that can be used in your bot.

The Handler-Handler
Here is the basic setup of your commands and their aliases as well as your events. Put this your index.js file below your client but above your login.
bot.aliases = new Discord.Collection(); // define aliases collection
bot.commands = new Discord.Collection(); // define commands collection
bot.events = new Discord.Collection(); // define events collection

require(`./handlers/command`)(bot);
require(`./handlers/event`)(bot);


Collections are fast ways to store temporary data that can be used at any time when your bot is online. The 3 collections above will be used later. You can create other collections for other features you might create. This is not for storing server data or user data, but collections can be used to load the data.

For each type of handler provided in the array, handler is the variable we created that will run for each item in the array. This will require the two files in the handler folder we are about to create!

Create Files and Folders
In your main directory, create a folder named handlers. Inside, create command.js and event.js

Then create a commands folder and an events folder in your main directory. We will add basic files later in this tutorial!

Command Handler
In the command.js file, use this adjustable code to load your commands into the commands collection.
const fs = require("fs"); // built in file system
module.exports = (bot) => { // define the function
fs.readdir("./commands/", (err, files) => { // read commands directory
if (err) console.log(err); // catch errors on startup
let jsfiles = files.filter(file => file.split(".").pop() === "js"); // find the .js files
if (jsfiles.length <= 0) { // basic check if there are no command files
return console.log("There are no commands to load...");
} else {
jsfiles.forEach(file => { // if there are .js files
let pull= require(`../commands/${file}`); // get command information
console.log(`Command ${file} loaded!`); // log the command name
bot.commands.set(pull.name, pull); // put the command name and options in command collection
if (pull.aliases) // check if you set aliases
pull.aliases.forEach(alias => bot.aliases.set(alias, pull.name)); // put aliases in the aliases collection
});
}
});
};


Event.js
In the event.js file, use this adjustable code to load your events into the events collection.
const fs = require("fs"); // built in file system
module.exports = (bot) => {
fs.readdir("./events/", (err, files) => {
if (err) console.log(err); // catch errors on startup
let jsfiles = files.filter(file => file.split(".").pop() === "js") // find the .js files
if (jsfiles.length <= 0) { // basic check if there are no event files
return console.log("There are no events to load...")
}
jsfiles.forEach(file => { // if there are .js files
let pull = require(`../events/${file}`); // get event information
console.log(`Event ${file} loaded!`); // log the event name
bot.events.set(pull.name, pull); // put event settings into the events collection
});
});
};

Your handlers are now finished! Let's initiate the events in your index.js file and then create your ready event! Commands are initiated when creating the files in the commands folder!

Initiate Events

Your bot needs to run the event in your index.js file in order to connect it to your events folder. This is an example of how all the events you are using will look in the index.js file. Events and their paramaters can be found here. If an event has multiple paramaters, make sure to separate them with a comma! The following code can be above the handler-handler but below your bot

// when your bot encounters the event provided
bot.on("eventName", (paramaters) =>{
// get the event from the events collection
let event = bot.events.get("eventName");

// run your bot and the paramaters above
if (event) event.run(bot, paramaters);
});

Required event paramaters can be found here. Each event has it's own paramaters that must be given in the event initiated.

In the event.run() section, you can also provide your own additional paramters/functions.

Here are two very important events to initiate in your index.js file.
bot.on("message", message => { // message is the paramter for the messge event
let event = bot.events.get("message");
if (event) event.run(bot, message) // run your bot and message to use in the file
});
bot.on("ready", () => { // there are no paramaters for the ready event
let event = bot.events.get("ready");
if (event) event.run(bot) // run your bot/client so you can use it in the file
});


Make sure to run your client in every event you use!

Basic Commands & Events Setup

Here is a little rundown of what all your event and command files should look like based on what we have already coded. Notice the similarities between the two event files below, everything outside the run function is required! Make sure you put in the right names and paramaters.

Prefix (for single prefix bots)
If you do not have a config.json file already, create one in your main directory where your main bot file (index.js or bot.js) should also be. Just below where you define your Discord.Client(), type the following:
js
bot.config = require("./config.json")

This will allow you to get every key inside your config.json by typing bot.config.KEY

Every JSON file must contain an outer set of [] or {} and we will be using {}.

Provide the following lines of code in the file you just created.
{
"prefix": "YOUR PREFIX HERE"
}

When you use bot.config.prefix you will now get your prefix automatically in your code!

Message.js
Before you can actually use commands, you need to run your message event. Every time a message is sent in a server with your bot, this event will trigger. We will make your bot ignore anything that doesn't start with its prefix. Go back to both handlers above to understand how your code connects! This will help you create future commands/features!

module.exports = {
name: "message",
run: async (bot, message) => { // use the paramaters from the event

// highly advised, prevents other bots from using your bot
if (message.author.bot) return;

// all other code recommended to go here

// get your prefix
let prefix = bot.config.prefix;

// if the user does not start their message with the prefix, ignore
if (!message.content.startsWith(prefix)) return;

// get all of the message except the prefix and split the users message by spaces " "
let args = message.content.slice(prefix.length).trim().split(' ');

// get the command they use
let cmd = args.shift().toLowerCase(); // get the first word used

// create an unassigned variable
let command;

// if the command provided exists in the collection
if (bot.commands.has(cmd)) {

// command is now the information of the command provided
command = bot.commands.get(cmd);

// if the command provided is an alias
} else if (bot.aliases.has(cmd)) {

// command is the information of the command received from the aliases collection
command = bot.commands.get(bot.aliases.get(cmd));

// if a command isn't provided, ignore
} else return;

// allow you to use your client, the message and the arguments in the command files
command.run(bot, message, args);

// say in your console what command was used
console.log(`Command Used: ${command.name}`)
}
}


Ready.js
A ready event is triggered once your bot goes online, this is where you can load or set a variety of things. For now, we will just set the presence of your bot.

module.exports = {
name: "ready",
run: async (bot) => { // use the paramaters from the event

// let yourself know when your ready event is loading
console.log("Ready event loading...");

// presence example
// presence settings
let mypresence= {
activity: {
name: 'with Something.Host'
},
status: 'online'
}
// set the presence
bot.user.setPresence(mypresence)
.then(console.log)
.catch(console.error)

// let yourself know that the ready event worked
console.log("Ready event success!")
}
}

Your bot is now online! Let's create your first command.

Command Setup
Your first command will be using the same code you ran in your message.js file. Here is an example of what your command files will start with given what we created before.

const Discord = require("discord.js");
module.exports = {
aliases: [],
description: "", // used later
name: "",
run: async (bot,message,args) => {
// command code
}
}


Ping Command
Using the template above, let's create a ping-pong command. Create a file in your commands folder. It is best to have the file name the same as the command name.
const Discord = require("discord.js");
module.exports = { // the command information from the commands collection
aliases: ["p"], // if you type your prefix then "p", this command will run
name: "ping", // pull.name in command.js and in message.js
run: async (bot,message,args) => { // command.run() from message.js
message.reply("pong!") // this will send a message tagging the author a comma, then the message
}
}
Was this article helpful?
Cancel
Thank you!