Curso Node

Node.js es un entorno de ejecución JavaScript de código abierto y multiplataforma que permite ejecutar código JavaScript fuera del navegador. Construido sobre el motor V8 de Google Chrome, Node.js transforma JavaScript en un lenguaje de programación del lado del servidor, lo que lo hace ideal para el desarrollo de aplicaciones de backend.

A diferencia de otros entornos de ejecución, Node.js adopta un modelo de I/O no bloqueante y orientado a eventos, lo que le permite manejar conexiones concurrentes de manera eficiente. Esta arquitectura asíncrona es especialmente útil para aplicaciones que requieren un alto rendimiento y escalabilidad, como servidores web y servicios de tiempo real.

En Node.js, el código se ejecuta en un único hilo de ejecución, pero utiliza el bucle de eventos para gestionar operaciones asíncronas. Esto significa que, en lugar de bloquear el hilo mientras espera una operación como la lectura de un archivo o una consulta a una base de datos, Node.js delega la operación al sistema y continúa procesando otras tareas. Cuando la operación asíncrona se completa, se coloca una tarea en la cola del bucle de eventos para ser ejecutada.

Este enfoque permite a Node.js manejar miles de conexiones simultáneas sin la necesidad de crear múltiples hilos o procesos. Por ejemplo, un servidor HTTP básico en Node.js se puede crear utilizando el módulo 'http':

const http = require('http');

const servidor = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader('Content-Type', 'text/plain');
  res.end('¡Hola, mundo!\n');
});

servidor.listen(3000, '127.0.0.1', () => {
  console.log('El servidor se está ejecutando en http://127.0.0.1:3000/');
});

En este ejemplo, el servidor escucha en el puerto 3000 y responde con un mensaje simple a cada solicitud recibida. Gracias al modelo asíncrono de Node.js, este servidor puede atender múltiples solicitudes al mismo tiempo sin bloquearse.

Node.js también ofrece un ecosistema robusto de módulos y paquetes a través de npm (Node Package Manager), que facilita la incorporación de funcionalidades adicionales. Herramientas populares como Express.js permiten desarrollar aplicaciones web y APIs REST de manera rápida y eficiente.

En el contexto del desarrollo de backend, Node.js es especialmente útil para construir microservicios, aplicaciones de tiempo real como chat en línea o sistemas de colaboración, y para servir como capa intermedia entre bases de datos y clientes front-end. Su capacidad para manejar operaciones asíncronas y su enfoque en la modularidad y la simplicidad lo convierten en una opción preferida para muchos desarrolladores.

Además, con el surgimiento de tecnologías como TypeScript, es posible mejorar la robustez del código añadiendo tipado estático a las aplicaciones de Node.js, lo que facilita el mantenimiento y escalabilidad de proyectos a gran escala.

Principales funcionalidades de NodeJS

Node.js ofrece una variedad de funcionalidades que lo han convertido en una herramienta esencial para el desarrollo de aplicaciones backend. Su arquitectura está diseñada para maximizar el rendimiento y la eficiencia, facilitando la creación de aplicaciones escalables y de alta concurrencia. A continuación, se detallan las principales funcionalidades que hacen de Node.js una opción preferida entre los desarrolladores.

Modelo de I/O asíncrono y no bloqueante

Una de las características más destacadas de Node.js es su modelo de entrada/salida (I/O) asíncrono y no bloqueante, basado en eventos. Esto permite que las aplicaciones manejen múltiples operaciones simultáneamente sin bloquear el hilo principal de ejecución. Como resultado, Node.js puede manejar miles de conexiones concurrentes con un uso mínimo de recursos.

Por ejemplo, al realizar una operación de lectura de archivo:

const fs = require('fs');

fs.readFile('/ruta/al/archivo.txt', 'utf8', (err, datos) => {
  if (err) throw err;
  console.log(datos);
});

console.log('Esta línea se ejecuta antes de que se complete la lectura del archivo');

En este código, la función readFile es asíncrona, lo que significa que el programa continúa ejecutándose sin esperar la finalización de la lectura del archivo.

Sistema de módulos

Node.js utiliza el sistema de módulos CommonJS, lo que facilita la organización y reutilización del código. Los desarrolladores pueden dividir su aplicación en múltiples módulos, cada uno en su propio archivo, y luego importarlos según sea necesario utilizando require.

Ejemplo de creación de un módulo:

// archivo matematicas.js
function sumar(a, b) {
  return a + b;
}

module.exports = sumar;

Y su posterior importación:

const sumar = require('./matematicas');

console.log(sumar(5, 3)); // Salida: 8

Módulos integrados

Node.js proporciona una serie de módulos integrados que ofrecen funcionalidades clave sin necesidad de instalar paquetes adicionales. Algunos de los módulos más utilizados incluyen:

• http: para crear servidores web y manejar solicitudes y respuestas HTTP.
• fs: para interactuar con el sistema de archivos.
• path: para manipular rutas de archivos y directorios.
• os: para obtener información sobre el sistema operativo.
• events: para trabajar con el patrón de diseño basado en eventos.

Estos módulos permiten construir aplicaciones completas y eficientes de manera rápida.

NPM: Gestor de paquetes

Node.js incorpora NPM (Node Package Manager), el gestor de paquetes más grande del mundo para aplicaciones JavaScript. NPM permite instalar, compartir y gestionar dependencias de proyectos. Con millones de paquetes disponibles, es posible agregar funcionalidades de manera sencilla.

Para instalar un paquete:

npm install nombre-del-paquete

Ecosistema de paquetes

