DW-2-Consolas y Terminales

Consolas y Terminales

¿Para qué sirven?

  1. Ejecución de Comandos: Ejecutar comandos del sistema operativo (programas y scripts).
  2. Gestión de Archivos y Directorios: Crear, mover, copiar y eliminar archivos y directorios.
  3. Automatización de Tareas: Crear y ejecutar scripts para automatizar tareas repetitivas.
  4. Desarrollo y Depuración: Compilar y ejecutar programas, manejar control de versiones.
  5. Administración del Sistema: Gestionar procesos, archivos y usuarios en el sistema.

Componentes de Consolas y Terminales

  1. Interfaz de Usuario: Donde se ingresan y se muestran los comandos y sus salidas.
  2. Shell: Intérprete de comandos que ejecuta los comandos ingresados.
  3. Motor de Procesamiento de Comandos: Analiza y ejecuta los comandos.
  4. Sistema de Archivos: Interactúa con el sistema de archivos para realizar operaciones.
  5. Utilidades y Herramientas: Conjunto de comandos y programas auxiliares.
  • Shell: Interpreta y ejecuta los comandos ingresados (ej., Bash, Zsh).
  • Prompt: Indica que la terminal está lista para recibir comandos.
  • Comandos: Instrucciones que el usuario escribe para realizar una acción.
  • Argumentos: Parámetros que se pasan a los comandos para especificar opciones o detalles adicionales.
  • Salida Estándar (stdout): Donde se muestran los resultados de los comandos.
  • Error Estándar (stderr): Donde se muestran los mensajes de error.
  • Entrada Estándar (stdin): Donde se reciben las entradas del usuario.

 

Librerías Utilizadas en el Desarrollo de Consolas y Terminales

  1. readline (Node.js): Interfaz para leer datos de una secuencia de entrada (stdin).
  2. xterm.js: Terminal embebida para aplicaciones web.
  3. blessed: Biblioteca para crear interfaces de usuario en la terminal.
  4.  commander: Para construir interfaces de línea de comandos.
  5. inquirer: Librería para crear interfaces de usuario interactivas en la línea de comandos.
  6. chalk: Estiliza la salida en la terminal con colores y otros atributos.
  7. shelljs: Para ejecutar comandos de shell en Node.js.

 

Estructura según Códigos de Programación

Ejemplo Básico de una Terminal Personalizada en JavaScript con Node.js:


// terminal.js
const readline = require('readline');

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

console.log('Custom Terminal');
rl.prompt();

rl.on('line', (line) => {
  switch(line.trim()) {
    case 'hello':
      console.log('Hello, World!');
      break;
    case 'exit':
      rl.close();
      break;
    default:
      console.log(`Unknown command: ${line.trim()}`);
      break;
  }
  rl.prompt();
}).on('close', () => {
  console.log('Exiting terminal');
  process.exit(0);
});

 

Lista de Consolas con sus Repositorios GitHub, URL, y CDN

  1. Windows Terminal

  2. ConEmu

  3. Hyper

  4. Terminator

  5. Alacritty

  6. iTerm2 (macOS)

 

Estructura Según Códigos de Programación

Ejemplo Básico de una Terminal en Node.js usando el módulo readline:


const readline = require('readline');

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

rl.question('Enter a command: ', (answer) => {
  console.log(`You entered: ${answer}`);
  rl.close();
});


Temario para Desarrollador de Consolas y Terminales 

  1.  Fundamentos de la Terminal y Shell:
    • Introducción a las terminales y shells.
    • Comandos básicos de la terminal (ls, cd, mkdir, rm, etc.).
    • Shell scripting básico.
    •  
  2. Programación en la Terminal:
    • Uso de readline en Node.js.
    • Creación de scripts interactivos con inquirer.
    • Construcción de CLI con commander.
    •  
  3. Estilización y Mejora de la Interfaz:
    • Uso de chalk para estilizar la salida.
    • Integración de figlet para texto ASCII.
    •  
  4. Automatización de Tareas:
    • Uso de shelljs para ejecutar comandos de shell.
    • Escribir scripts de automatización.
    •  
  5. Desarrollo de Terminales Avanzadas:
    • Estructura de proyectos de terminales complejas.
    • Implementación de características avanzadas como autocompletado y gestión de historial.
    • Pruebas y depuración de aplicaciones de terminal.

 

Ejemplo de un Proyecto Avanzado

Estructura del Proyecto: Go 


my-terminal-app/
├── bin/
│   └── cli.js
├── lib/
│   ├── commands.js
│   └── utils.js
├── package.json
└── README.md

Contenido de cli.js: 


#!/usr/bin/env node
const program = require('commander');
const { executeCommand } = require('../lib/commands');

program
  .version('1.0.0')
  .description('My Terminal App');

program
  .command('run <cmd>')
  .description('Run a command')
  .action((cmd) => {
    executeCommand(cmd);
  });

program.parse(process.argv);

 

Contenido de commands.js: 


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

function executeCommand(cmd) {
  exec(cmd, (error, stdout, stderr) => {
    if (error) {
      console.error(`Error: ${error.message}`);
      return;
    }
    if (stderr) {
      console.error(`Stderr: ${stderr}`);
      return;
    }
    console.log(`Output: ${stdout}`);
  });
}

module.exports = {
  executeCommand
};

...