Gestion des événements

Node.js utilise une architecture événementielle, ce qui permet d'exécuter du code quand un événement spécifique se produit. La bibliothèque discord.js en tire pleinement parti. Vous pouvez visiter la documentation Client pour voir la liste complète des événements.

À ce stade, votre fichier index.js a des écouteurs pour deux événements : ClientReady et InteractionCreate.

client.once(Events.ClientReady, (readyClient) => {
	console.log(`Ready! Logged in as ${readyClient.user.tag}`);

client.on(Events.InteractionCreate, async (interaction) => {
	if (!interaction.isChatInputCommand()) return;

	const command = interaction.client.commands.get(interaction.commandName);

	if (!command) {
	console.error(`Aucune commande correspondant à ${interaction.commandName} n'a été trouvée.`);
a été trouvée.`);
		return;
	}

	try {
		await command.execute(interaction);
	} catch (error) {
		console.error(error);
		if (interaction.replied || interaction.deferred) {
			await interaction.followUp({
				content: 'Une erreur s\'est produite lors de l\'exécution de cette commande !',
				flags: MessageFlags.Ephemeral,
			});
		} else {
			await interaction.reply({
				content: 'Une erreur s\'est produite lors de l\'exécution de cette commande !',
				flags: MessageFlags.Ephemeral,
			});
		}
	}
});

Actuellement, les écouteurs d'événements sont dans le fichier index.js. Client#ready émet une fois quand le Client devient prêt à l'emploi, et Client#interactionCreate émet chaque fois qu'une interaction est reçue. Déplacer le code de l'écouteur d'événements dans des fichiers individuels est simple, et nous utiliserons une approche similaire au gestionnaire de commandes.

Fichiers d'événements individuels

Votre répertoire de projet devrait ressembler à ceci :

Créez un dossier events dans le même répertoire. Vous pouvez ensuite déplacer le code de vos écouteurs d'événements dans index.js vers des fichiers séparés : events/ready.js et events/interactionCreate.js.

const { Events } = require('discord.js');

module.exports = {
	name: Events.ClientReady,
	once: true,
	execute(client) {
		console.log(`Ready! Logged in as ${client.user.tag}`);
	},
};

La propriété name indique pour quel événement ce fichier est destiné, et la propriété once contient une valeur booléenne qui spécifie si l'événement doit s'exécuter une seule fois. Vous n'avez pas besoin de le spécifier dans interactionCreate.js car le comportement par défaut sera d'exécuter à chaque instance d'événement. La fonction execute contient votre logique d'événement, qui sera appelée par le gestionnaire d'événements chaque fois que l'événement émet.

Lecture des fichiers d'événements

Ensuite, écrivons le code pour récupérer dynamiquement tous les fichiers d'événements dans le dossier events. Nous utiliserons une approche similaire à notre gestionnaire de commandes. Placez le nouveau code en surbrillance ci-dessous dans votre index.js.

fs.readdirSync().filter() retourne un tableau de tous les noms de fichiers dans le répertoire donné et filtre uniquement les fichiers .js, c'est-à-dire ['ready.js', 'interactionCreate.js'].

const fs = require('node:fs');
const path = require('node:path');
const { Client, Collection, GatewayIntentBits } = require('discord.js');
const { token } = require('./config.json');

const client = new Client({ intents: [GatewayIntentBits.Guilds] });

client.commands = new Collection();
const foldersPath = path.join(__dirname, 'commands');
const commandFolders = fs.readdirSync(foldersPath);

for (const folder of commandFolders) {
	const commandsPath = path.join(foldersPath, folder);
	const commandFiles = fs.readdirSync(commandsPath).filter((file) => file.endsWith('.js'));
	for (const file of commandFiles) {
		const filePath = path.join(commandsPath, file);
		const command = require(filePath);
		if ('data' in command && 'execute' in command) {
			client.commands.set(command.data.name, command);
		} else {
			console.log(`[WARNING] The command at ${filePath} is missing a required "data" or "execute" property.`);
		}
	}
}

const eventsPath = path.join(__dirname, 'events');
const eventFiles = fs.readdirSync(eventsPath).filter((file) => file.endsWith('.js'));

for (const file of eventFiles) {
	const filePath = path.join(eventsPath, file);
	const event = require(filePath);
	if (event.once) {
		client.once(event.name, (...args) => event.execute(...args));
	} else {
		client.on(event.name, (...args) => event.execute(...args));
	}
}

client.login(token);

Vous remarquerez que le code ressemble très similaire au chargement de commandes ci-dessus - lire les fichiers dans le dossier d'événements et charger chacun individuellement.

La classe Client dans discord.js étend la classe EventEmitter. Par conséquent, l'objet client expose les méthodes .on() et .once() que vous pouvez utiliser pour enregistrer les écouteurs d'événements. Ces méthodes prennent deux arguments : le nom de l'événement et une fonction de rappel. Ceux-ci sont définis dans vos fichiers d'événements séparés comme name et execute.

La fonction de rappel transmise prend argument(s) retourné(s) par son événement respectif, les collecte dans un tableau args en utilisant la syntaxe de paramètre rest, puis appelle event.execute() tout en passant le tableau args en utilisant la syntaxe spread. Ils sont utilisés ici car différents événements dans discord.js ont un nombre d'arguments différent. Le paramètre rest collecte ce nombre variable d'arguments dans un seul tableau, et la syntaxe spread prend ensuite ces éléments et les transmet à la fonction execute.

Après cela, écouter d'autres événements est aussi facile que de créer un nouveau fichier dans le dossier events. Le gestionnaire d'événements récupérera et l'enregistrera automatiquement chaque fois que vous redémarrez votre bot.