Cheatsheet de Node.js

Node.js es un entorno de ejecución de JavaScript que se utiliza principalmente para crear servidores, manejar peticiones HTTP, y construir aplicaciones de backend.

Instalación en Windows

Descargar el instalador de Node.js desde nodejs.org.

Instalación en Linux

Para instalar Node.js en Ubuntu:

sudo apt update
sudo apt install nodejs npm

Instalación en macOS

Usar Homebrew para instalar Node.js:

brew install node

Verifica instalación

node --version
npm --version

Crear un proyecto Node.js

Inicia un nuevo proyecto y crea un archivo package.json.

npm init

Para saltar preguntas y usar valores predeterminados, puedes usar:

npm init -y

Instalar dependencias

Instala dependencias necesarias para el proyecto.

npm install nombre-paquete

Instalar dependencias de desarrollo

Dependencias útiles para el entorno de desarrollo, como linters o herramientas de testing.

npm install --save-dev nombre-paquete

Ejecutar un archivo Node.js

node archivo.js

Node.js usa módulos ECMAScript (import/export) para manejar la reutilización de código.

Importar módulos nativos

Para importar un módulo nativo de Node.js, se utiliza la siguiente sintaxis:

import { createServer } from 'node:http';

Importar módulos externos

Si instalas un módulo externo con npm, puedes importarlo:

import express from 'express';

Exportar funciones o variables

Para exportar contenido de un módulo, usa export:

export function miFuncion() {
  // código
}

export const miConstante = 42;

Importar todo el módulo

import * as fs from 'node:fs';

Node.js incluye el módulo node:fs (File System) para trabajar con archivos y directorios.

Leer un archivo de forma síncrona

import { readFileSync } from 'node:fs';

const data = readFileSync('archivo.txt', 'utf-8');
console.log(data);

Leer un archivo de forma asíncrona

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

async function leerArchivo() {
  const data = await readFile('archivo.txt', 'utf-8');
  console.log(data);
}

leerArchivo();

Escribir en un archivo de forma síncrona

import { writeFileSync } from 'node:fs';

writeFileSync('archivo.txt', 'Contenido nuevo');

Escribir en un archivo de forma asíncrona

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

await writeFile('archivo.txt', 'Contenido nuevo');

El módulo node:http es fundamental para crear servidores web en Node.js.

Servidor HTTP básico

import { createServer } from 'node:http';

const server = createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('Hola, mundo\n');
});

server.listen(3000, () => {
  console.log('Servidor corriendo en http://localhost:3000');
});

Manejo de diferentes rutas

import { createServer } from 'node:http';

const server = createServer((req, res) => {
  if (req.url === '/') {
    res.writeHead(200, { 'Content-Type': 'text/plain' });
    res.end('Página de inicio');
  } else if (req.url === '/about') {
    res.writeHead(200, { 'Content-Type': 'text/plain' });
    res.end('Acerca de');
  } else {
    res.writeHead(404, { 'Content-Type': 'text/plain' });
    res.end('Página no encontrada');
  }
});

server.listen(3000);

Node.js soporta el uso de promesas y async/await para manejar código asíncrono de manera más legible.

Promesas

const promesa = new Promise((resolve, reject) => {
  const success = true;
  if (success) {
    resolve('Operación exitosa');
  } else {
    reject('Error en la operación');
  }
});

promesa
  .then((mensaje) => {
    console.log(mensaje);
  })
  .catch((error) => {
    console.log(error);
  });

Async/Await

async function ejemploAsync() {
  try {
    const resultado = await promesa;
    console.log(resultado);
  } catch (error) {
    console.log(error);
  }
}

ejemploAsync();

Node.js usa un sistema de eventos y streams para manejar datos.

Creación de un emisor de eventos

import { EventEmitter } from 'node:events';

const emisor = new EventEmitter();

emisor.on('evento', () => {
  console.log('Evento disparado');
});

emisor.emit('evento');

Leer un archivo como stream

import { createReadStream } from 'node:fs';

const stream = createReadStream('archivo.txt', 'utf-8');

stream.on('data', (chunk) => {
  console.log(chunk);
});

stream.on('end', () => {
  console.log('Lectura completada');
});

Escribir en un archivo como stream

import { createWriteStream } from 'node:fs';

const stream = createWriteStream('archivo.txt');

stream.write('Escribiendo datos en un archivo\n');
stream.end('Finalizando el archivo');

Try/Catch

try {
  throw new Error('Ha ocurrido un error');
} catch (error) {
  console.error(error.message);
}

Manejo de errores en código asíncrono

async function ejemploAsyncConErrores() {
  try {
    const resultado = await promesaFallida();
  } catch (error) {
    console.log('Error capturado:', error.message);
  }
}

ejemploAsyncConErrores();