Introducción

Node.js es un entorno de ejecución que permite ejecutar JavaScript fuera del navegador. En desarrollo web moderno se usa para muchas tareas: instalar herramientas, ejecutar servidores de desarrollo, compilar proyectos, lanzar tests, crear scripts, trabajar con paquetes npm y también desarrollar aplicaciones backend. También existen alternativas modernas como Bun, que en la práctica se usa de forma muy parecida en muchos flujos de trabajo.

En Desarrollo web en entorno cliente, Node.js aparece constantemente aunque el código final se ejecute en el navegador. Cuando usas Vite, React, Angular, TypeScript, linters o herramientas de build, normalmente las estás ejecutando con Node.js durante el desarrollo.

Este tutorial explica qué es Node.js, cómo se instala, cómo se usa desde la terminal y qué funciones habituales permite realizar. El objetivo no es convertirlo en una unidad completa de backend, sino entender la herramienta que sostiene gran parte del entorno de trabajo web actual.

Conocimiento previo

• JavaScript
• Librerías y frameworks de cliente
• React: fundamentos para aplicaciones cliente
• Angular: fundamentos del framework
• Uso básico de terminal.
• Conceptos básicos de archivos, carpetas y rutas.

Referencias

• Node.js - Documentation
• Node.js - Learn
• Node.js - npm
• Node.js - File system
• Node.js - Path
• Node.js - HTTP
• Node.js - Test runner
• Node.js - Debugger

Índice

1. Qué es Node.js
2. Para qué sirve Node.js en desarrollo web
3. Instalación y comprobación
4. Ejecutar JavaScript con node
5. npm y package.json
6. Scripts de npm
7. Módulos en Node.js
8. Trabajar con rutas y archivos
9. Crear un servidor HTTP básico
10. Consumir datos con fetch
11. Variables de entorno
12. Depurar programas Node.js
13. Ejecutar pruebas con node —test
14. Node.js en proyectos frontend
15. Node.js como base de backend
16. Buenas prácticas iniciales
17. Ejercicios

1. Qué es Node.js

Node.js es un runtime de JavaScript. Un runtime es un entorno capaz de ejecutar código. El navegador ejecuta JavaScript dentro de una página web; Node.js lo ejecuta directamente en el sistema operativo, desde la terminal o como proceso de servidor.

Esto permite usar JavaScript para tareas que no dependen del DOM:

• Leer y escribir archivos.
• Crear scripts de automatización.
• Ejecutar herramientas de desarrollo.
• Crear servidores HTTP.
• Consumir APIs.
• Procesar datos.
• Ejecutar pruebas.
• Crear aplicaciones de consola.

Node.js usa el motor V8, el mismo motor JavaScript que utiliza Chrome. Sin embargo, el entorno no es el mismo: en Node.js no existe document, window ni el DOM de una página web.

2. Para qué sirve Node.js en desarrollo web

En desarrollo web cliente, Node.js se usa sobre todo como herramienta de desarrollo. Aunque tu aplicación React o Angular se ejecute finalmente en el navegador, durante el desarrollo necesitas Node.js para ejecutar comandos.

Ejemplos:

• Crear proyectos con Vite, Angular CLI u otras herramientas.
• Instalar paquetes con npm.
• Ejecutar servidores de desarrollo.
• Compilar TypeScript.
• Transformar código moderno para navegadores.
• Optimizar assets.
• Ejecutar pruebas.
• Generar una build de producción.

TODO: añadir esquema visual de Node.js como herramienta entre el proyecto, npm, servidor de desarrollo y navegador.

También puede usarse en backend, por ejemplo para crear una API REST, pero ese uso pertenece más directamente al desarrollo web en entorno servidor.

3. Instalación y comprobación

La forma más sencilla de instalar Node.js es descargar la versión recomendada desde su sitio oficial. En entornos de clase puede que el profesor indique una versión concreta.

Después de instalar, comprueba desde la terminal:

# Terminal
node --version
npm --version

node ejecuta JavaScript. npm gestiona paquetes y scripts del proyecto.

Si los comandos no se reconocen, revisa:

• Si Node.js se instaló correctamente.
• Si la terminal se abrió antes de instalar Node.js.
• Si la ruta de Node.js está en el PATH del sistema.
• Si estás usando una terminal integrada del editor que necesita reiniciarse.

