Node.js es un entorno de ejecución para JavaScript construido con el motor V8 de Chrome, que permite ejecutar código JavaScript en el servidor. Es utilizado para crear aplicaciones web, APIs, herramientas de línea de comandos, y mucho más. En esta guía, aprenderás los pasos esenciales para comenzar con Node.js, desde la instalación hasta conceptos avanzados, con ejemplos prácticos para mejorar tu comprensión.
Antes de instalar Node.js, verifica si ya está instalado ejecutando los siguientes comandos en la terminal:
node -v
npm -v
Si obtienes una versión, significa que Node.js y npm (Node Package Manager) ya están instalados.
Si no lo tienes instalado, sigue estos pasos:
1- Descargar Node.js: Ve al sitio oficial de Node.js en https://nodejs.org y descarga la versión recomendada (LTS).
2- Instalar Node.js: Sigue las instrucciones del instalador para tu sistema operativo (Windows, macOS o Linux).
3- Verificar la instalación: Una vez instalado, verifica que todo funcione correctamente ejecutando:
node -v
npm -v
Estos comandos mostrarán las versiones instaladas de Node.js y npm.
Una vez instalado Node.js, puedes crear un proyecto con el siguiente comando en la terminal:
npm init -y
Esto generará un archivo 'package.json' que almacenará información sobre tu proyecto y sus dependencias.
Crea un archivo llamado 'app.js' y escribe el siguiente código para imprimir "Hola, Node.js" en la consola:
console.log('Hola, Node.js');
Para ejecutarlo, usa el siguiente comando en la terminal:
node app.js
Este comando ejecuta tu archivo en el entorno de Node.js y mostrará el mensaje en la consola.
Node.js se organiza en módulos. Puedes usar módulos internos, externos o crear los tuyos propios.
Un ejemplo de módulo interno es 'fs' (sistema de archivos) que te permite trabajar con archivos. Ejemplo:
const fs = require('fs');
fs.writeFile('archivo.txt', 'Hola, desde Node.js', (err) => {
if (err) throw err;
console.log('Archivo creado');
});
Puedes crear tus propios módulos exportando funciones o variables:
sumar.js:
function sumar(a, b) {
return a + b;
}
module.exports = sumar;
app.js:
const sumar = require('./sumar');
console.log(sumar(5, 3)); // Resultado: 8
npm es el gestor de paquetes para Node.js. Te permite instalar y gestionar bibliotecas de terceros.
Instalemos un paquete llamado 'express', una biblioteca para crear aplicaciones web.
npm install express
Ejemplo de uso básico de Express:
const express = require('express');
const app = express();
app.get('/', (req, res) => {
res.send('¡Hola desde Express!');
});
app.listen(3000, () => {
console.log('Servidor ejecutándose en http://localhost:3000');
});
Ejecuta este código y visita 'http://localhost:3000' en tu navegador para ver la respuesta del servidor.
Node.js maneja muchas tareas de manera asincrónica, utilizando promesas o callbacks.
Ejemplo con callbacks:
const fs = require('fs');
fs.readFile('archivo.txt', 'utf8', (err, data) => {
if (err) throw err;
console.log(data);
});
Con promesas:
const fs = require('fs').promises;
fs.readFile('archivo.txt', 'utf8')
.then(data => console.log(data))
.catch(err => console.log(err));
Con 'async/await':
const fs = require('fs').promises;
async function leerArchivo() {
try {
const data = await fs.readFile('archivo.txt', 'utf8');
console.log(data);
} catch (err) {
console.error(err);
}
}
leerArchivo();
Un middleware es una función que se ejecuta durante el ciclo de vida de una solicitud. Express hace un uso extensivo de middleware para manejar autenticación, validación, logging, entre otros.
Ejemplo de middleware personalizado:
const express = require('express');
const app = express();
// Middleware personalizado
app.use((req, res, next) => {
console.log(`Petición ${req.method} a ${req.url}`);
next();
});
app.get('/', (req, res) => {
res.send('¡Middleware funcionando!');
});
app.listen(3000, () => {
console.log('Servidor ejecutándose en http://localhost:3000');
});
Node.js puede conectarse a bases de datos como MongoDB, MySQL o PostgreSQL. A continuación, te mostramos cómo conectar Node.js a MongoDB usando 'mongoose':
1- Instalar Mongoose:
npm install mongoose
2- Conectar a la base de datos:
const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/miDB', { useNewUrlParser: true, useUnifiedTopology: true })
.then(() => console.log('Conectado a MongoDB'))
.catch(err => console.log(err));
3- Definir un esquema y modelo de MongoDB:
const usuarioSchema = new mongoose.Schema({
nombre: String,
edad: Number,
email: String
});
const Usuario = mongoose.model('Usuario', usuarioSchema);
// Crear un nuevo usuario
const nuevoUsuario = new Usuario({ nombre: 'Carlos', edad: 25, email: 'carlos@example.com' });
nuevoUsuario.save()
.then(usuario => console.log('Usuario guardado:', usuario))
.catch(err => console.log(err));
Node.js es ideal para crear APIs RESTful, y hay varias herramientas para probarlas como 'Jest' y 'Supertest'. Aquí un ejemplo de cómo crear una API RESTful:
const express = require('express');
const app = express();
app.use(express.json());
const usuarios = [
{ id: 1, nombre: 'Juan' },
{ id: 2, nombre: 'María' }
];
// Leer todos los usuarios
app.get('/usuarios', (req, res) => {
res.json(usuarios);
});
// Crear un nuevo usuario
app.post('/usuarios', (req, res) => {
const nuevoUsuario = { id: usuarios.length + 1, nombre: req.body.nombre };
usuarios.push(nuevoUsuario);
res.status(201).json(nuevoUsuario);
});
app.listen(3000, () => {
console.log('Servidor ejecutándose en http://localhost:3000');
});
WebSockets permiten la comunicación en tiempo real entre el servidor y los clientes. 'Socket.io' es una biblioteca popular para este propósito.
1- Instala 'socket.io':
npm install socket.io
2- Usa socket.io en el servidor:
const express = require('express');
const http = require('http');
const socketIo = require('socket.io');
const app = express();
const server = http.createServer(app);
const io = socketIo(server);
io.on('connection', (socket) => {
console.log('Un usuario se conectó');
socket.on('mensaje', (msg) => {
io.emit('mensaje', msg);
});
});
server.listen(3000, () => {
console.log('Servidor y WebSocket funcionando en http://localhost:3000');
});
Conceptos básicos de Node.js: Módulos, eventos, sistema de archivos (fs).
Express.js: Framework para construir aplicaciones web y APIs.
npm: Gestión de dependencias.
Asincronía: Callbacks, promesas, 'async/await'.
APIs RESTful: Diseño y consumo.
Base de datos: Conexiones a MongoDB, PostgreSQL, MySQL.
WebSockets: Comunicación en tiempo real con 'Socket.io'.
Testing: Unitarios con 'Jest', integración con 'Supertest'.
Seguridad: Autenticación con JWT, cifrado, control de acceso.
Crear una API RESTful básica con CRUD.
Implementar un chat en tiempo real usando WebSockets.
Conectar una aplicación Node.js