Guía de Node.js Nivel Medio: Event Loop, Módulos y Desarrollo Backend con Express por Santiago Soñora

“Hola, mundo” en Node.js

El clásico 'Hola, mundo' en Node.js, ejecutado desde la terminal. A nivel intermedio, podrías usarlo para demostrar cómo Node.js ejecuta scripts simples del lado del servidor.

📋 Copiar

console.log("Hola, mundo desde Node.js");

Resultado:

Output

Hola, mundo desde Node.js

Comandos básicos

Familiarizarse con estos comandos es esencial para interactuar eficientemente con Node.js:

Iniciar un proyecto Node.js
📋 Copiar
```
npm init -y
```
Crea un archivo `package.json` con configuración por defecto, que gestiona las dependencias y metadatos del proyecto.
Instalar un paquete (dependencia)
📋 Copiar
```
npm install express
```
Instala el paquete `express` y lo añade a las dependencias del proyecto en `package.json`.
Instalar paquete (dependencia de desarrollo)
📋 Copiar
```
npm install --save-dev nodemon
```
Instala el paquete `nodemon` (útil para desarrollo) y lo añade a las dependencias de desarrollo en `package.json`.

Crear un servidor HTTP básico (nativo)

📋 Copiar

const http = require('http');

const server = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader('Content-Type', 'text/plain');
  res.end('Hola desde Node.js HTTP nativo');
});

const port = 3000;
server.listen(port, () => {
  console.log(`Servidor corriendo en http://localhost:${port}/`);
});

Crea un servidor HTTP simple usando el módulo nativo 'http' que responde a cualquier petición.

Ejecutar un archivo JavaScript
📋 Copiar
```
node index.js
```
Ejecuta el archivo `index.js` utilizando el entorno de ejecución de Node.js desde la terminal.
Ver versiones de Node y npm
📋 Copiar
```
node -v && npm -v
```
Muestra las versiones instaladas de Node.js y su gestor de paquetes npm.
Instalar todas las dependencias
📋 Copiar
```
npm install
```
Lee el archivo `package.json` e instala todos los paquetes listados en las secciones `dependencies` y `devDependencies`.
Ejecutar script de package.json
📋 Copiar
```
npm run <nombre-script>
```
Ejecuta un comando personalizado definido en la sección 'scripts' del archivo `package.json` (ej: `npm start`, `npm test`).

Leer un archivo (Asíncrono)

📋 Copiar

const fs = require('fs');

fs.readFile('miarchivo.txt', 'utf8', (err, data) => {
  if (err) {
    console.error('Error al leer el archivo:', err);
    return;
  }
  console.log('Contenido del archivo:', data);
});

Utiliza el módulo nativo `fs` para leer el contenido de un archivo de forma asíncrona, pasando un callback para manejar el resultado o el error.

Escribir en un archivo (Asíncrono)

📋 Copiar

const fs = require('fs');

const contenido = 'Este es el nuevo contenido.';
fs.writeFile('miarchivo.txt', contenido, 'utf8', (err) => {
  if (err) {
    console.error('Error al escribir en el archivo:', err);
    return;
  }
  console.log('Archivo escrito exitosamente.');
});

Utiliza el módulo nativo `fs` para escribir contenido en un archivo de forma asíncrona.

Crear servidor Express básico con ruta

📋 Copiar

const express = require('express');
const app = express();

app.get('/', (req, res) => {
  res.send('¡Bienvenido a mi servidor Express!');
});

const port = 3000;
app.listen(port, () => {
  console.log(`Servidor Express corriendo en http://localhost:${port}/`);
});

Configura un servidor web mínimo con Express que responde a peticiones GET en la ruta raíz ('/').

Usar Variable de Entorno
📋 Copiar
```
console.log('Puerto:', process.env.PORT || 3000);
```
Accede al valor de una variable de entorno llamada `PORT`. Si no está definida, usa 3000 como valor por defecto.

Conceptos Clave

Comprender estos conceptos fundamentales te ayudará a dominar Node.js de forma más organizada y eficiente:

El Event Loop y I/O No Bloqueante:

Node.js opera en un solo hilo principal pero maneja la concurrencia a través de un Event Loop. Las operaciones de E/S (entrada/salida, como lectura de archivos, peticiones de red) son por defecto no bloqueantes. Esto permite que Node.js gestione muchas conexiones simultáneamente sin crear múltiples hilos, lo que lo hace eficiente para servidores con muchas conexiones concurrentes.
Sistema de Módulos (CommonJS y ES Modules):

Node.js permite organizar el código en módulos reusables. El sistema tradicional (CommonJS) usa `require()` para importar y `module.exports` para exportar. El sistema moderno (ES Modules), estándar en el navegador, usa `import` y `export`, y se puede habilitar en Node.js (con `.mjs` o configurando `package.json`).
Gestores de Paquetes: npm y Yarn:

npm (Node Package Manager) y Yarn son herramientas esenciales para descubrir, instalar y gestionar las bibliotecas y herramientas que tu proyecto Node.js necesita. El archivo `package.json` registra las dependencias y permite definir scripts personalizados.
Módulos Nativos (Core Modules):