El vasto ecosistema de paquetes de Node.js facilita el desarrollo de aplicaciones. Desde frameworks web como Express hasta librerías para bases de datos, autenticación, validación y más, los desarrolladores tienen a su disposición herramientas para prácticamente cualquier tarea.

Programación orientada a eventos

Node.js está construido en torno a un modelo orientado a eventos, lo que significa que responde a acciones o eventos, como la recepción de una solicitud o la finalización de una operación de I/O. El módulo events permite crear y manejar eventos personalizados.

Ejemplo utilizando EventEmitter:

const EventEmitter = require('events');

class MiEmisor extends EventEmitter {}

const miEmisor = new MiEmisor();

miEmisor.on('saludo', () => {
  console.log('¡Hola, mundo!');
});

miEmisor.emit('saludo');

Creación de servidores web

Con el módulo http, es posible crear servidores web sin necesidad de configuraciones adicionales. Esto permite desarrollar aplicaciones web y APIs rápidamente.

Ejemplo de un servidor HTTP básico:

const http = require('http');

const servidor = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader('Content-Type', 'text/plain');
  res.end('Respuesta del servidor');
});

servidor.listen(3000, () => {
  console.log('Servidor ejecutándose en el puerto 3000');
});

Soporte para aplicaciones en tiempo real

Node.js es ideal para aplicaciones en tiempo real que requieren un manejo eficiente de la concurrencia, como chats, juegos multijugador y aplicaciones de colaboración. Librerías como Socket.IO facilitan la implementación de comunicación bidireccional en tiempo real entre clientes y servidores.

Ejemplo de implementación con Socket.IO:

const io = require('socket.io')(servidor);

io.on('connection', (socket) => {
  console.log('Usuario conectado');

  socket.on('mensaje', (datos) => {
    io.emit('mensaje', datos);
  });
});

Streams y manejo de datos

Los streams permiten procesar datos que se reciben de forma secuencial, lo que es útil para manejar archivos grandes o datos entrantes de red sin cargar todo en memoria.

Tipos de streams:

• Readable: para leer datos.
• Writable: para escribir datos.
• Duplex: para leer y escribir datos.
• Transform: para modificar los datos mientras se leen o escriben.

Copiar un archivo utilizando streams:

const fs = require('fs');

const lectura = fs.createReadStream('origen.txt');
const escritura = fs.createWriteStream('destino.txt');

lectura.pipe(escritura);

Manejo de procesos hijo

El módulo child_process permite crear procesos hijo para ejecutar tareas en paralelo, aprovechando los núcleos múltiples de la CPU. Esto es útil para realizar operaciones intensivas sin bloquear el hilo principal.

Ejemplo de ejecución de un comando externo:

const { exec } = require('child_process');

exec('ls -la', (error, stdout, stderr) => {
  if (error) {
    console.error(`Error: ${error.message}`);
    return;
  }
  console.log(`Salida: ${stdout}`);
});

Módulo Cluster

El módulo cluster permite crear múltiples procesos hijo que comparten el mismo puerto del servidor, mejorando el rendimiento en sistemas de múltiples núcleos.

Uso básico del módulo cluster:

const cluster = require('cluster');
const http = require('http');
const numCPUs = require('os').cpus().length;

if (cluster.isPrimary) {
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }
} else {
  http.createServer((req, res) => {
    res.writeHead(200);
    res.end('Proceso manejado por worker');
  }).listen(8000);
}

Compatibilidad con bases de datos

Node.js puede conectarse a diversas bases de datos, tanto SQL como NoSQL. Librerías y drivers oficiales permiten interactuar con sistemas como MySQL, PostgreSQL, MongoDB, Redis, entre otros.

Ejemplo de conexión a MySQL:

const mysql = require('mysql');

const conexion = mysql.createConnection({
  host: 'localhost',
  user: 'usuario',
  password: 'contraseña',
  database: 'basedatos',
});

conexion.connect((err) => {
  if (err) throw err;
  console.log('Conectado a MySQL');
});

Herramientas para pruebas y depuración

Node.js cuenta con herramientas integradas y de terceros para pruebas y depuración. Módulos como assert para pruebas básicas y paquetes como Mocha y Jest facilitan el desarrollo de pruebas unitarias y de integración.

Ejemplo de uso del módulo assert:

const assert = require('assert');

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

assert.strictEqual(sumar(2, 3), 5, 'La suma debería ser 5');

Soporte para Promesas y async/await

Node.js soporta Promesas y la sintaxis de async/await, lo que simplifica el manejo de operaciones asíncronas y mejora la legibilidad del código.

Ejemplo utilizando async/await:

const fs = require('fs').promises;

async function leerArchivo() {
  try {
    const datos = await fs.readFile('/ruta/al/archivo.txt', 'utf8');
    console.log(datos);
  } catch (err) {
    console.error(err);
  }
}

leerArchivo();

Integración con TypeScript

Para proyectos que requieren un tipado estático y mayor robustez, Node.js se integra perfectamente con TypeScript. Esto permite detectar errores en tiempo de compilación y mejorar la mantenibilidad del código.

Ejemplo de un archivo TypeScript:

function saludar(nombre: string): string {
  return `Hola, ${nombre}`;
}

console.log(saludar('Carlos'));

Motor V8 de alto rendimiento

Node.js se basa en el motor V8 de Google, que convierte código JavaScript en código máquina nativo. Esto proporciona un rendimiento elevado, permitiendo que las aplicaciones sean rápidas y eficientes.

Amplia comunidad y soporte

La comunidad de Node.js es extensa y activa, lo que significa que hay una gran cantidad de recursos, tutoriales y soporte disponibles. Las aportaciones constantes de la comunidad garantizan que Node.js continúe evolucionando y adaptándose a las necesidades actuales del desarrollo.