IA Cheatsheets

🚀 Node.js Cheatsheet Completo 🚀

Node.js es un entorno de ejecución de JavaScript basado en el motor V8 de Chrome. Utiliza un modelo de E/S sin bloqueo y basado en eventos, lo que lo hace ligero y eficiente, ideal para construir aplicaciones de red escalables.

1. 🌟 Conceptos Clave

2. 🛠️ Configuración Inicial

  1. Instalar Node.js: Descarga e instala el instalador desde nodejs.org. Incluye npm.
  2. Verificar Instalación: Abre tu terminal/CMD y escribe: 
    node -v
npm -v
  3. Ejecutar un Archivo JavaScript: Guarda tu código en un archivo .js (ej. app.js) y ejecútalo: 
    node app.js

3. 📦 Gestión de Paquetes (NPM)

4. 🧩 Módulos (Organización del Código)

4.1. CommonJS (Por defecto para .js a menos que se configure type: "module")

4.2. ES Modules (Para .mjs o cuando type: "module" en package.json)

5. ⚡ Programación Asíncrona

5.1. Callbacks (Enfoque Tradicional)

const fs = require('fs');

fs.readFile('file.txt', 'utf8', (err, data) => {
  if (err) {
    console.error('Error al leer el archivo:', err);
    return;
  }
  console.log('Contenido del archivo:', data);
});
console.log('Lectura de archivo iniciada (asíncrono)...'); // Se ejecuta antes del callback

5.2. Promesas (Promise)

const fs = require('fs/promises'); // Usa la versión de promesas del módulo fs

fs.readFile('file.txt', 'utf8')
  .then(data => {
    console.log('Contenido del archivo (Promise):', data);
  })
  .catch(err => {
    console.error('Error al leer el archivo (Promise):', err);
  });

5.3. async/await (Sintaxis Moderna)

const fs = require('fs/promises');

async function readMyFile() {
  try {
    const data = await fs.readFile('file.txt', 'utf8');
    console.log('Contenido del archivo (async/await):', data);
  } catch (err) {
    console.error('Error al leer el archivo (async/await):', err);
  }
}
readMyFile();

5.4. Event Emitters (events module)

Para manejar eventos personalizados.

const EventEmitter = require('events');
class MyEmitter extends EventEmitter {}

const myEmitter = new MyEmitter();
myEmitter.on('event', (data) => { // Escucha el evento 'event'
  console.log('Un evento ha ocurrido:', data);
});

myEmitter.emit('event', { id: 1, message: 'Hola!' }); // Emite el evento

6. 📚 Módulos Core de Node.js

Node.js viene con un conjunto de módulos incorporados.

6.1. fs (File System) - Operaciones de Archivos

const fs = require('fs'); // Versión con Callbacks
// const fs = require('fs/promises'); // Versión con Promesas

// Leer archivo
fs.readFile('input.txt', 'utf8', (err, data) => { /* ... */ }); // Callback
// await fs.readFile('input.txt', 'utf8'); // Promise

// Escribir archivo (crea o sobrescribe)
fs.writeFile('output.txt', 'Hola desde Node.js', (err) => { /* ... */ });
// await fs.writeFile('output.txt', 'Hola desde Node.js');

// Añadir a archivo
fs.appendFile('log.txt', 'Nuevo log\n', (err) => { /* ... */ });

// Crear directorio
fs.mkdir('my_folder', (err) => { /* ... */ });

// Eliminar archivo
fs.unlink('temp.txt', (err) => { /* ... */ });

// Comprobar si existe
fs.access('file.txt', fs.constants.F_OK, (err) => {
  console.log(`${err ? 'no existe' : 'existe'} el archivo`);
});

6.2. path - Rutas de Archivos y Directorios

const path = require('path');

const filePath = path.join(__dirname, 'data', 'file.txt'); // Construye una ruta segura
console.log(filePath); // /ruta/a/tu/app/data/file.txt

console.log(path.basename(filePath)); // file.txt
console.log(path.dirname(filePath));  // /ruta/a/tu/app/data
console.log(path.extname(filePath));  // .txt
console.log(path.parse(filePath));    // Objeto con root, dir, base, ext, name

6.3. http - Servidor Web Básico

const http = require('http');

const server = http.createServer((req, res) => {
  if (req.url === '/') {
    res.writeHead(200, { 'Content-Type': 'text/html' });
    res.end('<h1>Página de Inicio</h1>');
  } else if (req.url === '/api/data') {
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({ message: 'Datos de la API', timestamp: Date.now() }));
  } else {
    res.writeHead(404, { 'Content-Type': 'text/html' });
    res.end('<h1>404 Not Found</h1>');
  }
});

const PORT = process.env.PORT || 3000;
server.listen(PORT, () =&gt; console.log(`Servidor corriendo en http://localhost:${PORT}`));

6.4. url - Parsear URLs

const url = require('url');
const address = 'http://localhost:8080/default.html?year=2023&month=february';
const q = url.parse(address, true); // `true` para parsear query string

console.log(q.host);     // 'localhost:8080'
console.log(q.pathname); // '/default.html'
console.log(q.search);   // '?year=2023&month=february'
console.log(q.query);    // { year: '2023', month: 'february' }

6.5. process - Información del Proceso Actual

console.log(process.platform); // 'win32', 'darwin', 'linux'
console.log(process.version);  // Versión de Node.js
console.log(process.cwd());    // Directorio de trabajo actual

// Acceder a variables de entorno
console.log(process.env.NODE_ENV); // 'development', 'production', etc.

// Argumentos de línea de comandos
// node app.js arg1 arg2
process.argv.forEach((val, index) =&gt; {
  console.log(`${index}: ${val}`); // 0: node, 1: app.js, 2: arg1, 3: arg2
});

// Salir del proceso
// process.exit(0); // Exit con éxito
// process.exit(1); // Exit con error

7. 🌐 Desarrollo Web con Express.js (Framework Popular)

Express.js es un framework web minimalista y flexible para Node.js que proporciona un conjunto robusto de características para aplicaciones web y APIs.

  1. Instalación: npm install express

  2. Servidor Básico:

    // server.js
const express = require('express');
const app = express();
const port = 3000;

// Middleware: para parsear JSON en el cuerpo de las solicitudes
app.use(express.json());
// Middleware: para servir archivos estáticos (ej. HTML, CSS, JS del frontend)
app.use(express.static('public'));

// Ruta GET
app.get('/', (req, res) =&gt; {
  res.send('¡Hola desde Express!');
});

// Ruta con parámetro
app.get('/users/:id', (req, res) =&gt; {
  const userId = req.params.id;
  res.json({ message: `Obteniendo usuario con ID: ${userId}` });
});

// Ruta POST
app.post('/api/products', (req, res) =&gt; {
  const product = req.body; // Acceder al cuerpo JSON
  console.log('Producto recibido:', product);
  res.status(201).json({ message: 'Producto creado', product });
});

// Ruta 404 (Middleware de manejo de errores al final)
app.use((req, res) =&gt; {
  res.status(404).send('Ruta no encontrada');
});

app.listen(port, () =&gt; {
  console.log(`Express app listening at http://localhost:${port}`);
});

8. 🚨 Manejo de Errores

9. 💡 Buenas Prácticas y Consejos

Este cheatsheet te proporciona una referencia completa de Node.js, cubriendo sus conceptos esenciales, operaciones de archivos, desarrollo web básico, gestión de paquetes y las mejores prácticas para construir aplicaciones escalables y eficientes.