Creación de aplicaciones CLI básicas con Node.js

Clase 22 de 26 • Curso de Node.js Avanzado

Resumen

Las aplicaciones de línea de comandos (CLI) están cobrando cada vez más importancia en el entorno de desarrollo, y Node.js facilita considerablemente su creación. Aprender a programar un CLI básico utilizando Node.js y sus herramientas esenciales optimizará las actividades cotidianas en la consola.

¿Qué es una aplicación CLI y para qué sirve?

Una aplicación CLI (Command Line Interface) es una herramienta ejecutable desde la terminal, ideal para tareas rápidas o repetitivas del desarrollador. Node.js no solo permite construir estas aplicaciones, sino que trae incorporado Node REPL, que simula una consola de JavaScript donde puedes probar rápidamente comandos y funciones.

Al ejecutar node en la terminal, se lanza una interfaz REPL que proporciona opciones tales como:

Ejecutar código JavaScript directamente.
Comandos para manipular archivos o código temporalmente.
Herramientas como break, clear, exit y más.

¿Cómo crear tu primera app CLI con Node.js?

Para empezar con una CLI básica, sigue estos pasos:

Crea una carpeta llamada CLI.
En esta carpeta, crea un archivo hello-cli.js.
Añade un comentario especial llamado Shibank al principio del archivo, indicando que será ejecutado con Node:

#!/usr/bin/env node

Este comentario especial orienta al sistema sobre cómo ejecutar el script.

Herramientas esenciales para la creación de CLIs en Node.js

Dos módulos fundamentales en Node.js para construir aplicaciones CLI son:

readline: permite obtener entradas desde la terminal.
process.argv: proporciona un arreglo con los argumentos con que se llamó al script.

Estos módulos son incluidos fácilmente en tu archivo de JavaScript:

const readline = require('readline');
const [nodeExecPath, scriptPath, ...args] = process.argv;

Cómo capturar y utilizar entradas por terminal

Utilizando readline, es posible realizar preguntas al usuario desde la CLI y capturar sus respuestas. Se configura creando una interfaz entre los streams de entrada y salida del proceso:

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

rl.question('Ingresa un número: ', numero => {
  console.log(`El número ingresado es: ${numero}`);
  rl.close();
  process.exit(0);
});

Este ejemplo muestra cómo se puede solicitar una entrada del usuario y manejarla adecuadamente.

Ejecución y permisos en sistemas operativos Unix

En sistemas operativos como Linux o Mac, es necesario asignar permisos de ejecución al archivo CLI:

chmod +x hello-cli.js

Luego, ejecuta el archivo directamente desde la terminal con:

./hello-cli.js

Si agregas argumentos, el script reconocerá y mostrará esas variables adicionales, por ejemplo:

./hello-cli.js parametro1=valor1 parametro2=valor2

¿Cómo trabajamos con señales para gestionar flujos?

Finalmente, las señales permiten responder a eventos como Ctrl+C. Escuchar estas señales en Node.js asegura un manejo de errores robusto en las aplicaciones CLI.

process.on('SIGINT', () => {
  console.log('Se recibió Ctrl+C.');
  process.exit(0);
});

Esta técnica permite controlar su aplicación CLI de manera fluida y eficaz.

Irving Juárez

student•

Esta modulo de readline ya lo habiamos utilizado antes para leer un archivo linea por linea. En ese momento se utilizo de esta manera:

const fs = require('fs');
const readLine = require('node:readline');
const path = require('path');
const { Transform, pipeline } = require('stream');

const readStream = fs.createReadStream(path.join(__dirname, 'linesInput.txt'), 'utf-8');
const writeStream = fs.createWriteStream(path.join(__dirname, 'linesOutput.txt'), 'utf-8');

const rl = readLine.createInterface({
    input: readStream,
    crlfDelay: Infinity
});

const processLineByLine = new Transform({
    transform(chunk, encoding, callback) {
        const newLine = `${chunk.toString().toUpperCase()} \n`;
        callback(null, newLine);
    }
})

pipeline(
    rl, 
    processLineByLine, 
    writeStream,
    (err) => {
        if (err) {
            console.error(err);
        } else {
            console.log('Pipeline completed');
        }
    }
);

Jimmy Foxx

student•

El código mostrado en el video no estaba atrapando la señal del CTRL+C, asi lo modifique un poco para que la misma instancia de readline ("rl") lo hiciera.

Sigo muy entretenido con el contenido de este curso, un saludo 👋

#!/usr/bin/env node

const readline = require('node:readline')
const {argv} = require('node:process')
const [nodeExecPath, scriptPath, ...args] = argv

console.log(`Ruta de Node: ${nodeExecPath}`)
console.log(`Ruta del script: ${scriptPath}`)
console.log(`Argumentos: ${args}`)

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
})

/**
 * SIGNAL HANDLER FOR CTRL+C
 */
rl.on('SIGINT', () => {
    console.log('\nCtrl+C detectado vía readline. Cerrando interfaz...');
    rl.close();
    process.exit(0);
});

/**
 * ENTER A NUMBER
 */
rl.question('Enter a number: ', (number)=>{
    console.log(`El número es: ${number}`)
    rl.close()
    process.exit(0)
})

Creación de aplicaciones CLI básicas con Node.js

Patrones de diseño en Node.js

Ventajas competitivas de Node.js para empresas

Principales patrones de diseño en JavaScript y Node.js

Implementación de patrones Singleton y Factory en JavaScript

Combinando patrones Singleton y Factory para crear un logger

Patrón Observer con Event Emitter en Node.js

Implementación del patrón middleware en Node.js sin Express

Decorators e inyección de dependencias en Node.js

Flujo de Datos con Node.js

Buffers y streams en Node.js: manejo eficiente de datos

Transformación de archivos con streams en Node.js

Event Loop en Node.js: fases y funcionamiento interno

Event Loop de Node.js: funcionamiento y orden de ejecución

Promise.all para ejecutar tareas asíncronas en paralelo

Debugging y Diagnóstico en Node.js

Depuración paso a paso con el inspector de Node.js

Diagnostic Channels para observabilidad en Node.js

Métricas de rendimiento en aplicaciones Node.js

Manejo global de errores y señales en Node.js

Configuración de logging con Pino en Node.js

Performance en Node.js

Análisis de performance de Node.js con métricas del event loop

Detección y solución de memory leaks en Node.js

Optimización de performance con Worker Threads y Child Processes

Caching con LRU para optimizar aplicaciones Node.js

Creando CLIs con Node.js