Tutorial Node: Introducción a Node.js

¿Qué es Node.js y qué diferencia hay con JavaScript y Express?

Node.js es un entorno de ejecución de JavaScript construido sobre el motor V8 de Google Chrome. Permite ejecutar código JavaScript en el lado del servidor, lo que extiende las capacidades del lenguaje más allá del navegador web. Gracias a Node.js, es posible desarrollar aplicaciones de red escalables y de alto rendimiento utilizando JavaScript en el backend.

Mientras que JavaScript es un lenguaje de programación interpretado que tradicionalmente se ha utilizado en el lado del cliente para manipular páginas web, con Node.js se puede utilizar el mismo lenguaje para construir aplicaciones del lado del servidor. Esto unifica el desarrollo frontend y backend bajo un mismo lenguaje, facilitando la transición y la colaboración entre ambos entornos.

Una de las características clave de Node.js es su modelo de E/S no bloqueante y orientado a eventos, lo que lo hace ligero y eficiente para aplicaciones en tiempo real y de datos intensivos. Esto difiere del uso típico de JavaScript en el navegador, donde el enfoque principal es la manipulación del DOM y la interacción del usuario.

Por otro lado, Express es una framework web minimalista y flexible para Node.js. Proporciona un conjunto de características robustas para desarrollar aplicaciones web y API. Mientras que Node.js ofrece las herramientas básicas para crear un servidor, Express simplifica el proceso al proporcionar métodos y middleware que facilitan la gestión de solicitudes HTTP, el enrutamiento y la renderización de vistas.

La diferencia fundamental entre Node.js y Express radica en que Node.js es el entorno de ejecución que permite ejecutar JavaScript en el servidor, mientras que Express es un framework que se ejecuta sobre Node.js para agilizar y simplificar el desarrollo de aplicaciones web. Express utiliza las funcionalidades nativas de Node.js y las extiende, permitiendo a los desarrolladores centrarse en la lógica de la aplicación sin preocuparse por configuraciones complejas del servidor.

Instalando Node.js: tu motor de JavaScript en el servidor

Para comenzar a desarrollar aplicaciones con Node.js, es crucial instalar el entorno en tu máquina local. Node.js es compatible con los sistemas operativos más comunes: Windows, macOS y Linux. A continuación, se detallan los pasos para cada plataforma, asegurando una instalación correcta y actualizada.

Instalación en Windows

La instalación de Node.js en Windows se realiza mediante el instalador oficial:

1. Visita la página oficial de Node.js en https://nodejs.org y descarga el instalador para Windows, asegurándote de seleccionar la versión LTS (Long Term Support) más reciente.

2. Ejecuta el archivo descargado y sigue las instrucciones del asistente de instalación. Es recomendable mantener las opciones predeterminadas para configurar adecuadamente el entorno de desarrollo.
3. Una vez completada la instalación, verifica que Node.js se ha instalado correctamente abriendo el Símbolo del sistema y ejecutando el comando:

   node -v

Este comando mostrará la versión de Node.js instalada en tu sistema, confirmando que todo está en orden.

Instalación en macOS

En macOS, una de las formas más recomendadas de instalar Node.js es utilizando Homebrew, un gestor de paquetes que simplifica la instalación y actualización de software:

• Si aún no tienes Homebrew instalado, abre la Terminal y ejecuta el siguiente comando para instalarlo:

   /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

• Una vez instalado Homebrew, instala Node.js ejecutando:

   brew install node

• Verifica la instalación comprobando la versión de Node.js:

   node -v

Así confirmarás que Node.js está listo para su uso en tu sistema macOS.

Instalación en Linux

En Linux, especialmente en distribuciones basadas en Debian como Ubuntu, puedes instalar Node.js utilizando el gestor de paquetes APT:

• Añade el repositorio de NodeSource, que proporciona paquetes actualizados de Node.js. Ejecuta en la Terminal:

   curl -fsSL https://deb.nodesource.com/setup_lts.x | sudo -E bash -

• Instala Node.js con el siguiente comando:

   sudo apt-get install -y nodejs

• Comprueba la versión instalada para asegurar que todo está correcto:

   node -v

Este comando mostrará la versión de Node.js instalada en tu sistema.

Para otras distribuciones de Linux, consulta la documentación oficial de Node.js para obtener instrucciones específicas.

Uso de nvm para gestionar versiones de Node.js

Una alternativa versátil para instalar Node.js es utilizar nvm (Node Version Manager), una herramienta que permite gestionar múltiples versiones de Node.js en el mismo sistema. Esto es especialmente útil si necesitas trabajar con diferentes versiones para distintos proyectos.

Para instalar nvm, sigue estos pasos:

• Descarga e instala nvm ejecutando el siguiente script en tu Terminal (compatible con macOS y Linux):

   curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.1/install.sh | bash

• Cierra y vuelve a abrir la Terminal o recarga tu perfil de shell ejecutando:

   source ~/.bashrc

o para zsh:

   source ~/.zshrc

• Instala la versión LTS más reciente de Node.js con nvm:

   nvm install --lts

• Verifica que la instalación ha sido exitosa comprobando la versión:

   node -v

Con nvm, puedes cambiar fácilmente entre versiones de Node.js según lo necesites, lo que proporciona flexibilidad en tu entorno de desarrollo.

Es importante destacar que, junto con Node.js, también se instala npm (Node Package Manager), que es el gestor de paquetes oficial para Node.js. npm te permite instalar y gestionar dependencias y módulos necesarios para tus proyectos, facilitando el desarrollo y la compartición de código.

Entorno de desarrollo ideal: configuración de VS Code y Node.js

Para maximizar la eficiencia en el desarrollo con Node.js, es fundamental configurar un entorno de desarrollo integrado (IDE) robusto y personalizado. Visual Studio Code (VS Code) es una de las herramientas más populares y versátiles para este propósito, gracias a su flexibilidad y amplia gama de extensiones.

Comienza por descargar e instalar VS Code desde su sitio oficial: https://code.visualstudio.com/. Una vez instalado, es momento de ajustar su configuración para optimizar el desarrollo con Node.js.

Extensiones esenciales para Node.js

Para potenciar VS Code en el desarrollo con Node.js, es recomendable instalar ciertas extensiones que facilitan tareas comunes y mejoran la productividad.

• Node Extension Pack: Este paquete incluye un conjunto de extensiones útiles, como npm Intellisense, **Version Lens ** y ESLint.
• ESLint: Ayuda a mantener un código limpio y consistente aplicando reglas de estilo y señalando errores de sintaxis.
• Prettier - Code formatter: Formatea automáticamente el código siguiendo estándares definidos, mejorando la legibilidad.
• npm Intellisense: Provee autocompletado para los módulos de npm, agilizando la importación de paquetes.

Para instalar una extensión, ve al panel de Extensiones en VS Code (icono de cuadrados en la barra lateral izquierda), busca el nombre de la extensión y haz clic en Instalar.

Configuración de Prettier +  ESLint

Para mantener un código consistente y aplicar buenas prácticas, usaremos la combinación moderna de Prettier (formateo) y ESLint (análisis de código). Esta configuración es el estándar de facto en la comunidad JavaScript actual. 

Instalación

Instala las dependencias necesarias en tu proyecto:

npm install --save-dev eslint prettier eslint-config-prettier eslint-plugin-prettier

Configuración de ESLint

Crea un archivo .eslintrc.json en la raíz de tu proyecto:

{
  "env": {
    "es2021": true,
    "node": true
  },
  "extends": [
    "eslint:recommended",
    "prettier"
  ],
  "plugins": ["prettier"],
  "rules": {
    "prettier/prettier": "error"
  }
}

Configuración de Prettier

Crea un archivo .prettierrc en la raíz de tu proyecto:

{
  "semi": true,
  "trailingComma": "es5",
  "singleQuote": true,
  "printWidth": 80,
  "tabWidth": 2
}

Scripts en package.json

Agrega estos scripts a tu package.json:

{
  "scripts": {
    "lint": "eslint .",
    "lint:fix": "eslint . --fix",
    "format": "prettier --write ."
  }
}

Integración con VS Code

• Instala las extensiones (Ctrl+Shift+X) ESLint y Prettier - Code Formatter, y configura VS Code para formatear al guardar:
  • Abre la paleta de comandos (Ctrl+Shift+P o Cmd+Shift+P).
  • Escribe "Formatear documento con..." y selecciona la opción.
  • Elige "Prettier - Code formatter" de la lista.
  • VS Code te preguntará si quieres usarlo como predeterminado para ciertos lenguajes. Haz clic en "Configurar..." y selecciona "Prettier - Code formatter" para los lenguajes que uses (JavaScript, TypeScript, etc.).
• Habilita “Formatear al guardar”:
  • Abre la configuración de VS Code (Ctrl+, o Cmd+,).
  • Busca la opción "Editor: Formatear al guardar" (**editor.formatOnSave**).
  • Marca la casilla para habilitar esta opción. Esto hará que Prettier formatee tu código automáticamente cada vez que guardes un archivo.

La extensión de ESLint debería detectar automáticamente tu configuración de ESLint (.eslintrc.js o .eslintrc.json) y el plugin eslint-plugin-prettier. Al configurar previamente la regla 'prettier/prettier': 'error' (o 'warn') en tu archivo de configuración de ESLint, la extensión de ESLint mostrará los problemas de formato detectados por Prettier directamente en el editor como errores o advertencias.

• Verificación:

1. Abre un archivo de código en tu proyecto (por ejemplo, un archivo .js o .ts).
2. Intenta desordenar un poco el formato del código (espacios, sangría, comillas, etc.).
3. Si habilitaste "Formatear al guardar": Guarda el archivo (Ctrl+S o Cmd+S). El código debería reformatearse automáticamente según las reglas de Prettier.
4. Si no habilitaste "Formatear al guardar": Haz clic derecho en el editor y selecciona "Formatear documento" (Shift+Alt+F en Windows/Linux o Shift+Option+F en macOS). El código debería formatearse con Prettier.
5. La extensión de ESLint debería analizar tu código y mostrar cualquier error o advertencia (incluyendo los problemas de formato reportados por eslint-plugin-prettier) en la ventana de "Problemas" de VS Code (Ver > Problemas).

¡Listo! Con estos pasos, tendrás ESLint y Prettier integrados en VS Code para ayudarte a mantener un código limpio y consistente. La extensión de ESLint te señalará los problemas, y Prettier se encargará de aplicar el estilo automáticamente al guardar o formatear manualmente.

Primer script en Node.js: de cero a la primera ejecución

Ahora que tienes Node.js instalado y tu entorno de desarrollo configurado, es momento de escribir y ejecutar tu primer script en Node.js. Este primer ejercicio te permitirá familiarizarte con la ejecución de código JavaScript en el servidor y comprender cómo Node.js gestiona los scripts.

Creando el directorio del proyecto

Comienza por crear una nueva carpeta para tu proyecto. Esto te ayudará a organizar tu código y facilitará la gestión de archivos. En tu terminal, navega hasta el directorio donde deseas crear el proyecto y ejecuta:

mkdir mi-primer-proyecto
cd mi-primer-proyecto

Esta secuencia crea una carpeta llamada mi-primer-proyecto y cambia el directorio actual a esta nueva carpeta.

Inicializando el proyecto con npm

Aunque no es estrictamente necesario para un script simple, es una buena práctica inicializar el proyecto con npm para gestionar futuras dependencias. Ejecuta el siguiente comando:

npm init -y

Este comando crea un archivo package.json básico con la configuración predeterminada, lo que será útil más adelante para añadir paquetes y scripts.

Escribiendo tu primer script

Utiliza Visual Studio Code o tu editor de texto preferido para crear un nuevo archivo llamado app.js dentro de la carpeta del proyecto. En este archivo, escribe el siguiente código:

console.log('¡Hola, Node.js!');

Este sencillo script utiliza console.log para imprimir un mensaje en la consola, demostrando cómo Node.js ejecuta código JavaScript en el lado del servidor.

Ejecutando el script con Node.js