4. Ejecutar JavaScript con node

Puedes ejecutar un archivo JavaScript desde terminal:

const nombre = 'Ada';
console.log(`Hola, ${nombre}`);

Comando:

# Terminal
node saludo.js

Salida esperada:

Hola, Ada

También puedes abrir un REPL, que es una consola interactiva de Node.js:

# Terminal
node

Dentro puedes escribir expresiones JavaScript:

// REPL de Node.js
2 + 3
Math.max(4, 8, 1)

Para salir del REPL, puedes pulsar Ctrl + C dos veces o escribir .exit.

5. npm y package.json

npm es el gestor de paquetes que suele instalarse junto con Node.js. Permite instalar dependencias y ejecutar scripts.

Un proyecto Node.js suele tener un archivo package.json:

{
  "name": "mi-proyecto",
  "version": "1.0.0",
  "type": "module",
  "scripts": {
    "start": "node src/index.js"
  },
  "dependencies": {},
  "devDependencies": {}
}

Puedes crear uno con:

# Terminal
npm init

O aceptar valores por defecto:

# Terminal
npm init -y

Partes importantes:

6. Scripts de npm

Los scripts permiten guardar comandos frecuentes en package.json.

Ejemplo:

{
  "scripts": {
    "dev": "vite",
    "build": "vite build",
    "preview": "vite preview",
    "start": "node src/index.js",
    "test": "node --test"
  }
}

Ejecución:

# Terminal
npm run dev
npm run build
npm run test

Algunos scripts especiales, como start y test, también pueden ejecutarse como:

# Terminal
npm start
npm test

En proyectos frontend modernos, comandos como npm run dev o npm run build suelen ejecutar herramientas instaladas localmente en el proyecto.

7. Módulos en Node.js

Un módulo permite dividir el código en varios archivos. Node.js puede trabajar con CommonJS y con módulos ES. En proyectos modernos es habitual usar módulos ES con import y export.

Ejemplo de módulo ES:

export function sumar(a, b) {
  return a + b;
}

Uso desde otro archivo:

import { sumar } from './matematicas.js';

console.log(sumar(2, 3));

Para usar esta sintaxis en Node.js, una opción habitual es tener "type": "module" en package.json.

También existen módulos internos de Node.js. Se importan con el prefijo node::

import os from 'node:os';

console.log(os.platform());
console.log(os.cpus().length);

El prefijo node: deja claro que se trata de un módulo propio de Node.js y no de un paquete instalado desde npm.

8. Trabajar con rutas y archivos

Node.js puede leer y escribir archivos. Esta capacidad no existe de la misma forma en JavaScript del navegador por razones de seguridad.

Leer un archivo de texto:

import { readFile } from 'node:fs/promises';

const contenido = await readFile('datos.txt', 'utf-8');
console.log(contenido);

Escribir un archivo:

import { writeFile } from 'node:fs/promises';

await writeFile('salida.txt', 'Texto generado desde Node.js');
console.log('Archivo creado');

Trabajar con rutas:

import path from 'node:path';

const ruta = path.join('datos', 'productos.json');
console.log(ruta);

Usar path evita construir rutas manualmente con / o \, que pueden variar entre sistemas operativos.

9. Crear un servidor HTTP básico

Node.js puede crear servidores HTTP. Esto permite responder peticiones desde el navegador o desde herramientas como fetch.

Servidor mínimo:

import http from 'node:http';

const hostname = '127.0.0.1';
const port = 3000;

const server = http.createServer((request, response) => {
  response.statusCode = 200;
  response.setHeader('Content-Type', 'text/plain; charset=utf-8');
  response.end('Hola desde Node.js');
});

server.listen(port, hostname, () => {
  console.log(`Servidor disponible en http://${hostname}:${port}`);
});

Ejecución:

# Terminal
node servidor.js

Después puedes abrir http://127.0.0.1:3000 en el navegador.

Este ejemplo sirve para entender la base. En proyectos reales de backend se suelen usar frameworks como Express, Fastify u otros, pero el principio es el mismo: recibir una petición y devolver una respuesta.

10. Consumir datos con fetch