Node.js viene con un conjunto de módulos 'core' preinstalados que proporcionan funcionalidades básicas como interactuar con el sistema de archivos (`fs`), crear servidores HTTP (`http`), manejar rutas de archivos (`path`), trabajar con eventos (`events`), etc. No necesitan ser instalados vía npm.
Manejo de Solicitudes y Respuestas HTTP:

En un servidor web, cada petición HTTP (`req`) contiene información sobre el cliente (URL, método, headers, cuerpo), y el objeto de respuesta (`res`) se usa para enviar datos de vuelta al cliente (estado, headers, cuerpo). Aprender a manejar estos objetos es fundamental para construir APIs y sitios web.
Introducción a Frameworks Web (Express.js):

Aunque es posible crear servidores con el módulo `http` nativo, frameworks como Express.js simplifican enormemente el desarrollo de aplicaciones web al proporcionar estructura para el routing (dirigir peticiones a funciones específicas) y middleware (funciones que pueden procesar peticiones antes de que lleguen al handler final).
Asincronía en el Backend (Callbacks, Promises, Async/Await):

Al igual que en el frontend, la asincronía es clave en Node.js. Se utiliza para manejar operaciones de E/S sin bloquear el servidor. Las callbacks, Promises y la sintaxis Async/Await son los patrones comunes para manejar operaciones asíncronas en el backend.
Variables de Entorno:

Son una forma segura y flexible de configurar tu aplicación Node.js para diferentes entornos (desarrollo, staging, producción) sin modificar el código. Se accede a ellas a través del objeto global `process.env`.

Casos de uso

Algunos ejemplos de aplicaciones prácticas donde se utiliza Node.js:

Construcción de APIs RESTful con frameworks:

Desarrollar servicios backend para aplicaciones web o móviles, manejando peticiones HTTP para realizar operaciones sobre recursos (CRUD) utilizando frameworks como Express.js, NestJS o Koa.
Creación de aplicaciones en tiempo real (WebSockets):

Construir servidores que permitan comunicación bidireccional en tiempo real entre el servidor y los clientes (ej: chats, dashboards en vivo) usando bibliotecas como Socket.IO.
Desarrollo de herramientas de línea de comandos (CLI):

Crear utilidades ejecutables desde la terminal para automatizar tareas, procesar datos, o interactuar con el sistema de archivos, aprovechando la capacidad de scripting de Node.js.
Servir aplicaciones frontend (Servidor Estático):

Configurar un servidor Node.js (con o sin Express) para servir los archivos estáticos (HTML, CSS, JS compilado) de una aplicación frontend.
Automatización de tareas de backend:

Crear scripts para tareas programadas (cron jobs), procesar colas de mensajes, o realizar operaciones de mantenimiento en el servidor.
Integración con bases de datos:

Conectar tu aplicación Node.js a bases de datos (SQL o NoSQL como MongoDB, PostgreSQL, MySQL) utilizando drivers o ORMs/ODMs adecuados.

Consejos para Principiantes

Aquí tienes algunas recomendaciones para facilitar tus inicios en Node.js:

Abraza la Asincronía:

El modelo asíncrono de Node.js es su mayor fortaleza. Asegúrate de comprender cómo funcionan las Callbacks, Promesas y Async/Await en el contexto del backend. Evita las operaciones síncronas bloqueantes siempre que sea posible para mantener tu servidor responsivo.
Domina npm/Yarn y package.json:

Dedica tiempo a entender cómo gestionar dependencias (producción vs desarrollo), ejecutar scripts personalizados y comprender el versionado semántico (semver). Es fundamental para la gestión de proyectos.
Familiarízate con los Módulos Nativos Clave:

Explora módulos como `fs` (sistema de archivos), `http` (cliente/servidor HTTP básico), `path` (manejo de rutas), `events` (emisor de eventos) y `process` (información del proceso actual). Te permitirán realizar muchas tareas comunes sin dependencias de terceros.
Entiende el Event Loop (en el contexto de Node.js):

Una comprensión un poco más profunda del Event Loop de Node.js te ayudará a entender cómo se ejecutan las operaciones asíncronas y a diagnosticar problemas de rendimiento, como el 'bloqueo' del Event Loop.
Usa Variables de Entorno para Configuración:

Nunca guardes credenciales o configuraciones específicas de entorno directamente en tu código. Utiliza `process.env` y herramientas como `dotenv` para cargar la configuración desde archivos externos o el entorno del sistema.
Aprende a Depurar Aplicaciones Node.js:

Las herramientas de depuración son esenciales. Utiliza el inspector de Node.js (`node inspect`) o las excelentes herramientas de depuración integradas en IDEs como VSCode para rastrear errores y entender el flujo de ejecución.
Comienza con un Framework Web como Express.js:

Aunque el módulo `http` nativo es importante, un framework como Express simplificará drásticamente la creación de servidores web y APIs al ofrecer convenciones para routing, middleware y manejo de peticiones/respuestas.

Herramientas relacionadas

Si te interesa Node.js, también podrías explorar estas herramientas:

Recursos útiles

Amplía tus conocimientos con estos enlaces y materiales: