Node.js desde Cero

Aprende a construir aplicaciones backend robustas con Node.js, desde los fundamentos hasta aplicaciones completas.

Principiante

Progreso del curso

Introducción a Node.js

Node.js es un entorno de ejecución para JavaScript construido con el motor V8 de Chrome. Node.js utiliza un modelo de operaciones E/S sin bloqueo y orientado a eventos, que lo hace liviano y eficiente.

¿Por qué aprender Node.js?

Utiliza JavaScript tanto en frontend como en backend
Gran ecosistema de paquetes con npm
Ideal para aplicaciones en tiempo real y APIs
Alta demanda en el mercado laboral

Sistema de Progreso

El Sistema de Progreso te ayuda a seguir tu avance en el curso y desbloquear contenido adicional. Aquí te explicamos cómo funciona:

¿Cómo funciona?

Gana puntos completando proyectos y ejercicios prácticos
Tu progreso se guarda automáticamente mientras avanzas
Desbloquea contenido adicional al alcanzar nuevos niveles

Niveles y Recompensas

Nivel 1 (0-100 puntos)

Principiante

Acceso a proyectos básicos y ejercicios iniciales

Nivel 2 (101-300 puntos)

Intermedio

Desbloqueo de soluciones detalladas y proyectos intermedios

Nivel 3 (301-600 puntos)

Avanzado

Acceso a proyectos avanzados y recursos premium

Nivel 4 (601+ puntos)

Experto

Acceso a mentoría y proyectos especiales

Cómo ganar puntos

Completa los ejercicios prácticos al final de cada sección
Realiza los proyectos propuestos en la sección de proyectos
Participa en los desafíos de código y ejercicios interactivos

Instalación y configuración de Node.js

Aprende a instalar y configurar Node.js en tu sistema operativo. Node.js es compatible con Windows, macOS y Linux.

Instalación en Windows

Paso 1: Descargar Node.js

Visita la página oficial: nodejs.org
Descarga la versión LTS (Long Term Support) recomendada para la mayoría de usuarios

Paso 2: Instalar Node.js

Ejecuta el archivo descargado (node-vX.X.X-x64.msi)
Acepta los términos de licencia
Selecciona la ubicación de instalación (se recomienda dejar la predeterminada)
Asegúrate de que la opción "Add to PATH" esté marcada
Completa el asistente de instalación

Paso 3: Verificar la instalación

Abre una nueva ventana de PowerShell o Command Prompt y ejecuta los siguientes comandos:

Verificar instalación

Deberías ver las versiones instaladas de Node.js y npm. Por ejemplo:

v18.17.0
9.6.7

Instalación en macOS

Paso 1: Instalar Homebrew (opcional)

Abre Terminal
Ejecuta el siguiente comando:

Instalar Homebrew

Paso 2: Instalar Node.js

Elige uno de estos métodos:

Método 1: Usando Homebrew

Instalar Node.js con Homebrew

Método 2: Usando el instalador oficial

Visita nodejs.org
Descarga la versión LTS para macOS
Ejecuta el instalador .pkg descargado

Paso 3: Verificar la instalación

Abre Terminal y ejecuta los siguientes comandos:

Verificar instalación

Instalación en Linux

Paso 1: Preparar el sistema

Elige los comandos según tu distribución:

Ubuntu/Debian:

Preparar Ubuntu/Debian

Fedora:

Preparar Fedora

Paso 2: Instalar Node.js

Ubuntu/Debian:

Instalar en Ubuntu/Debian

Fedora:

Instalar en Fedora

Paso 3: Verificar la instalación

Abre una terminal y ejecuta los siguientes comandos:

Verificar instalación

Configuración inicial

Después de la instalación, es recomendable configurar algunas opciones básicas de npm:

Configuración de npm

Verificación final

Para asegurarte de que todo está funcionando correctamente, ejecuta estos comandos:

Verificación final

Conceptos Básicos de Node.js

Antes de comenzar a programar, es importante entender los conceptos fundamentales que hacen que Node.js sea único y poderoso.

Variables y Tipos de Datos

Node.js utiliza JavaScript, por lo que comparte los mismos tipos de datos y declaración de variables.

variables.js

Bucles y Control de Flujo

Node.js proporciona diferentes tipos de bucles y estructuras de control para manejar el flujo de ejecución.

bucles.js

// Bucles y control de flujo en Node.js

// For tradicional
console.log("For tradicional:");
for (let i = 0; i < 5; i++) {
  console.log(`Iteración ${i}`);
}

// For...of (para arrays)
console.log("\nFor...of:");
const frutas = ["manzana", "banana", "naranja"];
for (const fruta of frutas) {
  console.log(fruta);
}

// For...in (para objetos)
console.log("\nFor...in:");
const persona = {
  nombre: "Ana",
  edad: 25,
  ciudad: "Madrid"
};
for (const propiedad in persona) {
  console.log(`${propiedad}: ${persona[propiedad]}`);
}

// While
console.log("\nWhile:");
let contador = 0;
while (contador < 3) {
  console.log(`Contador: ${contador}`);
  contador++;
}

// Do...while
console.log("\nDo...while:");
let num = 0;
do {
  console.log(`Número: ${num}`);
  num++;
} while (num < 3);

// If...else
console.log("\nIf...else:");
const edad = 18;
if (edad >= 18) {
  console.log("Eres mayor de edad");
} else {
  console.log("Eres menor de edad");
}

// Switch
console.log("\nSwitch:");
const dia = "Lunes";
switch (dia) {
  case "Lunes":
    console.log("Primer día de la semana");
    break;
  case "Viernes":
    console.log("¡Por fin es viernes!");
    break;
  default:
    console.log("Es otro día de la semana");
}

Event Loop y Asincronía

El Event Loop es uno de los conceptos más importantes en Node.js. Permite manejar operaciones asíncronas de manera eficiente.

event-loop.js

// Event Loop y asincronía en Node.js

// Ejemplo de operaciones síncronas vs asíncronas
console.log("Inicio del programa");

// Operación síncrona
console.log("Operación síncrona 1");
console.log("Operación síncrona 2");

// setTimeout - operación asíncrona
setTimeout(() => {
  console.log("Operación asíncrona 1 (después de 1 segundo)");
}, 1000);

// Promise - operación asíncrona
const promesa = new Promise((resolve) => {
  setTimeout(() => {
    resolve("Operación asíncrona 2 (después de 2 segundos)");
  }, 2000);
});

promesa.then(resultado => {
  console.log(resultado);
});

// async/await - operación asíncrona
async function operacionAsincrona() {
  console.log("Inicio de operación asíncrona");
  await new Promise(resolve => setTimeout(resolve, 1500));
  console.log("Fin de operación asíncrona");
}

operacionAsincrona();

console.log("Fin del programa");

// Ejemplo de manejo de eventos
const EventEmitter = require('events');
const miEvento = new EventEmitter();

miEvento.on('saludar', (nombre) => {
  console.log(`¡Hola, ${nombre}!`);
});

miEvento.emit('saludar', 'Juan');

Módulos y Require

Node.js utiliza un sistema de módulos para organizar el código. Los módulos pueden ser archivos individuales o directorios.

modulos.js

Funciones Avanzadas y ES6+

JavaScript moderno ofrece características avanzadas para el manejo de funciones y sintaxis mejorada.

funciones-avanzadas.js

// Funciones avanzadas y características ES6+

// Arrow Functions
const suma = (a, b) => a + b;
const saludar = nombre => `¡Hola, ${nombre}!`;

// Closures
function crearContador() {
  let contador = 0;
  return {
    incrementar: () => ++contador,
    obtener: () => contador
  };
}

const contador = crearContador();
console.log(contador.incrementar()); // 1
console.log(contador.incrementar()); // 2
console.log(contador.obtener());     // 2

// This y contexto
const persona = {
  nombre: "Ana",
  saludar: function() {
    console.log(`Hola, soy ${this.nombre}`);
  },
  saludarArrow: () => {
    console.log(`Hola, soy ${this.nombre}`); // undefined
  }
};

persona.saludar();      // "Hola, soy Ana"
persona.saludarArrow(); // "Hola, soy undefined"

// Desestructuración
const usuario = {
  nombre: "Juan",
  edad: 30,
  direccion: {
    calle: "Principal",
    ciudad: "Madrid"
  }
};

const { nombre, edad, direccion: { ciudad } } = usuario;
console.log(nombre, edad, ciudad);

// Spread operator
const numeros = [1, 2, 3];
const masNumeros = [...numeros, 4, 5];
console.log(masNumeros);

// Template literals
const nombre = "María";
const edad = 25;
console.log(`${nombre} tiene ${edad} años`);

// Clases
class Animal {
  constructor(nombre) {
    this.nombre = nombre;
  }
  
  hacerSonido() {
    console.log("Hace un sonido");
  }
}

class Perro extends Animal {
  hacerSonido() {
    console.log("¡Guau!");
  }
}

const perro = new Perro("Firulais");
perro.hacerSonido();

Streams y Sistema de Archivos

Los streams son una forma eficiente de manejar datos en Node.js, especialmente cuando trabajamos con archivos grandes.

streams-fs.js

// Streams y Sistema de Archivos

const fs = require('fs');
const path = require('path');

// Lectura de archivo con streams
const leerArchivo = () => {
  const stream = fs.createReadStream('archivo.txt', 'utf8');
  
  stream.on('data', (chunk) => {
    console.log('Chunk recibido:', chunk);
  });
  
  stream.on('end', () => {
    console.log('Lectura completada');
  });
  
  stream.on('error', (error) => {
    console.error('Error:', error);
  });
};

// Escritura de archivo con streams
const escribirArchivo = () => {
  const stream = fs.createWriteStream('nuevo-archivo.txt');
  
  stream.write('Primera línea\n');
  stream.write('Segunda línea\n');
  stream.end();
  
  stream.on('finish', () => {
    console.log('Escritura completada');
  });
  
  stream.on('error', (error) => {
    console.error('Error:', error);
  });
};

// Operaciones básicas con fs
const operacionesFS = async () => {
  try {
    // Crear directorio
    await fs.promises.mkdir('nuevo-directorio');
    
    // Escribir archivo
    await fs.promises.writeFile(
      'nuevo-directorio/archivo.txt',
      'Contenido del archivo'
    );
    
    // Leer archivo
    const contenido = await fs.promises.readFile(
      'nuevo-directorio/archivo.txt',
      'utf8'
    );
    console.log('Contenido:', contenido);
    
    // Eliminar archivo
    await fs.promises.unlink('nuevo-directorio/archivo.txt');
    
    // Eliminar directorio
    await fs.promises.rmdir('nuevo-directorio');
    
  } catch (error) {
    console.error('Error en operaciones:', error);
  }
};

HTTP y Networking

Node.js proporciona módulos nativos para crear servidores web y manejar comunicaciones en red.

http-networking.js

// HTTP y Networking

const http = require('http');

// Crear servidor HTTP básico
const servidor = http.createServer((req, res) => {
  // Configurar headers
  res.setHeader('Content-Type', 'application/json');
  
  // Manejar diferentes rutas
  switch (req.url) {
    case '/':
      res.writeHead(200);
      res.end(JSON.stringify({
        mensaje: 'Bienvenido al servidor'
      }));
      break;
      
    case '/api/usuarios':
      res.writeHead(200);
      res.end(JSON.stringify({
        usuarios: [
          { id: 1, nombre: 'Juan' },
          { id: 2, nombre: 'María' }
        ]
      }));
      break;
      
    default:
      res.writeHead(404);
      res.end(JSON.stringify({
        error: 'Ruta no encontrada'
      }));
  }
});

// Manejar errores del servidor
servidor.on('error', (error) => {
  console.error('Error del servidor:', error);
});

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

// Ejemplo de cliente HTTP
const hacerPeticion = () => {
  const opciones = {
    hostname: 'localhost',
    port: 3000,
    path: '/api/usuarios',
    method: 'GET'
  };
  
  const req = http.request(opciones, (res) => {
    let datos = '';
    
    res.on('data', (chunk) => {
      datos += chunk;
    });
    
    res.on('end', () => {
      console.log('Respuesta:', JSON.parse(datos));
    });
  });
  
  req.on('error', (error) => {
    console.error('Error en la petición:', error);
  });
  
  req.end();
};

Manejo de Errores y Variables de Entorno

El manejo adecuado de errores y la configuración del entorno son aspectos cruciales en el desarrollo con Node.js.

errores-env.js

// Manejo de errores y variables de entorno

require('dotenv').config();

// Manejo de errores con try/catch
const operacionRiesgosa = async () => {
  try {
    // Simular operación que puede fallar
    const resultado = await new Promise((resolve, reject) => {
      setTimeout(() => {
        reject(new Error('Algo salió mal'));
      }, 1000);
    });
  } catch (error) {
    console.error('Error capturado:', error.message);
    // Manejar el error apropiadamente
  }
};

// Manejo de errores en promesas
const promesaConError = () => {
  return new Promise((resolve, reject) => {
    // Simular error
    reject(new Error('Error en la promesa'));
  })
  .then(resultado => {
    console.log('Éxito:', resultado);
  })
  .catch(error => {
    console.error('Error en promesa:', error.message);
  });
};

// Variables de entorno
const configuracion = {
  puerto: process.env.PORT || 3000,
  entorno: process.env.NODE_ENV || 'desarrollo',
  apiKey: process.env.API_KEY
};

console.log('Configuración:', configuracion);

// Manejo de errores no capturados
process.on('uncaughtException', (error) => {
  console.error('Error no capturado:', error);
  // Realizar limpieza necesaria
  process.exit(1);
});

process.on('unhandledRejection', (error) => {
  console.error('Promesa rechazada no manejada:', error);
  // Realizar limpieza necesaria
  process.exit(1);
});

Herramientas de Desarrollo

Las herramientas de desarrollo son esenciales para mantener la calidad del código y facilitar el debugging.

herramientas-dev.js

// Herramientas de desarrollo

// Ejemplo de configuración de ESLint
/*
{
  "env": {
    "node": true,
    "es2021": true
  },
  "extends": "eslint:recommended",
  "rules": {
    "no-console": "warn",
    "semi": ["error", "always"]
  }
}
*/

// Ejemplo de configuración de Jest
/*
module.exports = {
  testEnvironment: 'node',
  testMatch: ['**/__tests__/**/*.js', '**/?(*.)+(spec|test).js']
};
*/

// Ejemplo de test con Jest
function sumar(a, b) {
  return a + b;
}

// Debugging con console
const debug = () => {
  console.log('Inicio de la función');
  console.time('operacion');
  
  // Código a debuggear
  const resultado = sumar(5, 3);
  
  console.timeEnd('operacion');
  console.log('Resultado:', resultado);
  
  // Inspeccionar objeto
  const objeto = { nombre: 'Test', valor: 42 };
  console.dir(objeto, { depth: null });
  
  // Stack trace
  console.trace('Punto de seguimiento');
};

// Profiling
const profiler = () => {
  console.profile('operacion');
  
  // Código a perfilar
  for (let i = 0; i < 1000000; i++) {
    sumar(i, i + 1);
  }
  
  console.profileEnd('operacion');
};

Tu primer programa en Node.js

Vamos a crear un programa simple que muestre un mensaje en la consola. Este es el primer paso para familiarizarte con Node.js.

Ejemplo: Hola Mundo en Node.js

hola-mundo.js

Ejercicio práctico

Modifica el código anterior para crear una función que calcule el área de un círculo dado su radio.

ejercicio-area.js

Módulos en Node.js

Node.js utiliza un sistema de módulos para organizar el código. Esto permite dividir tu aplicación en partes más pequeñas y reutilizables.

Ejemplo: Creando y usando módulos

matematicas.js

app.js

Ejercicio práctico

Crea un módulo llamado "geometria.js" que exporte funciones para calcular el área y perímetro de diferentes figuras geométricas.

geometria.js

Servidores HTTP con Node.js

Node.js proporciona un módulo HTTP nativo que nos permite crear servidores web. Aunque podemos usarlo directamente, en la práctica solemos utilizar frameworks como Express.js para simplificar el desarrollo.

Ejemplo: Servidor HTTP básico

server.js

Ejercicio práctico

Crea un servidor HTTP que maneje las siguientes rutas: - GET /api/productos: Devuelve una lista de productos - POST /api/productos: Crea un nuevo producto - GET /api/productos/:id: Devuelve un producto específico

productos-server.js

// Archivo: productos-server.js
const http = require('http');

// Datos de ejemplo
let productos = [
  { id: 1, nombre: 'Laptop', precio: 999.99 },
  { id: 2, nombre: 'Smartphone', precio: 499.99 }
];

// Función para parsear el body de la petición
function parseBody(req) {
  return new Promise((resolve, reject) => {
    let body = '';
    req.on('data', chunk => {
      body += chunk.toString();
    });
    req.on('end', () => {
      try {
        resolve(JSON.parse(body));
      } catch (error) {
        reject(error);
      }
    });
  });
}

// Creamos el servidor
const server = http.createServer(async (req, res) => {
  res.setHeader('Content-Type', 'application/json');

try {
    // GET /api/productos
    if (req.method === 'GET' && req.url === '/api/productos') {
      res.writeHead(200);
      res.end(JSON.stringify(productos));
    }
    // POST /api/productos
    else if (req.method === 'POST' && req.url === '/api/productos') {
      const nuevoProducto = await parseBody(req);
      nuevoProducto.id = productos.length + 1;
      productos.push(nuevoProducto);
      res.writeHead(201);
      res.end(JSON.stringify(nuevoProducto));
    }
    // GET /api/productos/:id
    else if (req.method === 'GET' && req.url.startsWith('/api/productos/')) {
      const id = parseInt(req.url.split('/')[3]);
      const producto = productos.find(p => p.id === id);
      if (producto) {
        res.writeHead(200);
        res.end(JSON.stringify(producto));
      } else {
        res.writeHead(404);
        res.end(JSON.stringify({ error: 'Producto no encontrado' }));
      }
    }
    else {
      res.writeHead(404);
      res.end(JSON.stringify({ error: 'Ruta no encontrada' }));
    }
  } catch (error) {
    res.writeHead(500);
    res.end(JSON.stringify({ error: 'Error interno del servidor' }));
  }
});

// Iniciamos el servidor
const PORT = 3000;
server.listen(PORT, () => {
  console.log(`Servidor de productos corriendo en http://localhost:${PORT}`);
});

Express.js: Framework Web para Node.js

Express.js es el framework web más popular para Node.js. Proporciona una capa de abstracción que simplifica la creación de aplicaciones web y APIs RESTful.

Ejemplo: API REST con Express.js

app.js

// Archivo: app.js
const express = require('express');
const app = express();

// Middleware para parsear JSON
app.use(express.json());

// Datos de ejemplo
let tareas = [
  { id: 1, titulo: 'Aprender Node.js', completada: false },
  { id: 2, titulo: 'Crear una API REST', completada: true }
];

// GET /api/tareas
app.get('/api/tareas', (req, res) => {
  res.json(tareas);
});

// POST /api/tareas
app.post('/api/tareas', (req, res) => {
  const nuevaTarea = {
    id: tareas.length + 1,
    ...req.body
  };
  tareas.push(nuevaTarea);
  res.status(201).json(nuevaTarea);
});

