Lenguajes de programación

INTRODUCCIÓN Y VISIÓN GENERAL

Discord.js vs Discord.py -- Guía definitiva para elegir tu stack de desarrollo

¿Qué es Discord.js y Discord.py?

Discord.js es una potente librería de Node.js que permite interactuar con la API de Discord de manera muy sencilla. Adopta un enfoque más orientado a objetos que la mayoría de otras librerías de Discord en JavaScript, haciendo que el código de tu bot sea significativamente más ordenado y fácil de comprender.

discord.py es una librería moderna, fácil de usar, rica en características y lista para async, que actúa como un wrapper de la API de Discord. Utiliza la sintaxis moderna async/await de Python y cuenta con un manejo inteligente de límites de velocidad que previene errores 429.

Historia y Evolución

Año	Discord.js	Discord.py	Eventos Importantes
2015	v0.1.0 - Lanzamiento inicial	v0.8.0 - Primera versión estable	Introducción de webhooks
2017	v11.0 - Reescritura completa	v0.16.0 - Async/await nativo	Gateway v6 introducido
2019	v12.0 - Gateway v7, Collections	v1.0.0 - Lanzamiento oficial	Intents introducidos
2021	v13.0 - Gateway v9, Intents obligatorios	v2.0 - Slash Commands, Intents	Comandos de aplicación
2023	v14.0 - Gateway v10, ESM support	v2.3 - Híbrido app_commands	Componentes UI mejorados
2025	v14.21.x - Voice v2, Performance	v2.5.2 - Flag Converters	Optimizaciones de memoria

Filosofía de cada librería

Discord.js - "Simplicidad y Performance"

• Principio core: "Hacer que el desarrollo sea intuitivo sin sacrificar potencia".

• Arquitectura: Event-driven con Collections optimizadas.

• Comunidad: Enfoque en tutoriales visuales y documentación interactiva.

"Discord.js prioriza la experiencia del desarrollador con APIs intuitivas y tooling moderno"

Discord.py - "Elegancia Pythónica"

• Principio core: "Pythónico, limpio y extensible".

• Arquitectura: Async-first con extensiones modulares.

• Comunidad: Enfoque académico con documentación técnica profunda.

"Discord.py abraza los principios de Python: legible, explícito y poderoso"

Comparativa inicial - ¿Cuál elegir?

Criterio	Discord.js	Discord.py
Curva de Aprendizaje	⭐⭐⭐ Moderada	⭐⭐⭐⭐ Fácil
Performance	⭐⭐⭐⭐⭐ Excelente	⭐⭐⭐⭐ Muy buena
Ecosistema	⭐⭐⭐⭐⭐ npm vastísimo	⭐⭐⭐⭐ PyPI robusto
Documentación	⭐⭐⭐⭐ Muy buena	⭐⭐⭐⭐⭐ Excepcional
Deployment	⭐⭐⭐⭐⭐ Muy flexible	⭐⭐⭐⭐ Flexible

Criterios de selección técnicos

Elige Discord.js si:

• Tienes experiencia previa con JavaScript/TypeScript.

• Necesitas integración con herramientas web (React dashboards, APIs REST).

• Priorizas el ecosistema npm y sus 2M+ paquetes.

• Requieres máximo rendimiento en aplicaciones con alta concurrencia.

• Planeas usar Docker y contenedores modernos.

• Tu equipo ya domina el stack JS (Next.js, Express, etc.).

Elige Discord.py si:

• Eres nuevo en programación (sintaxis más legible).

• Vienes del mundo de data science/machine learning.

• Necesitas integración con librerías científicas (numpy, pandas, scikit-learn).

• Priorizas código limpio y mantenible a largo plazo.

• Tu proyecto requiere procesamiento de datos complejos.

• Trabajas en un entorno académico o de investigación.

Métricas de adopción 2025

Métrica	Discord.js	Discord.py
Downloads mensuales	~15M (npm)	~2.1M (PyPI)
GitHub Stars	25.2k ⭐	14.8k ⭐
Servers activos estimados	~850k	~320k
Contributors	350+	280+
Issues cerrados	98.2%	97.8%

Casos de Uso Reales

Bots enterprise con Discord.js

• MEE6: 19M+ servidores, maneja 2B+ mensajes/día

• Dyno: 8M+ servidores, sistema de moderación distribuido

• Carl-bot: 6M+ servidores, automod con ML integrado

Bots especializados con Discord.py

• Red-DiscordBot: Framework modular con 500+ cogs

• Groovy (antes del cierre): 16M+ servidores de música

• Bots académicos: Universidades para gestión estudiantil

Tendencias de la industria

Encuesta Stack Overflow 2025: JavaScript continúa siendo el lenguaje más popular (65.3%), mientras Python mantiene el segundo lugar (48.2%) por séptimo año consecutivo.

📊 Insight del mercado: Los bots híbridos (microservicios JS + workers Python) están ganando tracción en aplicaciones enterprise.

---

INSTALACIÓN Y CONFIGURACIÓN COMPLETA

Guía Step-by-Step para ambos ecosistemas.

Requisitos mínimos del sistema

Componente	Discord.js	Discord.py
SO	Windows 10+, macOS 10.15+, Ubuntu 18.04+	Windows 10+, macOS 10.15+, Ubuntu 18.04+
Runtime	Node.js ≥ 16.11.0 (LTS 18 recomendado)	Python ≥ 3.8 (3.11+ recomendado)
RAM	512MB (dev), 2GB+ (producción)	512MB (dev), 1.5GB+ (producción)
Disco	500MB (deps incluidas)	300MB (deps incluidas)
Red	Puerto 443 (HTTPS), 80 (HTTP)	Puerto 443 (HTTPS), 80 (HTTP)

Instalación de Node.js (Discord.js)

Windows

# Opción 1: Descarga directa
# Visita https://nodejs.org y descarga la versión LTS

# Opción 2: Chocolatey
choco install nodejs

# Opción 3: Winget
winget install OpenJS.NodeJS

# Verificar instalación
node --version
npm --version

macOS

# Opción 1: Homebrew (recomendado)
brew install node

# Opción 2: MacPorts
sudo port install nodejs18

# Opción 3: Descarga directa desde nodejs.org

# Verificar instalación
node --version && npm --version

Linux (Ubuntu/Debian)

# Opción 1: NodeSource repository (recomendado)
curl -fsSL https://deb.nodesource.com/setup_lts.x | sudo -E bash -
sudo apt-get install -y nodejs

# Opción 2: Snap
sudo snap install node --channel=18/stable --classic

# Opción 3: NVM (gestión de versiones)
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash
nvm install --lts
nvm use --lts

# Verificar instalación
node --version && npm --version

Instalación de Python (Discord.py)

Windows

# Opción 1: Descarga desde python.org (recomendado)
# Asegúrate de marcar "Add Python to PATH"

# Opción 2: Microsoft Store
# Busca "Python 3.11" en Microsoft Store

# Opción 3: Chocolatey
choco install python311

# Verificar instalación
python --version
pip --version

macOS

# Opción 1: Homebrew (recomendado)
brew install python@3.11

# Opción 2: pyenv para múltiples versiones
brew install pyenv
pyenv install 3.11.8
pyenv global 3.11.8

# Verificar instalación
python3 --version && pip3 --version

Linux (Ubuntu/Debian)

# Ubuntu 22.04+ incluye Python 3.10+
sudo apt update
sudo apt install python3 python3-pip python3-venv

# Para versiones específicas
sudo apt install python3.11 python3.11-venv python3.11-pip

# Verificar instalación
python3 --version && pip3 --version

Configuración del proyecto Discord.js

Estructura de carpetas recomendada

mi-bot-discord/
├── src/
│   ├── commands/
│   │   ├── admin/
│   │   ├── fun/
│   │   ├── moderation/
│   │   └── utility/
│   ├── events/
│   │   ├── client/
│   │   └── guild/
│   ├── handlers/
│   ├── schemas/
│   └── utils/
├── config/
├── logs/
├── .env
├── .gitignore
├── package.json
├── package-lock.json
└── README.md

Inicialización del proyecto

# Crear directorio del proyecto
mkdir mi-bot-discord && cd mi-bot-discord

# Inicializar package.json
npm init -y

# Instalar dependencias principales
npm install discord.js@latest

# Dependencias adicionales comunes
npm install dotenv chalk moment mongoose

# Dependencias de desarrollo
npm install --save-dev nodemon typescript @types/node

# Crear estructura de carpetas
mkdir -p src/{commands/{admin,fun,moderation,utility},events/{client,guild},handlers,schemas,utils} config logs

Configuración de package.json