Node.js también permite realizar peticiones HTTP desde el propio entorno de ejecución.

Ejemplo:

const respuesta = await fetch('https://jsonplaceholder.typicode.com/posts/1');

if (!respuesta.ok) {
  throw new Error('No se pudo obtener el recurso');
}

const datos = await respuesta.json();
console.log(datos.title);

Esto es útil para scripts, pruebas, herramientas de línea de comandos o servidores que necesitan comunicarse con otras APIs.

La diferencia con fetch en navegador es el entorno: en navegador la petición está condicionada por políticas como CORS; en Node.js se ejecuta desde un proceso del sistema.

11. Variables de entorno

Las variables de entorno permiten configurar una aplicación sin escribir ciertos valores directamente en el código. Se accede a ellas mediante process.env.

Ejemplo:

const port = process.env.PORT ?? 3000;
console.log(`Puerto configurado: ${port}`);

Ejecutar con variable en PowerShell:

# Terminal
$env:PORT=4000; node config.js

Ejecutar con variable en Linux o macOS:

# Terminal
PORT=4000 node config.js

Usos habituales:

• Puerto del servidor.
• URL de una API.
• Modo de ejecución.
• Opciones de configuración.

12. Depurar programas Node.js

Node.js puede depurarse desde herramientas compatibles con el protocolo de inspección, incluido Chrome DevTools y editores como VS Code.

Para iniciar un programa en modo inspección:

# Terminal
node --inspect servidor.js

Para pausar al inicio:

# Terminal
node --inspect-brk servidor.js

Después puedes abrir Chrome y acceder a:

chrome://inspect

Desde ahí puedes conectar con el proceso Node.js, poner breakpoints y depurar de forma parecida a JavaScript del navegador.

TODO: añadir captura de chrome://inspect conectando con un proceso Node.js.

13. Ejecutar pruebas con node —test

Node.js incluye un test runner que permite ejecutar pruebas sin instalar una herramienta adicional para casos básicos.

Función a probar:

export function sumar(a, b) {
  return a + b;
}

Prueba:

import test from 'node:test';
import assert from 'node:assert/strict';
import { sumar } from './calculadora.js';

test('suma dos números', () => {
  assert.equal(sumar(2, 3), 5);
});

Ejecución:

# Terminal
node --test

Las pruebas ayudan a comprobar que una función sigue funcionando después de modificar el código.

14. Node.js en proyectos frontend

En un proyecto frontend, Node.js suele estar detrás de comandos como estos:

# Terminal
npm create vite@latest
npm install
npm run dev
npm run build
npm run preview

Qué ocurre en cada caso:

El navegador no ejecuta Node.js. Node.js se usa en tu equipo o en el servidor de integración para preparar la aplicación.

15. Node.js como base de backend

Node.js también puede usarse para desarrollar backend. En ese contexto puede:

• Crear APIs REST.
• Leer y escribir en bases de datos mediante librerías.
• Gestionar autenticación.
• Procesar formularios.
• Servir archivos.
• Conectarse con otros servicios.
• Ejecutar tareas programadas.

Ejemplo conceptual de respuesta JSON:

import http from 'node:http';

const productos = [
  { id: 1, nombre: 'Teclado' },
  { id: 2, nombre: 'Ratón' },
];

const server = http.createServer((request, response) => {
  response.setHeader('Content-Type', 'application/json; charset=utf-8');
  response.end(JSON.stringify(productos));
});

server.listen(3000);

Este uso conecta con Desarrollo web en entorno servidor, pero en esta asignatura nos interesa especialmente entender por qué Node.js aparece en el flujo de herramientas cliente.

16. Buenas prácticas iniciales

• Comprueba siempre node --version y npm --version antes de iniciar un proyecto.
• Usa la versión de Node.js indicada por el proyecto o el profesor.
• No subas node_modules al repositorio.
• Mantén package.json y package-lock.json coherentes.
• Usa scripts de npm para comandos frecuentes.
• Separa código de navegador y código de Node.js.
• No uses APIs del DOM en Node.js.
• No publiques secretos en el código.
• Usa módulos internos con prefijo node: cuando corresponda.
• Lee los mensajes de error completos antes de reinstalar dependencias.

17. Ejercicios