// GET /api/tareas/:id
app.get('/api/tareas/:id', (req, res) => {
  const tarea = tareas.find(t => t.id === parseInt(req.params.id));
  if (!tarea) {
    return res.status(404).json({ error: 'Tarea no encontrada' });
  }
  res.json(tarea);
});

// PUT /api/tareas/:id
app.put('/api/tareas/:id', (req, res) => {
  const tarea = tareas.find(t => t.id === parseInt(req.params.id));
  if (!tarea) {
    return res.status(404).json({ error: 'Tarea no encontrada' });
  }
  Object.assign(tarea, req.body);
  res.json(tarea);
});

// DELETE /api/tareas/:id
app.delete('/api/tareas/:id', (req, res) => {
  const index = tareas.findIndex(t => t.id === parseInt(req.params.id));
  if (index === -1) {
    return res.status(404).json({ error: 'Tarea no encontrada' });
  }
  tareas.splice(index, 1);
  res.status(204).send();
});

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

Middleware en Express.js

Los middleware son funciones que tienen acceso al objeto request, response y al siguiente middleware en el ciclo de request-response.

middleware.js

Bases de datos con MongoDB y Mongoose

MongoDB es una base de datos NoSQL que se integra perfectamente con Node.js. Mongoose es una biblioteca que nos ayuda a modelar y trabajar con documentos de MongoDB de manera más sencilla.

Ejemplo: Modelo y operaciones CRUD con Mongoose

models/Usuario.js

API REST con MongoDB

app.js

// Archivo: app.js
const express = require('express');
const mongoose = require('mongoose');
const Usuario = require('./models/Usuario');

const app = express();
app.use(express.json());

// Conexión a MongoDB
mongoose.connect('mongodb://localhost:27017/mi_base_datos', {
  useNewUrlParser: true,
  useUnifiedTopology: true
});

// GET /api/usuarios
app.get('/api/usuarios', async (req, res) => {
  try {
    const usuarios = await Usuario.find();
    res.json(usuarios);
  } catch (error) {
    res.status(500).json({ error: 'Error al obtener usuarios' });
  }
});

// POST /api/usuarios
app.post('/api/usuarios', async (req, res) => {
  try {
    const usuario = new Usuario(req.body);
    await usuario.save();
    res.status(201).json(usuario);
  } catch (error) {
    res.status(400).json({ error: 'Error al crear usuario' });
  }
});

// GET /api/usuarios/:id
app.get('/api/usuarios/:id', async (req, res) => {
  try {
    const usuario = await Usuario.findById(req.params.id);
    if (!usuario) {
      return res.status(404).json({ error: 'Usuario no encontrado' });
    }
    res.json(usuario);
  } catch (error) {
    res.status(500).json({ error: 'Error al obtener usuario' });
  }
});

// PUT /api/usuarios/:id
app.put('/api/usuarios/:id', async (req, res) => {
  try {
    const usuario = await Usuario.findByIdAndUpdate(
      req.params.id,
      req.body,
      { new: true, runValidators: true }
    );
    if (!usuario) {
      return res.status(404).json({ error: 'Usuario no encontrado' });
    }
    res.json(usuario);
  } catch (error) {
    res.status(400).json({ error: 'Error al actualizar usuario' });
  }
});

// DELETE /api/usuarios/:id
app.delete('/api/usuarios/:id', async (req, res) => {
  try {
    const usuario = await Usuario.findByIdAndDelete(req.params.id);
    if (!usuario) {
      return res.status(404).json({ error: 'Usuario no encontrado' });
    }
    res.status(204).send();
  } catch (error) {
    res.status(500).json({ error: 'Error al eliminar usuario' });
  }
});

// Iniciamos el servidor
const PORT = 3000;
app.listen(PORT, () => {
  console.log(`Servidor con MongoDB corriendo en http://localhost:${PORT}`);
});

Relaciones entre modelos

En MongoDB podemos crear relaciones entre documentos usando referencias o embebiendo documentos.

models/Post.js