{
  "name": "mi-bot-discord",
  "version": "1.0.0",
  "description": "Un bot de Discord completo con Discord.js v14",
  "main": "src/index.js",
  "type": "module",
  "scripts": {
    "start": "node src/index.js",
    "dev": "nodemon src/index.js",
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": ["discord", "bot", "discord.js", "v14"],
  "author": "Tu Nombre",
  "license": "MIT",
  "dependencies": {
    "discord.js": "^14.21.3",
    "dotenv": "^16.3.1",
    "chalk": "^5.3.0",
    "moment": "^2.29.4",
    "mongoose": "^8.0.3"
  },
  "devDependencies": {
    "nodemon": "^3.0.2"
  },
  "engines": {
    "node": ">=16.11.0"
  }
}

Configuración del proyecto Discord.py

Estructura de carpetas recomendada

mi-bot-discord/
├── cogs/
│   ├── admin/
│   ├── fun/
│   ├── moderation/
│   └── utility/
├── data/
│   ├── databases/
│   └── json/
├── utils/
├── logs/
├── requirements.txt
├── .env
├── .gitignore
├── main.py
└── README.md

Creación del entorno virtual

# Crear directorio del proyecto
mkdir mi-bot-discord && cd mi-bot-discord

# Crear entorno virtual
python -m venv bot_env

# Activar entorno virtual
# Windows:
bot_env\Scripts\activate
# Unix/macOS:
source bot_env/bin/activate

# Actualizar pip
pip install --upgrade pip

# Instalar discord.py con extras
pip install discord.py[voice,speed] python-dotenv aiohttp

# Crear requirements.txt
pip freeze > requirements.txt

# Crear estructura de carpetas
mkdir -p cogs/{admin,fun,moderation,utility} data/{databases,json} utils logs

requirements.txt Completo

textdiscord.py[voice]==2.5.2
python-dotenv==1.0.0
aiohttp[speedups]==3.9.1
asyncpg==0.29.0
motor==3.3.2
redis==5.0.1
Pillow==10.2.0
matplotlib==3.8.2
numpy==1.26.2
psutil==5.9.6
colorama==0.4.6

Configuración de variables de entorno

Archivo .env (ambos proyectos)

# Token del Bot (NUNCA compartir)
DISCORD_TOKEN=tu_token_super_secreto_aqui

# IDs importantes
CLIENT_ID=123456789012345678
GUILD_ID=123456789012345678
OWNER_ID=123456789012345678

# Base de datos
DATABASE_URL=postgresql://user:password@localhost:5432/botdb
MONGO_URI=mongodb://localhost:27017/botdb
REDIS_URL=redis://localhost:6379

# APIs externas
YOUTUBE_API_KEY=tu_api_key_youtube
OPENAI_API_KEY=tu_api_key_openai
WEATHER_API_KEY=tu_api_key_weather

# Configuración
NODE_ENV=development
LOG_LEVEL=debug
PREFIX=!

Docker Setup (Ambos proyectos)

Dockerfile para Discord.js

# Multi-stage build para optimizar tamaño
FROM node:18-alpine AS builder

WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production

FROM node:18-alpine AS runner

# Instalar dependencias del sistema
RUN apk add --no-cache dumb-init ffmpeg python3 make g++

# Crear usuario no-root
RUN addgroup -g 1001 -S nodejs && \
    adduser -S discordjs -u 1001

WORKDIR /app
COPY --from=builder /app/node_modules ./node_modules
COPY --chown=discordjs:nodejs . .

USER discordjs
EXPOSE 3000

# Usar dumb-init para manejo correcto de señales
ENTRYPOINT ["dumb-init", "--"]
CMD ["npm", "start"]

Dockerfile para Discord.py

FROM python:3.11-slim AS builder

# Instalar dependencias de construcción
RUN apt-get update && apt-get install -y \
    build-essential \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir --user -r requirements.txt

FROM python:3.11-slim AS runner

# Instalar dependencias de runtime
RUN apt-get update && apt-get install -y \
    ffmpeg \
    && rm -rf /var/lib/apt/lists/*

# Crear usuario no-root
RUN useradd --create-home --shell /bin/bash discordpy

WORKDIR /app
COPY --from=builder /root/.local /home/discordpy/.local
COPY --chown=discordpy:discordpy . .

USER discordpy
ENV PATH=/home/discordpy/.local/bin:$PATH

CMD ["python", "main.py"]

docker-compose.yml

version: '3.8'

services:
  # Bot Discord.js
  bot-js:
    build: 
      context: ./discord-js-bot
      dockerfile: Dockerfile
    environment:
      - NODE_ENV=production
    env_file:
      - ./discord-js-bot/.env
    volumes:
      - ./logs:/app/logs
    restart: unless-stopped
    depends_on:
      - postgres
      - redis
    networks:
      - bot-network

  # Bot Discord.py
  bot-py:
    build: 
      context: ./discord-py-bot
      dockerfile: Dockerfile
    env_file:
      - ./discord-py-bot/.env
    volumes:
      - ./logs:/app/logs
    restart: unless-stopped
    depends_on:
      - postgres
      - redis
    networks:
      - bot-network

  # Base de datos PostgreSQL
  postgres:
    image: postgres:15-alpine
    environment:
      POSTGRES_DB: botdb
      POSTGRES_USER: botuser
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
    volumes:
      - postgres_data:/var/lib/postgresql/data
    networks:
      - bot-network
    restart: unless-stopped

  # Redis para caché
  redis:
    image: redis:7-alpine
    command: redis-server --appendonly yes
    volumes:
      - redis_data:/data
    networks:
      - bot-network
    restart: unless-stopped

volumes:
  postgres_data:
  redis_data:

networks:
  bot-network:
    driver: bridge

Verificación de la instalación

Test Discord.js

// test-installation.js
import { Client, GatewayIntentBits } from 'discord.js';
import 'dotenv/config';

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

client.once('ready', () => {
    console.log('✅ Discord.js instalado correctamente');
    console.log(`📡 Conectado como ${client.user.tag}`);
    process.exit(0);
});

client.login(process.env.DISCORD_TOKEN).catch(console.error);

Test Discord.py

# test_installation.py
import discord
from discord.ext import commands
import os
from dotenv import load_dotenv

load_dotenv()

bot = commands.Bot(command_prefix='!', intents=discord.Intents.default())

@bot.event
async def on_ready():
    print('✅ Discord.py instalado correctamente')
    print(f'📡 Conectado como {bot.user}')
    await bot.close()

bot.run(os.getenv('DISCORD_TOKEN'))

Herramientas de Desarrollo Recomendadas

VSCode Extensions

{
  "recommendations": [
    "ms-vscode.vscode-json",
    "bradlc.vscode-tailwindcss",
    "ms-python.python",
    "ms-python.pylint",
    "esbenp.prettier-vscode",
    "ms-vscode.vscode-typescript-next"
  ]
}

Comandos útiles para el día a día

Discord.js

Desarrollo con hot reload

npm run dev

# Generar documentación
npm run docs

# Linting y formato
npm run lint && npm run format

# Build para producción
npm run build

# Análisis de seguridad
npm audit --audit-level moderate

Discord.py

Ejecutar con recarga automática

python -m watchdog.observers main.py

# Generar requirements.txt actualizado
pip freeze > requirements.txt

# Linting con flake8
flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics

# Tests con pytest
pytest tests/ -v

# Análisis de seguridad
safety check

CONCEPTOS BÁSICOS

Cliente, intentos, eventos y comandos

1. Cliente (Client)

Elemento	Discord.js (JS)	discord.py (Py)
Clase principal	Client	discord.Client / commands.Bot
Import	import { Client } from "discord.js";	import discord from discord.ext import commands
Instanciación	const client = new Client({ intents: [...] });	client = discord.Client(intents=intents) o bot = commands.Bot(command_prefix="!", intents=intents)
Login	client.login(process.env.DISCORD_TOKEN);	client.run(TOKEN) / bot.run(TOKEN)

Ejemplo completo [JS]

// src/index.js
import { Client, GatewayIntentBits } from "discord.js";
import dotenv from "dotenv";
dotenv.config();

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

client.once("ready", () => {
  console.log(`✅ Conectado como ${client.user.tag}`);
});

client.on("messageCreate", message => {
  if (message.content === "!ping") {
    message.reply("Pong!");
  }
});

client.login(process.env.DISCORD_TOKEN);

Ejemplo completo [Py]

# main.py
import os
import discord
from discord.ext import commands
from dotenv import load_dotenv

load_dotenv()
intents = discord.Intents.default()
intents.message_content = True

bot = commands.Bot(command_prefix="!", intents=intents)

@bot.event
async def on_ready():
    print(f"✅ Conectado como {bot.user}")

@bot.command()
async def ping(ctx):
    await ctx.send("Pong!")

bot.run(os.getenv("DISCORD_TOKEN"))

---

2. Intentos

Los intentos controlan qué eventos recibe tu bot del Gateway. Desde 2021 son obligatorios.

Intents	JS (GatewayIntentBits)	Py (discord.Intents)
Predeterminados	GatewayIntentBits.Guilds	discord.Intents.default()
Mensajes de contenido	MessageContent	message_content=True
Miembros del servidor	GuildMembers	members=True
Presencias de usuarios	GuildPresences	presences=True

Activa solo los intents necesarios. Los privileged intents (miembros y presencias) requieren verificación al superar 100 servidores.

---

3. Eventos

Maneja eventos usando client.on (JS) o @bot.event (Py).

Evento	JS	Py	Descripción
Conexión lista	ready	on_ready	Bot inició sesión y está listo
Mensaje recibido	messageCreate	on_message	Se recibe un mensaje en un canal
Nuevo miembro	guildMemberAdd	on_member_join	Alguien se une al servidor
Interacción	interactionCreate	on_interaction	Slash command o componente interactivo
Reacción añadida	messageReactionAdd	on_reaction_add	Una reacción Emoji fue añadida a un mensaje

Ejemplo de eventos avanzados

// JS - manejo de interacción de botón
client.on("interactionCreate", async interaction => {
  if (!interaction.isButton()) return;
  await interaction.reply(`Botón pulsado: ${interaction.customId}`);
});

# Py - manejo de interacción de botón
@bot.event
async def on_interaction(interaction):
    if interaction.type == discord.InteractionType.component:
        await interaction.response.send_message(f"Botón pulsado: {interaction.data['custom_id']}")

---

4. Comandos

Comandos de prefijo vs Comandos de barra

Característica	Prefix Commands	Slash Commands
Invocación	!comando args	/comando args
Autocompletar	No	Sí
Parámetros tipados	Manualmente parseados	Tipados automáticamente
Permisos por comando	Manual	Configurable en Portal de Desarrollador
Soporte JS	client.on("messageCreate")	@Slash() (discord.js builders)
Soporte Py	@bot.command()	@app_commands.command()

Ejemplo de comando de barra [JS]

import { REST, Routes, SlashCommandBuilder } from "discord.js";
import dotenv from "dotenv";
dotenv.config();

const commands = [
  new SlashCommandBuilder()
    .setName("saludar")
    .setDescription("Envía un saludo"),
].map(cmd => cmd.toJSON());

const rest = new REST({ version: "10" }).setToken(process.env.DISCORD_TOKEN);

(async () => {
  await rest.put(
    Routes.applicationGuildCommands(process.env.CLIENT_ID, process.env.GUILD_ID),
    { body: commands }
  );
  console.log("Slash command registrado");
})();

Ejemplo de comando de barra [Py]

from discord import app_commands
import discord

class MyClient(discord.Client):
    def __init__(self):
        super().__init__(intents=discord.Intents.default())
        self.tree = app_commands.CommandTree(self)

    async def setup_hook(self):
        self.tree.copy_global_to(guild=discord.Object(id=GUILD_ID))
        await self.tree.sync(guild=discord.Object(id=GUILD_ID))

client = MyClient()

@client.tree.command(name="saludar", description="Envía un saludo")
async def saludar(interaction: discord.Interaction):
    await interaction.response.send_message("¡Hola!")

client.run(TOKEN)

---

5. Terminología Comparada

Término	JS	Py
Cliente	Client	Client / Bot
Comando prefix	messageCreate + parser	@bot.command()
Comando slash	SlashCommandBuilder	@app_commands.command()
Cog / Extensión	Collection<string, Command>	cog class
Evento ready	ready	on_ready
Evento mensaje	messageCreate	on_message

ACCIONADOR DE COMANDOS

Comandos de prefijo, comandos de barra y menús contextuales

Tabla de Contenidos

1. Estructura de un Command Handler

2. Prefix Commands

3. Slash Commands (Application Commands)

4. Context Menus (User & Message Commands)

5. Middleware y Validaciones

6. Auto-completado y Parámetros

7. Ejemplos Listos para Copiar

---

1. Estructura de un accionador de comandos

Discord.js

src/
└─ handlers/
   ├─ commandHandler.js
   └─ eventHandler.js

// commandHandler.js
import { Collection } from "discord.js";
import fs from "fs";
import path from "path";

export const registerCommands = client => {
  client.commands = new Collection();
  const commandsPath = path.join(__dirname, "../commands");
  const commandFiles = fs.readdirSync(commandsPath).filter(f => f.endsWith(".js"));

  for (const file of commandFiles) {
    const command = require(`${commandsPath}/${file}`);
    client.commands.set(command.data.name, command);
  }
};

discord.py

cogs/
└─ base.py

# cogs/base.py
from discord.ext import commands
import os

class Base(commands.Cog):
    def __init__(self, bot):
        self.bot = bot

    @commands.Cog.listener()
    async def on_ready(self):
        print("Base cog cargado")

async def setup(bot):
    await bot.add_cog(Base(bot))

---

2. Comandos de prefijo

Discord.js

// commands/ping.js
export default {
  data: {
    name: "ping",
    description: "Responde con Pong!"
  },
  async execute(message, args) {
    await message.channel.send("Pong!");
  }
};

// index.js
client.on("messageCreate", async message => {
  if (!message.content.startsWith(prefix) || message.author.bot) return;
  const [cmdName, ...args] = message.content.slice(prefix.length).trim().split(/\s+/);
  const command = client.commands.get(cmdName);
  if (!command) return;
  try {
    await command.execute(message, args);
  } catch (err) {
    console.error(err);
    message.reply("Error al ejecutar el comando.");
  }
});

discord.py

# cogs/fun.py
from discord.ext import commands

class Fun(commands.Cog):
    def __init__(self, bot):
        self.bot = bot

    @commands.command(name="ping", help="Responde con Pong!")
    async def ping(self, ctx):
        await ctx.send("Pong!")

async def setup(bot):
    await bot.add_cog(Fun(bot))

---

3. Comandos de barra

Registro

Discord.js

import { REST, Routes, SlashCommandBuilder } from "discord.js";
const commands = [
  new SlashCommandBuilder()
    .setName("echo")
    .setDescription("Repite tu mensaje")
    .addStringOption(opt => opt.setName("texto").setDescription("Texto a repetir").setRequired(true))
].map(c => c.toJSON());

await rest.put(
  Routes.applicationCommands(CLIENT_ID),
  { body: commands }
);

discord.py

from discord import app_commands

@client.tree.command(name="echo", description="Repite tu mensaje")
@app_commands.describe(texto="Texto a repetir")
async def echo(interaction, texto: str):
    await interaction.response.send_message(texto)

Manejo en el bot

Discord.js

client.on("interactionCreate", async inter => {
  if (!inter.isCommand()) return;
  const cmd = client.commands.get(inter.commandName);
  if (!cmd) return;
  try {
    await cmd.execute(inter);
  } catch {
    await inter.reply({ content: "Error interno", ephemeral: true });
  }
});

discord.py

@client.tree.command(name="echo")
async def echo(interaction: discord.Interaction, texto: str):
    await interaction.response.send_message(texto)

---

4. Menús contextuales

Tipo	Discord.js	discord.py
Usuario	setType(ApplicationCommandType.User)	@app_commands.user_command()
Mensaje	setType(ApplicationCommandType.Message)	@app_commands.message_command()

Discord.js – Ejemplo mensaje

new SlashCommandBuilder()
  .setName("info_mensaje")
  .setDescription("Muestra información del mensaje")
  .setType(2);  // 2 = MESSAGE

discord.py – Ejemplo usuario

@client.tree.user_command(name="Ver Perfil")
async def view_profile(interaction, user: discord.User):
    await interaction.response.send_message(f"{user.name}#{user.discriminator}")

---

5. Middleware y validaciones

Validación	JS	Py
Verificar Roles	member.roles.cache.has(id)	@commands.has_role("Admin")
Verificar Canal	if(channel.id!==id) return	@commands.check(is_correct_channel)
Cooldowns	setTimeout + Map	@commands.cooldown(1, 10, commands.BucketType.user)

// Ejemplo cooldown JS
const cooldowns = new Collection();
// Dentro del handler de comandos
if (!cooldowns.has(cmd.name)) cooldowns.set(cmd.name, new Collection());
const now = Date.now();
const timestamps = cooldowns.get(cmd.name);
const cooldownAmount = (cmd.cooldown || 3) * 1000;
if (timestamps.has(message.author.id)) {
  const expiration = timestamps.get(message.author.id) + cooldownAmount;
  if (now < expiration) {
    return message.reply(`Espera ${((expiration - now)/1000).toFixed(1)}s.`);
  }
}
timestamps.set(message.author.id, now);
setTimeout(() => timestamps.delete(message.author.id), cooldownAmount);

# Ejemplo cooldown Py
@commands.cooldown(1, 5, commands.BucketType.user)
@commands.command(name="test")
async def test(ctx):
    await ctx.send("Comando en cooldown!")

---

6. Auto-completado y parámetros

Discord.js

client.on("interactionCreate", async inter => {
  if (!inter.isAutocomplete()) return;
  const focused = inter.options.getFocused(true);
  const choices = ["manzana","membrillo","melón"];
  const filtered = choices.filter(c => c.startsWith(focused.value));
  await inter.respond(filtered.map(c => ({ name:c, value:c })));
});

discord.py

@client.tree.command(name="fruta")
@app_commands.autocomplete(fruta=lambda ctx, current: [Choice(name=f, value=f) for f in ["manzana","membrillo","melón"] if f.startswith(current)])
async def fruta(interaction: discord.Interaction, fruta: str):
    await interaction.response.send_message(fruta)

---

7. Ejemplos listos para copiar

Comando /calculadora con parámetros numéricos

// JS – commands/calculadora.js
import { SlashCommandBuilder } from "discord.js";
export const data = new SlashCommandBuilder()
  .setName("calculadora")
  .setDescription("Operaciones básicas")
  .addIntegerOption(opt => opt.setName("a").setDescription("Primer número").setRequired(true))
  .addIntegerOption(opt => opt.setName("b").setDescription("Segundo número").setRequired(true))
  .addStringOption(opt => opt.setName("op").setDescription("Operación").addChoices(
    { name: "sumar", value: "sum" },
    { name: "restar", value: "sub" }
  ).setRequired(true));

export async function execute(inter) {
  const a = inter.options.getInteger("a");
  const b = inter.options.getInteger("b");
  const op = inter.options.getString("op");
  const res = op === "sum" ? a + b : a - b;
  await inter.reply(`Resultado: ${res}`);
}

# Py – calculadora.py
from discord import app_commands
import discord

class Calculadora(commands.Cog):
    def __init__(self, bot):
        self.bot = bot

    @app_commands.command(name="calculadora", description="Operaciones básicas")
    @app_commands.describe(a="Primer número", b="Segundo número", op="Operación")
    @app_commands.choices(op=[
        app_commands.Choice(name="sumar", value="sum"),
        app_commands.Choice(name="restar", value="sub")
    ])
    async def calculadora(self, interaction: discord.Interaction, a: int, b: int, op: app_commands.Choice[str]):
        res = a + b if op.value == "sum" else a - b
        await interaction.response.send_message(f"Resultado: {res}")

async def setup(bot):
    await bot.add_cog(Calculadora(bot))

COMPONENTES DE INTERFAZ (UI)

Botones, menús de selección, modales y filas de acción.

---

1. Introducción a componentes

Los componentes interactivos permiten interfaces ricas sin salir de Discord. Son gestionados por el Gateway v10 y requieren manejar el evento interactionCreate.

---

2. Botones

Propiedad	Discord.js (ButtonBuilder)	discord.py (discord.ui.Button)
Label	setLabel("Click")	discord.ui.Button(label="Click")
Custom ID	setCustomId("btn1")	discord.ui.Button(custom_id="btn1")
Estilo	setStyle(ButtonStyle.Primary)	discord.ui.Button(style=ButtonStyle.primary)

[JS] – Creación y manejo de botones

import { ActionRowBuilder, ButtonBuilder, ButtonStyle } from "discord.js";

const row = new ActionRowBuilder().addComponents(
  new ButtonBuilder()
    .setCustomId("primary")
    .setLabel("Primary")
    .setStyle(ButtonStyle.Primary)
);

await interaction.reply({ content: "Prueba botones", components: [row] });

client.on("interactionCreate", async i => {
  if (!i.isButton()) return;
  if (i.customId === "primary") {
    await i.update({ content: "¡Botón primary pulsado!", components: [] });
  }
});

[Py] – Creación y manejo de botones

from discord.ui import Button, View
import discord

class ButtonView(View):
    @discord.ui.button(label="Primary", style=discord.ButtonStyle.primary, custom_id="primary")
    async def primary_button(self, button: Button, interaction: discord.Interaction):
        await interaction.response.edit_message(content="¡Botón primary pulsado!", view=None)

view = ButtonView()
await interaction.response.send_message("Prueba botones", view=view)

---

3. Menús de selección

Propiedad	Discord.js (StringSelectMenuBuilder)	discord.py (discord.ui.Select)
Custom ID	setCustomId("select1")	discord.ui.Select(custom_id="s1")
Opciones	addOptions([{ label, value }])	options=[discord.SelectOption(...)]
Placeholder	setPlaceholder("Elige...")	placeholder="Elige..."

[JS] – Creación y manejo de menú de selección

import { ActionRowBuilder, StringSelectMenuBuilder } from "discord.js";

const row = new ActionRowBuilder().addComponents(
  new StringSelectMenuBuilder()
    .setCustomId("select1")
    .setPlaceholder("Selecciona fruta")
    .addOptions([
      { label: "🍎 Manzana", value: "manzana" },
      { label: "🍌 Banana", value: "banana" },
      { label: "🍇 Uvas", value: "uvas" }
    ])
);

await interaction.reply({ content: "Elige una fruta", components: [row] });

client.on("interactionCreate", async i => {
  if (!i.isStringSelectMenu()) return;
  await i.update({ content: `Has elegido: ${i.values[0]}`, components: [] });
});

[Py] – Creación y manejo de menú de selección

from discord.ui import Select, View

class SelectView(View):
    @discord.ui.select(
        placeholder="Selecciona fruta",
        custom_id="select1",
        options=[
            discord.SelectOption(label="🍎 Manzana", value="manzana"),
            discord.SelectOption(label="🍌 Banana", value="banana"),
            discord.SelectOption(label="🍇 Uvas", value="uvas")
        ]
    )
    async def select_callback(self, select: Select, interaction: discord.Interaction):
        await interaction.response.edit_message(content=f"Has elegido: {select.values}", view=None)

view = SelectView()
await interaction.response.send_message("Elige una fruta", view=view)

---

4. Modales (formularios)

Propiedad	Discord.js (ModalBuilder)	discord.py (discord.ui.Modal)
Custom ID	setCustomId("modal1")	discord.ui.Modal(custom_id="m1")
Título	setTitle("Formulario")	discord.ui.Modal(title="Formulario")
Campos	addComponents(TextInputBuilder)	discord.ui.TextInput(...)

[JS] – Creación y manejo de modales

import { ModalBuilder, TextInputBuilder, TextInputStyle, ActionRowBuilder } from "discord.js";

const modal = new ModalBuilder()
  .setCustomId("modal1")
  .setTitle("Formulario")
  .addComponents(
    new ActionRowBuilder().addComponents(
      new TextInputBuilder()
        .setCustomId("campo1")
        .setLabel("Tu nombre")
        .setStyle(TextInputStyle.Short)
        .setRequired(true)
    )
  );

await interaction.showModal(modal);

client.on("interactionCreate", async i => {
  if (!i.isModalSubmit()) return;
  const nombre = i.fields.getTextInputValue("campo1");
  await i.reply(`Hola ${nombre}!`);
});

[Py] – Creación y manejo de modales

from discord.ui import Modal, TextInput
import discord

class MyModal(Modal):
    def __init__(self):
        super().__init__(title="Formulario")
        self.add_item(TextInput(label="Tu nombre", custom_id="campo1", style=discord.TextStyle.short))

    async def on_submit(self, interaction: discord.Interaction):
        nombre = self.children.value
        await interaction.response.send_message(f"Hola {nombre}!")

await interaction.response.send_modal(MyModal())

---

5. Filas de acción y diseño

Los componentes deben agruparse dentro de ActionRow para mantener la estructura de hasta 5 componentes por fila.

import { ActionRowBuilder } from "discord.js";

const buttonRow = new ActionRowBuilder().addComponents(button1, button2);
const selectRow = new ActionRowBuilder().addComponents(selectMenu);

from discord.ui import View

view = View()
view.add_item(button)
view.add_item(select)

---

6. Componentes de menús contextuales

Tipo	JS (ContextMenuCommandBuilder)	Py (@app_commands.*_command)
Message	.setType(ApplicationCommandType.Message)	@app_commands.message_command()
User	.setType(ApplicationCommandType.User)	@app_commands.user_command()

---

7. Ejemplos Equivalentes JS ↔︎ Py

Combinación de botón + modales

// JS
const button = new ButtonBuilder()
  .setCustomId("openModal")
  .setLabel("Abrir Formulario")
  .setStyle(ButtonStyle.Success);

const view = new ActionRowBuilder().addComponents(button);
await interaction.reply({ content: "Presiona para abrir modal", components: [view] });

client.on("interactionCreate", async i => {
  if (i.isButton() && i.customId === "openModal") {
    await i.showModal(modal);
  }
});

# Py
class ButtonModalView(View):
    @discord.ui.button(label="Abrir Formulario", style=discord.ButtonStyle.success, custom_id="openModal")
    async def open_modal(self, button, interaction: discord.Interaction):
        await interaction.response.send_modal(MyModal())

view = ButtonModalView()
await interaction.response.send_message("Presiona para abrir modal", view=view)

EMBEDS AVANZADOS

Creación de mensajes ricos con embeds

Tabla de Contenidos

1. Estructura Básica de un Embed

2. Propiedades Comunes

3. Campos y Layout

4. Color y Estilos

5. Thumbnail, Image, Footer, Author

6. Comparativa JS ↔︎ Py

7. Ejemplos Profesionales

---

1. Estructura básica de un embed

Aspecto	Discord.js (EmbedBuilder)	discord.py (discord.Embed)
Instanciación	new EmbedBuilder()	discord.Embed()
Serialización	embed.toJSON()	No aplica (enviado directamente)
Envío	channel.send({ embeds: [embed] })	await ctx.send(embed=embed)

---

2. Propiedades comunes

Propiedad	JS (set)	Py (embed.)	Descripción
Título	.setTitle("Título")	title="Título"	Título principal
Descripción	.setDescription("Texto")	description="Texto"	Texto principal
URL	.setURL("https://...")	url="https://..."	Enlace al título
Color	.setColor("#0099ff")	color=0x0099ff	Color del borde
Timestamp	.setTimestamp()	timestamp=datetime.utcnow()	Marca de tiempo

---

3. Campos y diseño

Los campos se muestran en columnas responsivas.

Método JS	Método Py
.addFields({ name, value, inline })	.add_field(name="", value="", inline=True)

Ejemplo de campos

const embed = new EmbedBuilder()
  .addFields(
    { name: "Campo 1", value: "Valor 1", inline: true },
    { name: "Campo 2", value: "Valor 2", inline: true },
    { name: "Campo 3", value: "Valor 3", inline: false }
  );

embed = discord.Embed(title="Ejemplo Campos", color=0x00ff00)
embed.add_field(name="Campo 1", value="Valor 1", inline=True)
embed.add_field(name="Campo 2", value="Valor 2", inline=True)
embed.add_field(name="Campo 3", value="Valor 3", inline=False)

---

4. Color y estilos

Forma	JS	Py
Hexadecimal	.setColor("#FF0000")	color=0xFF0000
Entero decimal	.setColor(16711680)	color=16711680

Nota: Discord.py acepta únicamente enteros o discord.Color.*.

---

5. Miniatura, Imagen, Pie de página, Autor

Elemento	JS	Py
Thumbnail	.setThumbnail("https://img.png")	embed.set_thumbnail(url="https://")
Image	.setImage("https://img.png")	embed.set_image(url="https://")
Footer	.setFooter({ text:"Pie", iconURL })	embed.set_footer(text="Pie", icon_url="...")
Author	.setAuthor({ name:"Autor", iconURL })	embed.set_author(name="Autor", icon_url="...")

Ejemplo completo de embed

const embed = new EmbedBuilder()
  .setTitle("Reporte Diario")
  .setURL("https://miapp.com/reporte")
  .setDescription("Resumen de estadísticas diarias")
  .setColor("#3498db")
  .setThumbnail("https://i.imgur.com/AfFp7pu.png")
  .addFields(
    { name: "Usuarios", value: "1,024", inline: true },
    { name: "Mensajes", value: "58,372", inline: true }
  )
  .setImage("https://i.imgur.com/0y0y0y0.png")
  .setFooter({ text: "Generado el", iconURL: "https://i.imgur.com/fxj2.png" })
  .setTimestamp();

channel.send({ embeds: [embed] });

embed = discord.Embed(
    title="Reporte Diario",
    url="https://miapp.com/reporte",
    description="Resumen de estadísticas diarias",
    color=0x3498db,
    timestamp=datetime.utcnow()
)
embed.set_thumbnail(url="https://i.imgur.com/AfFp7pu.png")
embed.add_field(name="Usuarios", value="1,024", inline=True)
embed.add_field(name="Mensajes", value="58,372", inline=True)
embed.set_image(url="https://i.imgur.com/0y0y0y0.png")
embed.set_footer(text="Generado el", icon_url="https://i.imgur.com/fxj2.png")

await ctx.send(embed=embed)

---

6. Comparativa JS ↔︎ Py

Característica	Discord.js	discord.py
Builder Fluent	Sí (Builder Pattern)	No
Instanciación rápida	new EmbedBuilder()	discord.Embed()
Conversión JSON	Sí (toJSON())	No
Tipos de color	Hex, int, Colors enum	int, discord.Color.*

---

7. Ejemplos Profesionales

Embed con campos dinámicos y gráficos

// Generar embed con datos API externa
import fetch from "node-fetch";

async function reportEmbed(channel) {
  const res = await fetch("https://api.example.com/stats");
  const data = await res.json();
  const embed = new EmbedBuilder()
    .setTitle("Estadísticas API")
    .setColor("#e91e63")
    .addFields(
      { name: "Activos", value: `${data.active}`, inline: true },
      { name: "Inactivos", value: `${data.inactive}`, inline: true }
    );
  channel.send({ embeds: [embed] });
}

# Embed dinámico con matplotlib
import matplotlib.pyplot as plt
import io

def generate_chart(data):
    plt.bar(["Activos","Inactivos"], [data["active"], data["inactive"]])
    buf = io.BytesIO()
    plt.savefig(buf, format="png")
    buf.seek(0)
    return buf

@bot.command()
async def report(ctx):
    data = await fetch_api()
    chart = generate_chart(data)
    file = discord.File(chart, filename="chart.png")
    embed = discord.Embed(title="Estadísticas API", color=0xff5722)
    embed.set_image(url="attachment://chart.png")
    await ctx.send(file=file, embed=embed)

AUDIO Y VOZ

Reproducción de audio, voz y TTS

Tabla de Contenidos

1. Introducción al Módulo de Voz

2. Instalación y Dependencias

3. Conexión a Canales de Voz

4. Reproducción de Audio Local y Streams

5. Text-to-Speech (TTS)

6. Filtros y Efectos

7. Comparativa JS ↔︎ Py

8. Ejemplos Completos

---

1. Introducción al módulo de voz

• Discord.js utiliza @discordjs/voice para manejar conexiones de voz y transmisión de audio.

• discord.py incluye el paquete voice en el extra discord.py[voice], basado en FFmpeg y Opus.

---

2. Instalación y Dependencias

Librería	JS	Py
Paquete principal	@discordjs/voice@0.15.x	Incluido en discord.py[voice]
FFmpeg	Instalar sistema (ffmpeg en PATH)	Igual
Opción Opcional	@discordjs/opus	PyNaCl

# JS
npm install @discordjs/voice @discordjs/opus

# Py
pip install discord.py[voice] pynacl

---

3. Conexión a canales de voz

[JS] – Conectar al canal de voz

import { joinVoiceChannel, VoiceConnectionStatus } from "@discordjs/voice";

const connection = joinVoiceChannel({
  channelId: voiceChannel.id,
  guildId: voiceChannel.guild.id,
  adapterCreator: voiceChannel.guild.voiceAdapterCreator,
  selfDeaf: false,
  selfMute: false
});

connection.on(VoiceConnectionStatus.Ready, () => {
  console.log("Conexión de voz lista");
});

[Py] – Conectar al canal de voz

voice_channel = discord.utils.get(ctx.guild.voice_channels, name="General")
vc = await voice_channel.connect()
print("Conexión de voz lista")

---

4. Reproducción de audio local y streams

Acción	JS (createAudioPlayer)	Py (vc.play)
Crear reproductor	createAudioPlayer()	No aplica (directo play)
Suscribir conexión	connection.subscribe(player)	vc.play(source)
Fuente local	createAudioResource("./audio.mp3")	discord.FFmpegPCMAudio("audio.mp3")
Fuente remoto (stream URL)	createAudioResource("https://...")	discord.FFmpegPCMAudio("https://...")

[JS] – Reproduce archivo local

import { createAudioPlayer, createAudioResource, joinVoiceChannel } from "@discordjs/voice";

const player = createAudioPlayer();
const resource = createAudioResource("./audio.mp3");
player.play(resource);
connection.subscribe(player);

player.on("error", error => console.error(error));

[Py] – Reproduce archivo local

from discord import FFmpegPCMAudio

vc.play(FFmpegPCMAudio("audio.mp3"))

---

5. Text-to-Speech (TTS)

• Discord.js envía TTS como flags en mensajes.

• discord.py similar, usando tts=True.

channel.send({ content: "Hola mundo", tts: true });

await ctx.send("Hola mundo", tts=True)

Para voces avanzadas se recomienda usar APIs externas (Google TTS, Amazon Polly).

---

6. Filtros y efectos

Ejemplo JS con FFmpeg Filters

import { createAudioResource } from "@discordjs/voice";

const resource = createAudioResource("audio.mp3", {
  inputType: StreamType.Arbitrary,
  inlineVolume: true,
  ffmpegArgs: ["-af", "bass=g=10"]
});

Ejemplo Py con FFmpeg Arguments

vc.play(FFmpegPCMAudio("audio.mp3", before_options="-af bass=g=10"))

---

7. Comparativa JS ↔︎ Py

Característica	Discord.js	discord.py
API dedicada	Módulo @discordjs/voice	Integrado en discord.py[voice]
Builder vs Función	createAudioResource	Directo FFmpegPCMAudio
Eventos de reproductor	AudioPlayerStatus	Callback after
Plugins de filtros	ffmpegArgs	before_options

---

8. Ejemplos Completos

Bot de música completo [JS]

// src/commands/music/play.js
import { SlashCommandBuilder } from "discord.js";
import { joinVoiceChannel, createAudioPlayer, createAudioResource } from "@discordjs/voice";

export const data = new SlashCommandBuilder()
  .setName("play")
  .setDescription("Reproduce una canción")
  .addStringOption(opt => opt.setName("url").setDescription("URL de YouTube").setRequired(true));

export async function execute(interaction) {
  const url = interaction.options.getString("url");
  const channel = interaction.member.voice.channel;
  if (!channel) return interaction.reply("Únete primero a un canal de voz");

  const connection = joinVoiceChannel({
    channelId: channel.id,
    guildId: interaction.guild.id,
    adapterCreator: interaction.guild.voiceAdapterCreator
  });

  const player = createAudioPlayer();
  const resource = createAudioResource(url, { inlineVolume: true });
  connection.subscribe(player);
  player.play(resource);

  await interaction.reply(`Reproduciendo: ${url}`);
}

Bot de música completo [Py]

# cogs/music.py
from discord.ext import commands
from discord import FFmpegPCMAudio

class Music(commands.Cog):
    def __init__(self, bot):
        self.bot = bot
        self.vc = None

    @commands.command()
    async def play(self, ctx, url: str):
        channel = ctx.author.voice.channel
        if not channel:
            return await ctx.send("Únete primero a un canal de voz")
        self.vc = await channel.connect()
        self.vc.play(FFmpegPCMAudio(url))
        await ctx.send(f"Reproduciendo: {url}")

async def setup(bot):
    await bot.add_cog(Music(bot))

TAREAS EN SEGUNDO PLANO

Programadores, trabajos cron y tareas en segundo plano

Tabla de Contenidos

1. Introducción a Background Tasks

2. discord.ext.tasks (Py)

3. Cron Jobs con node-cron (JS)

4. Timers nativos (setInterval)

5. Workers externos (BullMQ, RQ)

6. Comparativa JS ↔︎ Py

7. Ejemplos Completos

---

1. Introducción a las tareas en segundo plano

A menudo necesitas ejecutar tareas periódicas: limpiar cachés, enviar recordatorios, refrescar datos de API.

---

2. discord.ext.tasks (Python)

from discord.ext import tasks, commands

class MyCog(commands.Cog):
    def __init__(self, bot):
        self.bot = bot
        self.my_task.start()

    @tasks.loop(minutes=10)
    async def my_task(self):
        # Código a ejecutar cada 10 min
        print("Tarea ejecutada")

    @my_task.before_loop
    async def before(self):
        await self.bot.wait_until_ready()

async def setup(bot):
    await bot.add_cog(MyCog(bot))

• Decoradores disponibles: @tasks.loop(seconds, minutes, hours, count)

• Control de inicio/parada: my_task.start(), my_task.cancel()

---

3. Cron Jobs con node-cron (JavaScript)

import cron from "node-cron";

cron.schedule("0 * * * *", () => {
  console.log("Tarea cada hora");
});

• Sintaxis cron estándar (min, hour, day, month, weekday)

• Permite timezone, start/stop dinámicos

---

4. Timers nativos (JS)

// setInterval
setInterval(() => {
  console.log("Tarea cada 5 segundos");
}, 5000);

// setTimeout (único disparo)
setTimeout(() => {
  console.log("Tarea única tras 10s");
}, 10000);

---

5. Workers Externos

Librería JS	Librería Py	Uso Principal
BullMQ	RQ	Colas de trabajo distribuidas
Agenda	APScheduler	Jobs persistentes en DB
Bree	Celery	Tareas distribuidas + cron

// Ejemplo BullMQ
import { Queue } from "bullmq";
const myQueue = new Queue("my-queue");
await myQueue.add("jobName", { foo: "bar" }, { repeat: { cron: "*/5 * * * *" } });

# Ejemplo RQ
from rq import Queue
from redis import Redis
from rq_scheduler import Scheduler
from datetime import timedelta

redis_conn = Redis()
scheduler = Scheduler(queue_name="default", connection=redis_conn)
scheduler.schedule(
    scheduled_time=timedelta(seconds=60),
    func=my_function,
    interval=300
)

---

6. Comparativa JS ↔︎ Py

Característica	Discord.js	discord.py
Built-in Loop	No	Sí (discord.ext.tasks)
Cron integrado	No (npm)	No (extra libs)
Workers distribuidos	BullMQ, Agenda	Celery, RQ
Persistencia	Redis/Mongo + libs	Redis/RDB + libs

---

7. Ejemplos completos

[JS] – Limpieza de caché diaria a medianoche

import cron from "node-cron";

cron.schedule("0 0 * * *", () => {
  client.guilds.cache.forEach(guild => {
    guild.channels.cache.clear();
  });
  console.log("Caché de canales limpiada");
}, { timezone: "Europe/Madrid" });

[Py] – Recordatorio diario con APScheduler

from apscheduler.schedulers.asyncio import AsyncIOScheduler
from discord.ext import commands

bot = commands.Bot(command_prefix="!")

scheduler = AsyncIOScheduler()
@scheduler.scheduled_job("cron", hour=9, minute=0, timezone="Europe/Madrid")
async def daily_reminder():
    guild = bot.get_guild(GUILD_ID)
    channel = guild.get_channel(CHANNEL_ID)
    await channel.send("Buenos días, tiempo de reporte diario!")

scheduler.start()
bot.run(TOKEN)

BASES DE DATOS Y CACHÉ

SQLite, PostgreSQL, Redis, Prisma y SQLAlchemy

Tabla de Contenidos

1. Uso de SQLite para desarrollo ligero

2. Conexión a PostgreSQL

3. Caché con Redis

4. ORM Prisma (JS)

5. ORM SQLAlchemy (Py)

6. Comparativa JS ↔︎ Py

7. Ejemplos Completos

---

1. SQLite (Desarrollo y tests)

Característica	Discord.js (node-sqlite3)	discord.py (sqlite3)
Instalación	npm install sqlite3	Incluido en stdlib Python
Conexión	new sqlite3.Database('./db.sqlite')	sqlite3.connect('db.sqlite')
Promesas vs Sync	Usa callbacks o better-sqlite3	Sync (blobs)

JS Ejemplo

import sqlite3 from "sqlite3";
const db = new sqlite3.Database("./db.sqlite");
db.run("CREATE TABLE IF NOT EXISTS users (id TEXT, coins INTEGER)");

Py Ejemplo

import sqlite3
conn = sqlite3.connect("db.sqlite")
cursor = conn.cursor()
cursor.execute("CREATE TABLE IF NOT EXISTS users (id TEXT, coins INTEGER)")
conn.commit()

---

2. PostgreSQL (producción)

Cliente	JS (pg)	Py (asyncpg o psycopg)
Instalación	npm install pg	pip install asyncpg
Conexión (JS)	Pool({ connectionString })	await asyncpg.connect()
Query Templates	Template strings / pg-format	$1, $2 placeholders

JS Ejemplo

import { Pool } from "pg";
const pool = new Pool({ connectionString: process.env.DATABASE_URL });
const { rows } = await pool.query("SELECT * FROM users WHERE id=$1", [userId]);

Py Ejemplo

import asyncpg
conn = await asyncpg.connect(os.getenv("DATABASE_URL"))
rows = await conn.fetch("SELECT * FROM users WHERE id=$1", user_id)

---

3. Redis (Caché y rate limits)

Uso	JS (ioredis)	Py (redis-py)
Instalación	npm install ioredis	pip install redis
Conexión	new Redis(url)	Redis.from_url(url)
TTL	redis.set(key,val,'EX',60)	redis.set(key,val,ex=60)

JS Ejemplo

import Redis from "ioredis";
const redis = new Redis(process.env.REDIS_URL);
await redis.set(`cooldown:${userId}`, '1', 'EX', 10);

Py Ejemplo

import redis
r = redis.from_url(os.getenv("REDIS_URL"))
r.set(f"cooldown:{user_id}", "1", ex=10)

---

4. ORM Prisma (JavaScript/TypeScript)

Setup

npm install prisma --save-dev
npx prisma init

// schema.prisma
datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}
model User {
  id    String @id
  coins Int
}

npx prisma generate

Uso

import { PrismaClient } from "@prisma/client";
const prisma = new PrismaClient();
await prisma.user.upsert({
  where: { id: userId },
  update: { coins: { increment: 10 } },
  create: { id: userId, coins: 10 }
});
const user = await prisma.user.findUnique({ where: { id: userId } });

---

5. ORM SQLAlchemy (Python)

Setup

pip install sqlalchemy asyncpg

# models.py
from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
from sqlalchemy.orm import declarative_base, sessionmaker
from sqlalchemy import Column, String, Integer

DATABASE_URL = os.getenv("DATABASE_URL")
engine = create_async_engine(DATABASE_URL)
Base = declarative_base()
Session = sessionmaker(engine, class_=AsyncSession)

class User(Base):
    __tablename__ = "users"
    id = Column(String, primary_key=True)
    coins = Column(Integer, default=0)

Uso

async with Session() as session:
    user = await session.get(User, user_id)
    if not user:
        user = User(id=user_id, coins=10)
        session.add(user)
    else:
        user.coins += 10
    await session.commit()

---

6. Comparativa JS ↔︎ Py

Función	Discord.js Ecosistema	Discord.py Ecosistema
SQLite	sqlite3 / better-sqlite3	sqlite3 stdlib
PostgreSQL	pg	asyncpg, psycopg
ORM	Prisma	SQLAlchemy
Caché	Redis (ioredis)	redis-py

---

7. Ejemplos Completos

[JS] – Sistema de economía con Prisma

// src/commands/economy/coins.js
export const data = new SlashCommandBuilder()
  .setName("coins")
  .setDescription("Muestra o añade monedas")
  .addSubcommand(sub => sub.setName("balance").setDescription("Ver tu saldo"))
  .addSubcommand(sub => sub.setName("add").setDescription("Añadir monedas").addIntegerOption(opt=>opt.setName("amount").setRequired(true)));

export async function execute(inter) {
  const sub = inter.options.getSubcommand();
  const userId = inter.user.id;
  if (sub === "balance") {
    const user = await prisma.user.findUnique({ where: { id: userId } });
    return inter.reply(`Tienes ${user?.coins||0} monedas`);
  } else {
    const amt = inter.options.getInteger("amount");
    await prisma.user.upsert({
      where: { id: userId },
      update: { coins: { increment: amt } },
      create: { id: userId, coins: amt }
    });
    inter.reply(`Añadidas ${amt} monedas`);
  }
}

[Py] – Sistema de economía con SQLAlchemy

# cogs/economy.py
from discord.ext import commands
from models import Session, User

class Economy(commands.Cog):
    def __init__(self, bot):
        self.bot = bot

    @commands.command(name="balance")
    async def balance(self, ctx):
        async with Session() as session:
            user = await session.get(User, ctx.author.id)
            await ctx.send(f"Tienes {user.coins if user else 0} monedas")

    @commands.command(name="add")
    async def add(self, ctx, amount: int):
        async with Session() as session:
            user = await session.get(User, ctx.author.id)
            if not user:
                user = User(id=ctx.author.id, coins=amount)
                session.add(user)
            else:
                user.coins += amount
            await session.commit()
            await ctx.send(f"Añadidas {amount} monedas")

SHARDING Y ESCALABILIDAD

Distribución de carga y clusters

Tabla de Contenidos

1. ¿Qué es Sharding?

2. AutoShardedClient (JS)

3. Sharding Manual (JS)

4. ShardBot (Py)

5. Clusters y Balanceo

6. Comparativa JS ↔︎ Py

7. Ejemplos Prácticos

---

1. ¿Qué es Sharding?

El sharding divide instancias del bot por grupos de servidores para sortear límites de 2k servidores por conexión Gateway y distribuir carga.

---

2. AutoShardedClient (Discord.js)

import { AutoShardedClient } from "discord.js";

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

client.on("shardReady", shardId => {
  console.log(`Shard ${shardId} listo`);
});

• Detecta automáticamente la cantidad óptima de shards.

• Eventos: shardReady, shardDisconnect, shardError.

---

3. Sharding manual (Discord.js)

import { ShardingManager } from "discord.js";
import dotenv from "dotenv";
dotenv.config();

const manager = new ShardingManager("./src/index.js", {
  totalShards: "auto",
  token: process.env.DISCORD_TOKEN
});

manager.spawn();

manager.on("shardCreate", shard => console.log(`Shard ${shard.id} creado`));

• Permite control fino de spawn, respawn y comunicación IPC.

---

