🟩 2.6 · Node.js y npm: JavaScript conquista el servidor

🎯 Objetivo del tema

🗺️ Mapa del tema

En 2009, Ryan Dahl tuvo una idea revolucionaria: tomar el motor V8 de Chrome (que compila JavaScript a código máquina rapidísimo) y embebarlo en un programa que se ejecuta FUERA del navegador. Así nació Node.js: JavaScript en el servidor. Combinado con npm (el gestor de paquetes más grande del mundo), se convirtió en el ecosistema de desarrollo backend más usado después de PHP.

2.6.1 Qué es Node.js y por qué importa

Node.js es un RUNTIME de JavaScript: un programa que ejecuta código JS fuera del navegador. Usa el mismo motor V8 de Chrome, así que es rapidísimo. Permite usar JavaScript tanto en el frontend (navegador) como en el backend (servidor), lo que simplifica el desarrollo full-stack.

2.6.2 Instalación y primer script

Instalar Node.js instala 2 cosas: el runtime de Node (para ejecutar JS) y npm (Node Package Manager, el gestor de paquetes). Ambos vienen juntos. Después de instalar, puedes ejecutar JavaScript desde la terminal con `node archivo.js`.

// hola.js: tu primer script de Node
// Ejecutar: node hola.js en la terminal

const nombre = process.argv[2] || 'Mundo';
console.log(`Hola, ${nombre}!`);
console.log(`Versión de Node: ${process.version}`);
console.log(`Plataforma: ${process.platform}`);

// process.argv es como los argumentos de la terminal
// $ node hola.js Ana
// > Hola, Ana!
// > Versión de Node: v20.11.0
// > Plataforma: win32

Primer script de Node.js

2.6.3 Módulos: require vs import

En Node.js, tu código se organiza en módulos. Hay 2 sistemas: CommonJS (con require, el antiguo) y ES Modules (con import, el moderno). El moderno es el estándar hoy. Saber ambos te permite leer código viejo y escribir código nuevo.

// CommonJS (antiguo):
// math.js
function sumar(a, b) { return a + b; }
module.exports = { sumar };
// app.js
const { sumar } = require('./math.js');

// ES Modules (moderno):
// math.js
export function sumar(a, b) { return a + b; }
// app.js
import { sumar } from './math.js';

// En package.json, para usar ES Modules:
{
  "type": "module",  // esto activa ES Modules en todo el proyecto
  "name": "mi-app",
  "version": "1.0.0"
}

CommonJS vs ES Modules en código

2.6.4 npm: el gestor de paquetes más grande del mundo

npm viene con Node y es el registro de paquetes de JavaScript más grande del mundo: más de 2 millones de paquetes. Te permite instalar y gestionar dependencias (librerías) de tu proyecto. El archivo package.json es el corazón: describe tu proyecto y sus dependencias.

El archivo package.json

{
  "name": "mi-api",
  "version": "1.0.0",
  "description": "Mi primera API con Node.js",
  "type": "module",
  "main": "index.js",
  "scripts": {
    "start": "node index.js",
    "dev": "node --watch index.js",
    "test": "node test.js"
  },
  "dependencies": {
    "express": "^4.18.0",
    "cors": "^2.8.5"
  },
  "devDependencies": {
    "nodemon": "^3.0.0",
    "eslint": "^8.0.0"
  }
}

Anatomía de un package.json

Los 7 comandos de npm que usarás el 95%

2.6.5 npx: ejecutar paquetes sin instalar

npx es un atajo para ejecutar paquetes de npm sin tener que instalarlos globalmente. Es útil para herramientas de línea de comandos que solo usas ocasionalmente: create-react-app, vite, eslint, etc. Node 5.2+ lo trae integrado.

# ANTES: instalar globalmente y luego usar (versión vieja)
npm install -g create-react-app
create-react-app mi-proyecto

# AHORA: con npx, no necesitas instalar nada globalmente
npx create-react-app mi-proyecto
npx vite create mi-proyecto
npx eslint archivo.js
npx nodemon app.js
npx jest

# npx descarga el paquete, lo ejecuta, y lo borra. Cero instalación permanente.

npx: el atajo moderno

2.6.6 Event Loop: el corazón de Node

Node.js es de un solo hilo (como JavaScript en el navegador), pero maneja miles de conexiones simultáneas gracias al Event Loop: un ciclo que ejecuta código asíncrono sin bloquear el hilo principal. Es la magia que hace a Node perfecto para servidores con muchas conexiones I/O (bases de datos, archivos, APIs externas).

Cómo funciona (simplificado)

• 1. Node recibe una petición (ej: leer un archivo).
• 2. La manda a una operación asíncrona (fs.readFile) y SIGUE ejecutando otros callbacks.
• 3. Cuando la operación termina, su callback se encola en el Event Loop.
• 4. El Event Loop procesa los callbacks en orden, en el hilo principal.
• 5. Mientras tanto, Node puede aceptar más peticiones.

// Ejemplo: operaciones async en paralelo
import fs from 'fs/promises';

// ❌ MAL: bloquea el hilo esperando
const data1 = fs.readFileSync('archivo1.txt', 'utf8');
const data2 = fs.readFileSync('archivo2.txt', 'utf8');
console.log(data1, data2);
// Lee UNO, espera, lee el otro, espera. Lento.

// ✅ BIEN: paralelo, no bloquea
const [data1, data2] = await Promise.all([
  fs.readFile('archivo1.txt', 'utf8'),
  fs.readFile('archivo2.txt', 'utf8'),
]);
console.log(data1, data2);
// Lanza las dos, espera AMBAS en paralelo. Rápido.

Event Loop: sync vs async

📚 Contenido ampliado

Material adicional, referencias externas verificadas y ejemplos extendidos.