Para ejecutar tu script, asegúrate de que estás en el directorio del proyecto en tu terminal y ejecuta el comando:

node app.js

Deberías ver en la consola el mensaje:

¡Hola, Node.js!

Este resultado confirma que Node.js ha ejecutado tu script correctamente, mostrando en pantalla el mensaje definido.

Explorando el objeto global

A diferencia de JavaScript en el navegador, en Node.js dispones de objetos y funciones adicionales. Modifica tu app.js para explorar algunas de estas funcionalidades:

console.log('Directorio actual:', __dirname);
console.log('Nombre del archivo:', __filename);

Al ejecutar de nuevo node app.js, el resultado será:

Directorio actual: /ruta/a/tu/proyecto/mi-primer-proyecto
Nombre del archivo: /ruta/a/tu/proyecto/mi-primer-proyecto/app.js

Aquí, __dirname y __filename son variables globales en Node.js que proporcionan información sobre el directorio y el archivo actual, lo que es útil para gestionar rutas y archivos en tus aplicaciones.

Trabajando con módulos nativos

Node.js incluye una serie de módulos nativos que puedes utilizar sin necesidad de instalar dependencias adicionales. Por ejemplo, el módulo os proporciona información sobre el sistema operativo. Añade el siguiente código a tu app.js:

const os = require('os');

console.log('Sistema operativo:', os.platform());
console.log('Arquitectura del CPU:', os.arch());
console.log('Memoria libre:', os.freemem());

Al ejecutar el script, obtendrás detalles sobre tu sistema, aprovechando los módulos incorporados de Node.js.

Ejecutando scripts con parámetros

Puedes pasar argumentos a tu script desde la línea de comandos. Modifica app.js para acceder a los parámetros proporcionados:

const args = process.argv.slice(2);

console.log('Argumentos ingresados:', args);

Ejecuta el script con argumentos:

node app.js primer_parametro segundo_parametro

El resultado será:

Argumentos ingresados: [ 'primer_parametro', 'segundo_parametro' ]

La propiedad process.argv es un array que contiene los argumentos proporcionados al script, lo que permite personalizar el comportamiento de tu aplicación según las entradas del usuario.

Manejando funciones asíncronas

Aunque profundizaremos en la asincronía más adelante, es interesante ver un ejemplo básico utilizando setTimeout:

console.log('Mensaje mostrado inmediatamente.');

setTimeout(() => {
  console.log('Mensaje mostrado después de 2 segundos.');
}, 2000);

Al ejecutar node app.js, observarás que el primer mensaje se muestra de inmediato, y tras 2 segundos, aparece el segundo mensaje. Esto demuestra cómo Node.js maneja operaciones asíncronas sin bloquear el flujo principal de ejecución.

Utilizando importaciones modernas (ECMAScript Modules)

Con las versiones más recientes de Node.js, es posible utilizar la sintaxis de módulos ECMAScript (import y export). Para habilitar esta funcionalidad, modifica tu package.json para especificar el tipo de módulo:

{
  "name": "mi-primer-proyecto",
  "version": "1.0.0",
  "type": "module",
  "main": "app.js",
  "scripts": {
    "start": "node app.js"
  },
  "author": "",
  "license": "ISC"
}

Importante: Los módulos ECMAScript (ESM) son el futuro de JavaScript. A diferencia de CommonJS (`require()`), ESM usa `import/export` y es el estándar moderno. Node.js v22 tiene excelente soporte para ESM.

Para usar ESM, asegúrate de tener `"type": "module"` en tu package.json:

import os from 'os';

console.log('Hostname:', os.hostname());

Ejecuta el script con:

npm start

Esta configuración te permite aprovechar las características modernas de JavaScript en Node.js, manteniendo tu código actualizado y limpio.

Creando scripts en package.json

Para simplificar la ejecución de tu aplicación, puedes definir un script en el package.json. Como ya agregamos "start": "node app.js" en la sección scripts, puedes iniciar tu aplicación simplemente con:

npm start

Esto ejecuta el comando definido, facilitando el proceso y estandarizando la forma de iniciar tu proyecto.