Glosario de Node.js de la A a la Z — Node.js

Glosario de Node.js — 115 definiciones

Todos los términos definidos en las 23 secciones de la guía, por orden alfabético.
Consejo: pulsa Ctrl + F para buscar un término en la página.

.on() / .emit(): on(evento, callback): registrar un oyente. emit(evento, datos): disparar el evento (todos sus oyentes se llaman con los datos).
.once() / .off(): once(): escuchar un evento una sola vez (desuscripción automática). off()/removeListener(): dejar de escuchar un evento.
.pipe(): Conecta un stream de lectura a un stream de escritura: los datos fluyen automáticamente de uno a otro, fragmento a fragmento, con gestión del caudal.
«Funciona en mi máquina»: El problema que resuelve Docker: una aplicación depende de su entorno y puede fallar en otro; el contenedor empaqueta su entorno y funciona siempre igual.
Adopción progresiva: TS se aprende por etapas (tipado ligero y luego avanzado); como superconjunto de JS, tu dominio de JavaScript se reutiliza — añades los tipos por encima.
API + front separado (SPA): Alternativa moderna: Node expone una API REST (JSON) consumida por un front separado (React/Vue/Angular) que gestiona la visualización en el navegador.
API REST: Estilo de arquitectura de API web: exponer recursos (URL claras) manipulados mediante la semántica HTTP, respuestas en JSON con códigos de estado adecuados.
async/await: Sintaxis moderna (azúcar sobre Promises): `await` espera el resultado de una operación asíncrona sin bloquear; el código asíncrono se lee como síncrono. Errores con try/catch.
Asíncrono no bloqueante: Modelo donde las operaciones lentas (archivos, red, base) no bloquean el programa: Node registra una retrollamada y sigue haciendo otra cosa mientras espera.
Asíncrono vs síncrono (fs): Lo asíncrono (no bloqueante) es preferible en servidor para no bloquear el bucle de eventos; lo síncrono (Sync) se reserva para scripts/configuración al arrancar.
Autenticación vs autorización: Autenticación: QUIÉN es el usuario (401 si no está autenticado). Autorización: si TIENE DERECHO a realizar esa acción (403 si no está autorizado).
Base de datos / persistencia: Sistema que guarda los datos de forma duradera (usuarios, productos…). Dos familias: NoSQL (MongoDB) y SQL/relacional (sección 3-4).
Beneficios de Docker: Reproducibilidad (idéntico en todas partes), aislamiento (sin conflictos), portabilidad (cualquier host Docker), facilidad de despliegue, onboarding rápido (docker compose up).
Beneficios de TypeScript: Errores detectados en compilación, autocompletado/herramientas superiores, documentación implícita (los tipos describen), robustez y mantenibilidad en proyectos grandes.
Beneficios de los tests: Confianza (el código hace lo que debe), no regresión (detectar lo que rompe un cambio), documentación (comportamiento esperado), mejor diseño (código testeable = mejor estructurado).
Buenas prácticas REST: URL coherentes en plural, métodos/códigos de estado correctos, gestión de errores limpia, paginación, versionado (/api/v1/), respuesta JSON estructurada.
Bucle de eventos (event loop): Mecanismo central que orquesta la ejecución: lanza operaciones lentas en segundo plano y retrollama a las funciones cuando llegan los resultados.
Buffer: Zona de memoria bruta de bytes para manipular datos binarios (archivos, red) que JavaScript no tiene de forma nativa; los streams transportan a menudo Buffers.
Callback: Función pasada como argumento, llamada cuando termina una operación asíncrona. Convención Node «error-first»: primer argumento = error (null si OK), luego el resultado.
Callback hell: Anidamiento ilegible de callbacks al encadenar operaciones asíncronas dependientes; problema que resuelven las Promises y async/await.
Lo que simplifica Express: El servidor nativo gestiona todo a mano (enrutamiento con if, parsing del cuerpo, cabeceras); Express aporta enrutamiento, parsing, middlewares — pero se apoya en el módulo http.
Ruta de módulo: Local: empieza por ./ o ../ (archivos del proyecto). Nombre solo: módulo nativo (fs) o paquete npm de node_modules (express).
CI/CD (GitHub Actions): Automatizar el camino código → producción: CI (en cada push, testear/verificar), CD (desplegar automáticamente si las verificaciones pasan). GitHub Actions crea estos pipelines.
Clustering: Lanzar varias instancias de la aplicación (una por núcleo, vía módulo cluster o PM2) que se reparten las peticiones; aprovecha todos los núcleos (Node es mono-hilo).
CommonJS (CJS): Sistema de módulos histórico de Node: exportar con `module.exports`, importar con `require()`. Síncrono, simple, omnipresente en el ecosistema npm.
Compilación (tsc) / tsconfig: TS no se ejecuta directamente: el compilador (tsc) verifica y transforma los .ts en .js. Configurado vía tsconfig.json; ts-node ejecuta TS directamente en dev.
console.log(): Función para mostrar en la terminal (equivalente a «print»); herramienta básica para ver valores, depurar y trazar la ejecución.
const / let (vs var): const: constante no reasignable (preferir). let: variable reasignable. Ambas de ámbito de bloque. `var` debe evitarse (ámbito confuso).
CRUD: Las cuatro operaciones básicas: Create (crear), Read (leer), Update (actualizar), Delete (eliminar); en Mongoose, métodos asíncronos (await).
dependencies vs devDependencies / node_modules: dependencies: necesarias en producción. devDependencies: útiles solo en dev (-D). node_modules: carpeta de paquetes instalados (no versionada, regenerable).
Despliegue: Hacer que la aplicación se ejecute en un servidor accesible en Internet (en lugar de localhost); mediante una plataforma PaaS (simple) o un VPS/cloud (más control y responsabilidades).
Desestructuración: Extracción de valores de objetos/arrays en una línea: `const { nombre } = obj;` o `const [a, b] = arr;`. Omnipresente (imports, datos).
Docker / contenedorización: Herramienta que empaqueta una aplicación CON todo su entorno (Node, dependencias, config) en un contenedor aislado y portable, que se ejecuta de forma idéntica en todas partes.
Docker Compose: Archivo docker-compose.yml que define varios contenedores (app Node + base + caché…) y sus relaciones, lanzados juntos (docker compose up); describe toda la pila.
emit / on / broadcast: emit(evento, dato): enviar. on(evento, callback): recibir. El servidor emite hacia un cliente, hacia TODOS (io.emit, broadcast) o hacia grupos (rooms).
Errores esperados vs inesperados: Esperados: recurso no encontrado (404), validación fallida (400) — gestionados explícitamente. Inesperados: bugs (500). Además: gestionar errores async (try/catch alrededor de los await).
error-first / try-catch: Gestión de errores: error como primer argumento de callbacks; .catch() para Promises; try/catch alrededor de los await.
ES Modules (ESM): Sistema de módulos estándar del lenguaje: exportar con `export`, importar con `import`. La dirección del futuro; activado vía .mjs o "type":"module" en package.json.
Esenciales de producción: Variables de entorno (config + secretos, nunca en el código/Git), HTTPS (cifrado), logs y monitorización (vigilar), entornos separados (dev/staging/prod).
Evento error: Evento especial: un emisor que emite 'error' sin oyente hace fallar el programa — siempre escuchar los errores.
EventEmitter: Clase nativa (módulo events) en el corazón del modelo dirigido por eventos de Node; muchos objetos nativos (servidor HTTP, streams…) heredan de ella.
Ejecutar un archivo: La forma principal de trabajar: escribir tu código en un archivo .js y lanzarlo con `node archivo.js` (Node ejecuta todo el archivo).
Express: Framework web de referencia para Node (minimalista, flexible), construido sobre el módulo http; simplifica enrutamiento, parsing y gestión de peticiones. Base de la mayoría de apps Node.
express.Router(): Herramienta que agrupa rutas por recurso en archivos separados (router users, products…) montados en la app; organiza una API que crece.
Archivos estáticos: Recursos fijos servidos al navegador (CSS, imágenes, JS del cliente, fuentes); servidos simplemente con el middleware express.static('public').
Función flecha (arrow): Sintaxis concisa `(a) => ...` para escribir funciones, muy usada para callbacks; sin `this` propio (evita trampas).
fs (file system): Módulo de lectura/escritura de archivos y carpetas; funciones en versión asíncrona (preferible, fs.promises + await) o síncrona (Sync, bloqueante).
Gestión de errores centralizada: Middleware Express especial (err, req, res, next) colocado al final, que recibe los errores y devuelve una respuesta coherente (código correcto, mensaje claro, sin fuga de detalles sensibles).
Globales Node vs navegador: Node NO tiene window/document/DOM (no hay página web); ofrece process, __dirname, __filename, global y acceso al sistema.
Hash de contraseñas (bcrypt): Nunca se almacena una contraseña en claro, sino su hash unidireccional (bcrypt, con salt, deliberadamente lento). Al iniciar sesión, se compara sin descifrar.
http (módulo nativo): Módulo que permite crear un servidor web sin dependencia: http.createServer() con una función llamada en cada petición, luego .listen(puerto).
Intensivo en I/O vs intensivo en CPU: Node destaca para tareas de entrada/salida (servidores, API, tiempo real); es menos adecuado para cálculos pesados prolongados (mono-hilo).
Imagen / Dockerfile / contenedor: Imagen: plantilla congelada de la app + entorno, definida por un Dockerfile (receta de construcción). Contenedor: instancia en ejecución de una imagen.
Inyección SQL: Fallo crítico: NUNCA concatenar datos de usuario en una consulta SQL; usar consultas parametrizadas (los ORM protegen automáticamente).
JWT (JSON Web Token): Token firmado criptográficamente emitido tras el login, reenviado por el cliente en cada petición (cabecera Authorization) y verificado por el servidor; sin estado, popular para API.
LTS vs Current: LTS (Long Term Support, versiones pares): estable y mantenida largo tiempo, preferible. Current (impar): más reciente pero menos estable, para probar novedades.
map / filter / reduce: Métodos modernos de arrays para transformar, filtrar y agregar colecciones de forma funcional; la forma moderna de procesar datos.
Métodos y códigos HTTP: Métodos: GET (leer), POST (crear), PUT/PATCH (modificar), DELETE (eliminar). Códigos: 200 OK, 201 Created, 400/401/404 (errores cliente), 500 (error servidor).
Middleware: Función (req, res, next) que se ejecuta durante el procesamiento de una petición; puede inspeccionar/modificar, ejecutar código y luego next() para pasar al siguiente. EL concepto clave de Express.
Caché (Redis): Almacenar en memoria (o en Redis) los resultados costosos (consultas frecuentes, cálculos) para no rehacerlos; a menudo la palanca de rendimiento más impactante.
Módulo: Archivo separado con una responsabilidad, que exporta lo que pone a disposición e importa lo que necesita; base de la organización del código.
Módulos nativos (built-in): Bibliotecas integradas en Node (sin instalación) que dan acceso al sistema: fs, path, os, http, crypto, events, stream… Importadas por su nombre.
MongoDB (NoSQL orientado a documentos): Base que almacena DOCUMENTOS (estructuras tipo JSON/BSON) agrupados en COLECCIONES, sin esquema rígido; cercana a los objetos JS, popular con Node.
Mongoose (ODM): Object Document Mapper que añade una capa práctica sobre MongoDB: esquemas (estructura + validación), modelos (métodos de manipulación).
Motor de plantillas (vistas): Herramienta que genera HTML dinámico a partir de plantillas (HTML + lógica: variables, bucles, condiciones) y datos; EJS, Handlebars, Pug…
Motor V8: Motor JavaScript de Google Chrome (escrito en C++) que compila y ejecuta JS muy rápido; el corazón de Node.js.
MVC / separación de responsabilidades: Modelos (datos), Controladores (lógica de procesamiento), Rutas (URL que delegan a controladores); separa las preocupaciones para un código mantenible y evolutivo.
Node + npm: La instalación de Node trae el ejecutable Node (que lanza tus scripts) Y npm (el gestor de paquetes), instalados juntos.
Node.js: Entorno de ejecución que permite ejecutar JavaScript fuera del navegador (lado servidor), basado en el motor V8 más una biblioteca de acceso al sistema.
npm y el registro: Gestor de paquetes de Node, que da acceso al mayor registro open source del mundo (cientos de miles de bibliotecas reutilizables).
nvm (Node Version Manager): Herramienta que permite instalar varias versiones de Node y cambiar entre ellas; valiosa cuando los proyectos exigen versiones distintas.
ORM (Prisma, Sequelize): Object-Relational Mapper que hace corresponder tablas y objetos JS y genera el SQL; manipulación de objetos/métodos en lugar de SQL crudo (legible, seguro, productivo).
os: Módulo de acceso a información del sistema: plataforma, procesadores (os.cpus), memoria, carpetas estándar (homedir, tmpdir).
PaaS (Render, Railway…): Plataformas que simplifican el despliegue: conectas tu repo Git, ellas construyen, lanzan, gestionan servidor/HTTPS/escalado; nivel gratuito habitual. Ideales para empezar.
package-lock.json: Archivo que bloquea las versiones EXACTAS instaladas; garantiza que todos instalen las mismas versiones (reproducibilidad).
package.json: Manifiesto del proyecto: nombre, versión, dependencias, scripts, metadatos. Creado con `npm init`; punto de referencia de todo proyecto Node.
path: Módulo de manipulación portable de rutas (path.join, resolve, basename, extname…): gestiona diferencias de separador entre sistemas (/ vs \).
Pipeline de middlewares: Cadena de funciones que atraviesa cada petición; enrutamiento, parsing (express.json), auth, gestión de errores son todos middlewares (app.use o por ruta).
Prisma (moderno): ORM apreciado: esquema declarativo (schema.prisma), migraciones (versionar el esquema), cliente generado y TIPADO (autocompletado, seguridad de tipos — excelente con TypeScript).
process: Objeto global de Node que da acceso al proceso: argumentos (process.argv), variables de entorno (process.env), salida (process.exit()).
Perfilado / medir antes de optimizar: Identificar los verdaderos cuellos de botella midiendo antes de optimizar (regla de oro); evitar optimizar a ciegas o prematuramente.
Programación dirigida por eventos: Modelo donde los objetos emiten eventos y otras partes del código reaccionan escuchando; desacoplamiento por el nombre del evento.
Promise: Objeto que representa un valor futuro (resultado de una operación asíncrona). Tres estados: pending, fulfilled (éxito), rejected (error). Gestionado vía .then() y .catch().
Cuándo usar streams: En cuanto se procesan grandes volúmenes (archivos grandes, subidas/descargas, flujos de red); para archivos pequeños, readFile clásico basta.
REPL: Entorno interactivo que se abre escribiendo `node` solo: lee/evalúa/imprime JavaScript línea a línea. Ideal para experimentar sin crear archivo.
req (request): Objeto de la petición entrante: método (req.method: GET/POST…), ruta (req.url), cabeceras (req.headers) y cuerpo (leído como stream para POST).
req / res enriquecidos: req: req.params (ruta), req.query (query string), req.body (cuerpo). res: res.json(data), res.status(201).json(...), res.send, res.redirect.
require vs import: require() (CommonJS) e import (ESM) son las dos sintaxis de importación; hay que entender ambas porque coexisten en el código real.
res (response): Objeto de construcción de la respuesta: estado (res.statusCode), cabeceras (res.setHeader), cuerpo (res.write/res.end).
res.render(): Método Express que renderiza una vista: res.render('página', { datos }) genera el HTML inyectando los datos en la plantilla (carpeta views/).
Recursos y métodos HTTP: GET /users (listar), GET /users/:id (leer uno), POST /users (crear), PUT/PATCH /users/:id (modificar), DELETE /users/:id (eliminar) — convenciones coherentes.
Rooms: Grupos de clientes (una sala de chat, una partida) hacia los que se difunde de forma selectiva; organizan la comunicación en tiempo real.
Enrutamiento: Asociación de URL + método HTTP a handlers: app.get('/users', ...), app.post(...), etc. Parámetros de ruta dinámicos: '/users/:id' → req.params.id.
Escalado horizontal / load balancer: Repartir la carga entre varios servidores/instancias detrás de un balanceador de carga; para servir a muchísimos usuarios (favorece apps stateless).
Esquema y modelo: El esquema define la estructura de los documentos (tipos, validaciones: required, unique, valores por defecto); el modelo, creado desde el esquema, ofrece los métodos de manipulación.
Seguridad transversal: Helmet (cabeceras de seguridad), HTTPS, secretos en variables de entorno (nunca en el código), rate limiting, validación — y «nunca confiar en las entradas».
semver y scripts npm: Versionado MAYOR.MENOR.PARCHE (^ / ~ controlan las actualizaciones aceptadas). Los scripts npm definen comandos reutilizables (npm run <nombre>).
Sesión vs JWT: Sesión: estado en el servidor + cookie de identificador. JWT: token autoportante sin almacenamiento en servidor. Dos formas de mantener la autenticación (HTTP es sin estado).
Socket.IO: Biblioteca de referencia para el tiempo real en Node: dirigida por eventos (emit/on), con reconexión automática, fallbacks, rooms y namespaces.
SQL (lenguaje): Structured Query Language: SELECT (leer), INSERT (crear), UPDATE (modificar), DELETE (eliminar), JOIN (combinar tablas relacionadas).
SQL / relacional: Bases que organizan los datos en tablas (columnas tipadas), filas y relaciones vía claves foráneas; PostgreSQL, MySQL. Garantías fuertes (esquema estricto, transacciones ACID).
SSR (Server-Side Rendering): El servidor genera el HTML completo y lo envía al navegador; enfoque de los sitios clásicos (contenido, SEO).
Stream (flujo): Procesamiento de datos por fragmentos (chunks), a medida que llegan, en lugar de cargar todo en memoria; eficiente para grandes volúmenes (memoria y tiempo).
Template literal: Cadena con acentos graves que permite insertar variables: `Hola ${nombre}` — más limpio que la concatenación con +.
Tiempo real: Situaciones donde el servidor envía datos al cliente sin que este los pida, al instante (chat, notificaciones, datos en vivo, juegos); no encaja en el modelo petición-respuesta HTTP.
Terminal / PATH: Consola donde se lanzan node y npm; `node -v` y `npm -v` verifican la instalación (si responden, Node está en el PATH).
Tests automatizados (Jest): Código que prueba tu código: unitarios (una función aislada), de integración (varias partes/una ruta con su base), end-to-end. Jest es el framework popular.
Tipado estático vs dinámico: Estático (TS): tipos declarados y verificados ANTES de la ejecución (en compilación) — detecta errores pronto. Dinámico (JS): tipos verificados solo en ejecución (flexible pero fuente de bugs en runtime).
Tipos de streams: Readable (lectura), Writable (escritura), Duplex (ambos, ej. socket), Transform (transforma al pasar: compresión, cifrado).
TypeScript: Superconjunto de JavaScript que añade tipado estático (todo JS válido es TS válido); se compila a JavaScript ordinario que ejecuta Node.
Validación de entradas: Verificar que los datos recibidos de un cliente tienen el formato esperado (campos requeridos, tipos, restricciones) ANTES de procesarlos; rechazar con 400 si no son válidos. Bibliotecas: Zod, Joi.
VPS: Servidor virtual alquilado que administras tú mismo (Node, config, seguridad, PM2, Nginx, HTTPS); más control y flexibilidad, pero más responsabilidades.
VS Code: Editor estándar para Node/JavaScript: gratuito, soporte JS integrado, terminal integrado, extensiones (ESLint, Prettier) para calidad y formato de código.
WebSocket: Protocolo que establece una conexión PERSISTENTE y BIDIRECCIONAL: permanece abierta, y cliente y servidor se envían mensajes en cualquier momento, en ambos sentidos.
Worker threads: Hilos separados para ejecutar tareas intensivas en CPU (cálculos pesados) sin bloquear el hilo principal / bucle de eventos.