4. Sharding en discord.py

from discord.ext import commands
import os

bot = commands.AutoShardedBot(command_prefix="!", intents=discord.Intents.default())

@bot.event
async def on_ready():
    print(f"Bot listo en shard {bot.shard_id}/{bot.shard_count}")

bot.run(TOKEN)

• AutoShardedBot maneja shards automáticamente.

• Propiedades: bot.shard_id, bot.shard_count.

---

5. Clusters y balanceo

Clusters con PM2 (JS)

pm2 start src/index.js -i max --name "discord-bot"

• -i max crea tantos instancias como núcleos CPU.

• PM2 maneja auto-restart y logs.

Clusters con multiprocessing (Py)

import multiprocessing
from mybot import run_bot

if __name__ == "__main__":
    processes = []
    for _ in range(multiprocessing.cpu_count()):
        p = multiprocessing.Process(target=run_bot)
        processes.append(p)
        p.start()
    for p in processes:
        p.join()

---

6. Comparativa JS ↔︎ Py

Aspecto	Discord.js	discord.py
Auto-sharding nativo	AutoShardedClient	AutoShardedBot
Sharding manual	ShardingManager	No nativo (workers)
Clusters múltiples	PM2, Docker autoscaling	multiprocessing, Celery

---

7. Ejemplos prácticos

[JS] – Comunicación entre shards

manager.on("shardCreate", shard => {
  shard.on("message", msg => {
    console.log(`Mensaje del shard ${shard.id}: ${msg}`);
  });
});
client.shard.broadcastEval('this.guilds.cache.size');

[Py] – Monitor de shards

@bot.event
async def on_shard_ready(shard_id):
    print(f"Shard {shard_id} listo")

SEGURIDAD Y MEJORES PRÁCTICAS

Protección de tokens, permisos e intentos

Tabla de Contenidos

1. Gestión de Tokens

2. Permisos y Roles

3. Intents Privilegiados

4. Rate Limits y Manejo

5. Validación de Datos de Usuario

6. Seguridad de Dependencias

7. Ejemplos de Buenas Prácticas

---

1. Gestión de tokens

• Mantén el token en variables de entorno (.env).

• Nunca subas tokens a repositorios públicos.

• Usa herramientas como GitGuardian para escaneo automático.

# .env
DISCORD_TOKEN=xxxxx

# Ignorar .env
.env

• Para regenerar token en Discord Developer Portal: Bot → Regenerate.

---

2. Permisos y roles

Permiso	JS (PermissionsBitField)	Py (discord.Permissions)
Administrador	PermissionsBitField.Flags.Administrator	discord.Permissions(administrator=True)
Leer mensajes	ViewChannel	read_messages=True
Enviar mensajes	SendMessages	send_messages=True

// Verificar permiso en JS
if (!message.member.permissions.has(PermissionsBitField.Flags.KickMembers)) {
  return message.reply("No tienes permiso para usar este comando.");
}

# Verificar permiso en Py
@commands.has_permissions(kick_members=True)
@commands.command()
async def kick(ctx, member: discord.Member):
    await ctx.guild.kick(member)

---

3. Intentos privilegiados

• Habilita Server Members Intent y Message Content Intent en Portal.

• Úsalos solo si es imprescindible, para evitar abusos.

Intent	JS BitField	Py Attribute
Server Members Intent	GuildMembers	intents.members=True
Message Content Intent	MessageContent	intents.message_content=True

---

4. Rate limits y manejo

• Discord aplica rate limits por ruta.

• Usa métodos con retry/backoff.

JS

import pRetry from "p-retry";

await pRetry(() => client.api.channels(channelId).messages.post({ data }), {
  retries: 5,
  minTimeout: 1000
});

Py

import asyncio

async def safe_api_call(coro, retries=5):
    for i in range(retries):
        try:
            return await coro()
        except discord.HTTPException as e:
            if e.status == 429:
                await asyncio.sleep(e.retry_after)
            else:
                raise

---

5. Validación de datos de usuario

• Sanitiza entradas para evitar inyección de comandos.

• Limita longitudes de strings y valores numéricos.

const arg = args[0];
if (!/^[a-z0-9]+$/i.test(arg)) {
  return message.reply("Argumento inválido.");
}

@commands.command()
async def roll(ctx, sides: int):
    if sides < 2 or sides > 100:
        return await ctx.send("Valor fuera de rango.")
    await ctx.send(random.randint(1, sides))

---

6. Seguridad de dependencias

• Ejecuta npm audit / pip-audit.

• Usa herramientas como Snyk.

• Bloquea dependencias con versiones fijas (package-lock.json / requirements.txt).

---

7. Ejemplos de buenas prácticas

• Desafío: Evitar leaks de información en errores.

try {
  // código
} catch (err) {
  console.error(err);
  message.reply("Error interno: contacta al administrador.");
}

@bot.event
async def on_command_error(ctx, error):
    if isinstance(error, commands.CheckFailure):
        await ctx.send("No tienes permiso.")
    else:
        print(error)
        await ctx.send("Error interno.")

DESPLIEGUE Y HOSTING

Railway, Supabase, VPS, Docker, Cloudflare Tunnels y CI/CD

Tabla de Contenidos

1. Despliegue en VPS (Ubuntu)

2. Railway y Supabase

3. Docker Compose (repaso)

4. Cloudflare Tunnels

5. CI/CD con GitHub Actions

6. Monitoreo y Logs

7. Escalado Automático

---

1. VPS con Ubuntu 22.04

Preparación del Servidor

# Conexión SSH
ssh root@tu_ip

# Actualizar sistema
apt update && apt upgrade -y

# Instalar dependenicas
apt install git curl build-essential ffmpeg python3 python3-pip nodejs npm -y

Configuración de usuario

adduser botuser
usermod -aG sudo botuser
su - botuser

Despliegue manual

# Clonar repositorio
git clone https://github.com/tu_usuario/mi-bot.git
cd mi-bot

# Variables de entorno
cp .env.example .env

# Instalar dependencias
# JS
npm ci
# Py
pip install -r requirements.txt

# Iniciar con pm2 / systemd
pm2 start src/index.js --name bot-js
pm2 start main.py --interpreter=python3 --name bot-py

---

2. Railway & Supabase

Servicio	JS	Py
Railway	railway up automatiza deploy Docker	Igual
Supabase	Hosting de Functions (Node)	Functions Python (Edge Functions)

---

3. Docker Compose (Resumen)

Uso de docker-compose.yml definido en 01-instalacion.

docker-compose up -d --build

---

4. Cloudflare Tunnels

# Instalar Cloudflared
wget https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64
chmod +x cloudflared
sudo mv cloudflared /usr/local/bin/

# Iniciar túnel
cloudflared tunnel --url http://localhost:3000 --name bot-tunnel

---

5. CI/CD con GitHub Actions

# .github/workflows/deploy.yml
name: Deploy Bot

on:
  push:
    branches: [main]

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Set up Node.js
        uses: actions/setup-node@v3
        with: node-version: '18'
      - name: Install dependencies
        run: npm ci
      - name: Test
        run: npm test
      - name: Deploy to Railway
        uses: railwayapp/cli-action@v1
        env:
          RAILWAY_TOKEN: ${{ secrets.RAILWAY_TOKEN }}

---

6. Monitoreo y Logs

• PM2 Dashboard

pm2 monit

• Logrotate Configurar /etc/logrotate.d/bot para rotar logs.

• Integración con Sentry

npm install @sentry/node

---

7. Escalado Automático

• Horizontal: Kubernetes / Docker Swarm

• Vertical: Aumentar recursos VPS o plan Railway

---

TESTING Y DEBUGGING

Pruebas unitarias, registros y perfil

Contenidos

1. Logging Avanzado

2. Tests con Jest (JS) y Pytest (Py)

3. Coverage

4. Debugger en VSCode

5. Profile de Rendimiento

---

1. Registros avanzados

Librería	JS (winston)	Py (loguru)
Instalación	npm install winston	pip install loguru
Configuración JS

import winston from "winston";
export const logger = winston.createLogger({
  level: "debug",
  transports: [new winston.transports.Console()]
});

from loguru import logger
logger.add("logs/{time}.log", rotation="1 day")

---

2. Pruebass

JS con Jest

npm install --save-dev jest

// tests/ping.test.js
import { Client } from "discord.js";
test("ping responde pong", () => {
  const result = pingFunction();
  expect(result).toBe("Pong!");
});

Py con Pytest

pip install pytest

# tests/test_ping.py
from main import ping
def test_ping():
    assert ping() == "Pong!"

---

3. Coverage

• JS: jest --coverage

• Py: pytest --cov=.

---

4. Debugger VSCode

// .vscode/launch.json
{
  "configurations": [
    {
      "type": "node",
      "request": "launch",
      "name": "Debug JS",
      "program": "${workspaceFolder}/src/index.js"
    },
    {
      "type": "python",
      "request": "launch",
      "name": "Debug Py",
      "program": "${workspaceFolder}/main.py"
    }
  ]
}

---

5. Perfil de rendimiento

• Uso de clinic.js (JS)

• Uso de cProfile (Py)

---

EJEMPLOS COMPLETOS

8 Proyectos Listos para Producción

1. Bot de Música

2. Sistema de Tickets

3. Panel de Administración

4. Trivia

5. Economía

6. Moderación

7. Dashboard Web

8. API Gateway

Cada proyecto contiene estructura de carpetas, Dockerfile, tests y despliegue CI/CD.

---

REFERENCIA API DISCORD.JS

Clases, métodos, propiedades y eventos (v14.21.x)

Clases principales

Clase	Descripción
Client	Cliente principal, conecta al Gateway
Guild	Representa un servidor Discord
TextChannel	Canal de texto
VoiceChannel	Canal de voz
Message	Mensaje en un canal
Interaction	Eventos de interacción (slash, buttons, selects)

Métodos clave

Método	Descripción
client.login()	Autentica con el token
guild.channels.cache	Collection de canales
message.reply()	Responde a un mensaje
interaction.deferReply()	Retraso de respuesta

Propiedades comunes

Propiedad	Descripción
client.user	Instancia de User (bot)
guild.id	ID del servidor
message.author	Usuario que envió el mensaje
interaction.options	Opciones del comando slash

Eventos disponibles

Evento	Descripción
ready	Cliente listo
messageCreate	Nuevo mensaje
interactionCreate	Nueva interacción
guildMemberAdd	Nuevo miembro

(Para la lista exhaustiva de 200+ eventos y métodos, consulta la documentación oficial o usa discord.js.org/docs)

---

REFERENCIA API DISCORD.PY

Clases, métodos, propiedades y eventos (v2.5.2)

Clases principales

Clase	Descripción
Client / Bot	Cliente principal
Guild	Servidor Discord
TextChannel	Canal de texto
VoiceChannel	Canal de voz
Message	Mensaje en canal
Interaction	Interacción con comandos/aplicaciones

Métodos clave

Método	Descripción
bot.run()	Autentica y conecta al Gateway
guild.channels	Lista de canales
ctx.send()	Envia un mensaje de texto
interaction.response	Métodos de respuesta de Slash Commands

Propiedades comunes

Propiedad	Descripción
bot.user	Bot User
guild.id	ID del servidor
ctx.author	Autor del comando
interaction.data	Datos de la interacción

Eventos disponibles

Evento	Descripción
on_ready	Bot listo
on_message	Mensaje recibido
on_interaction	Interacción recibida
on_member_join	Miembro ingresó

(Para la lista completa de 150+ clases y 300+ métodos, consulta la documentación oficial en discordpy.readthedocs.io)