En el desarrollo con Node.js es común utilizar módulos nativos como process, path, fs, stream y http. Estos proporcionan funcionalidades esenciales sin necesidad de paquetes externos. A continuación se muestran ejemplos reescritos con nombres de variibles alternativos y explicaciones claras.

Módulo path

Sirve para manipular rutas de archivos de forma segura e independiente del sistema operativo.

const path = require('path');

// Unir segmentos en una ruta
const rutaRelativa = path.join('plantilla', 'modulos', 'utilidades', 'herramienta.js');
// Resultado: plantilla/modulos/utilidades/herramienta.js

// Resolver ruta absoluta desde el directorio de trabajo
const rutaAbsoluta = path.resolve('datos', 'config', 'db.json');
// Ejemplo de salida: /home/usuario/proyecto/datos/config/db.json

// Obtener el último componente de una ruta
console.log(path.basename('scripts/app.js'));   // app.js
console.log(path.basename('scripts/app.js', '.js')); // app
console.log(path.basename('scripts/app.js', '.json')); // app.js

// Directorio contenedor
console.log(path.dirname('scripts/app.js')); // scripts
console.log(path.dirname('scripts/middleware/auth.js')); // scripts/middleware

// Extensión del archivo
console.log(path.extname('scripts/app.js')); // .js
console.log(path.extname('README.md'));      // .md

Módulo process

Proporciona información sobre el proceso actual y el entorno de ejecución.

const process = require('process');

// Argumentos enviados desde la terminal
const argumentos = process.argv.slice(2);

// Variable de entorno personalizada (ejemplo)
const apiBaseURL = process.env.API_BASE;

// Plataforma del sistema operativo
const plataforma = process.platform;

Sistema de archivos (fs)

Permite leer, escribir y manipular archivos.

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

// Información de un archivo o directorio
fs.stat('./iconos.js', (err, stats) => {
  if (!err) console.log(stats);
});

// Listar contenido de un directorio
fs.readdir('./src', (error, archivos) => {
  if (!error) console.log(archivos);
});

// Leer un archivo (ruta construida con process.cwd())
fs.readFile(
  path.join(process.cwd(), 'package.json'),
  'utf-8',
  (error, contenido) => {
    if (!error) console.log(contenido);
  }
);

// Escribir un archivo JSON con datos de ejemplo
const contenidoJson = `[
  { "id": 1, "nombre": "Elemento A" },
  { "id": 2, "nombre": "Elemento B" }
]`;
fs.writeFile(
  path.join(process.cwd(), 'salida.json'),
  contenidoJson,
  (error) => {
    if (error) console.error('Error al escribir:', error);
  }
);

Streams

Los flujos permtien procesar datos de manera eficiente, fragmento a fragmento.

const fs = require('fs');

// Lectura de un archivo mediante stream
const lector = fs.createReadStream('./package.json', 'utf-8');
lector.on('data', (trozo) => {
  console.log('Nuevo fragmento:');
  console.log(trozo);
});
lector.on('end', () => console.log('Lectura finalizada.'));
lector.on('error', (err) => console.error('Error:', err));

// Escritura con streams
const escritor1 = fs.createWriteStream('salida1.txt', 'utf-8');
escritor1.write('Línea uno del stream\n');
escritor1.write('Línea final.');
escritor1.end();

const escritor2 = fs.createWriteStream('salida2.txt');
escritor2.write(Buffer.from('Datos binarios con Buffer\n', 'utf-8'));
escritor2.write(Buffer.from('Fin.', 'utf-8'));
escritor2.end();

// Tubería: copiar contenido de un stream a otro
fs.createReadStream('./salida1.txt')
  .pipe(fs.createWriteStream('./copia.txt'));

Servidor HTTP

El módulo http permite crear servidores web ligeros.

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

// Servidor simple con respuesta estática
const serverBasico = http.createServer((peticion, respuesta) => {
  console.log(`${peticion.method} ${peticion.url}`);
  respuesta.writeHead(200, { 'Content-Type': 'text/html' });
  respuesta.end('<h1>Hola desde Node.js</h1>');
});
serverBasico.listen(8080, () => {
  console.log('Servidor corriendo en http://127.0.0.1:8080');
});

// Servidor de archivos estáticos (reescrito con otros nombres)
const directorioRaiz = path.resolve(process.argv[2] || '.');
console.log(`Sirviendo desde: ${directorioRaiz}`);

const servidorArchivos = http.createServer((peticion, respuesta) => {
  const rutaRequerida = url.parse(peticion.url).pathname;
  const rutaLocal = path.join(directorioRaiz, rutaRequerida);

  fs.stat(rutaLocal, (error, stat) => {
    if (!error && stat.isFile()) {
      console.log(`200 ${peticion.url}`);
      respuesta.writeHead(200);
      fs.createReadStream(rutaLocal).pipe(respuesta);
    } else {
      console.log(`404 ${peticion.url}`);
      respuesta.writeHead(404);
      respuesta.end('404 Recurso no encontrado');
    }
  });
});
servidorArchivos.listen(8081, () => {
  console.log('Servidor de archivos en http://127.0.0.1:8081/');
});