OS

Clase 18 de 31 • Curso de Fundamentos de Node.js

Contenido del curso

Conocer los conceptos básicos de NodeJS

Cómo manejar la asincronía

Entender los módulos del core

Utilizar los módulos y paquetes externos

Conocer trucos que no quieren que sepas

Manejar herramientas con Node

Tomar examen

Resumen

¿Cómo se accede a la información del sistema operativo usando Node.js?

Node.js ofrece un módulo llamado 'os' que permite acceder a una serie de características del sistema operativo que usualmente estarían reservadas para lenguajes de bajo nivel. Estas funcionalidades son de gran utilidad para desarrolladores que necesitan interactuar con la memoria RAM, el número de cores de la CPU, el tipo de sistema de archivos, entre otras cosas. A continuación te mostramos cómo puedes explorar y utilizar estas capacidades.

¿Cómo se obtiene la arquitectura de la máquina?

La arquitectura de la máquina indica si estás trabajando con un sistema de 32 o 64 bits, y esto puede influir en la manera en la que compilamos o ejecutamos algunos módulos nativos. Para obtener esta información en Node.js, utilizamos el método os.arch().

const os = require('os');
console.log(os.arch()); 
// Salida esperada: 'x64' (para 64 bits) o 'x32'/'x86' (para 32 bits)

¿Cómo se identifica la plataforma?

Conocer la plataforma sobre la que tu código corre puede ser esencial, especialmente si tu software requiere ejecutar comandos específicos de un sistema operativo. El método os.platform() te proporciona esta información:

console.log(os.platform()); 
// Salida esperada: 'linux', 'win32', 'darwin', etc.

¿Cómo se accede a la información de las CPUs?

Saber cuántos núcleos tiene tu procesador y cómo se están utilizando puede ayudar a optimizar el rendimiento de tus aplicaciones. Node.js te permite acceder a esta información con os.cpus():

console.log(os.cpus());
// Proporciona detalles sobre cada núcleo de la CPU, como su modelo y velocidad.

¿Cómo se monitorea la memoria disponible?

Cuando desarrollamos aplicaciones que requieren gran cantidad de memoria, es crucial saber cuánta memoria libre hay disponible y cuál es su capacidad total. Puedes utilizar os.freemem() y os.totalmem() para esto:

console.log(`${os.freemem()} bytes de memoria libre`);
console.log(`${os.totalmem()} bytes de memoria total`);

¿Cuáles son las constantes y señales del sistema?

Node.js ofrece una lista de constantes del sistema que pueden ser vitales al trabajar con procesos a muy bajo nivel. El método os.constants te proporciona una serie de señas y códigos de error clave:

console.log(os.constants);
// Muestra las diferentes señales y errores del sistema.

¿Cómo se obtienen directorios usuario y temporales?

Saber dónde almacenar archivos temporales o específicos del usuario es esencial para evitar errores o pérdida de información. Node.js nos da acceso a esta información con os.homedir() y os.tmpdir().

console.log(os.homedir()); // Directorio raíz del usuario
console.log(os.tmpdir());  // Directorio para archivos temporales

¿Qué es el nombre del host y cómo se usan las interfaces de red?

Cuando se trabaja con redes, conocer el nombre del host y las interfaces de red disponibles puede ser crítico. Node.js te proporciona los métodos os.hostname() y os.networkInterfaces() para obtener esta información:

console.log(os.hostname()); // Nombre del host
console.log(os.networkInterfaces()); // Detalles de las interfaces de red

Este módulo de 'os' en Node.js nos permite realizar tareas más avanzadas en nuestras aplicaciones, haciendo posible el desarrollo de software que interactúa eficientemente con el sistema operativo. Con estas herramientas, estás mejor equipado para enfrentar desafíos de desarrollo a un nivel más profundo. ¡Sigue explorando y aprendiendo!

Esteban Martini

student•

en vez de avanzar con el curso me puse a hacer un mini cli para conocer la info del sistema, ajajjaa... falta encapsular la mayoria de la info, asi que les dejo para que juegen:

const os = require("os");
const readline = require("readline");

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

rl.on("close", function () {
  console.log("\nBYE BYE !!!");
  process.exit(0);
});

const printOptions = () => {
  console.log("**********************************************");
  console.log("         tyny system info.                    ");
  console.log("**********************************************");
  console.log("choice an option:");

  rl.question(
    `
  1. Architecture Info.
  x. exit
  
  `,
    handleResponse
  );
};

const askMore = () => {
  rl.question("More info...? (S/n)", function (res) {
    res !== "n" ? printOptions() : process.exit(0);
  });
};

const handleResponse = (opt) => {
  switch (opt) {
    case "1":
      gralInfo();
      askMore();
      break;
    case "x":
      rl.close();
    default:
      console.log("opcion no valida");
      printOptions();
      break;
  }
};

const gralInfo = () => {
  // Architecture
  console.log("**********************************************");
  console.log("         GRAL INFO                            ");
  console.log("**********************************************");

  console.log("Architecture:", os.arch());

  // Platform
  console.log("Platform:", os.platform());
};

const allInfo = () => {
  // cpus
  console.log("cpus");
  console.log(os.cpus().length);
  console.log("");

  // Errores y se?ales del sistema
  console.log("Erros and signals of the system");
  console.log(os.constants);
  console.log("");

  // Function to convert from bytes to kbytes, mbytes and gbytes
  const SIZE = 1024;

  kb = (bytes) => {
    return bytes / SIZE;
  };
  mb = (bytes) => {
    return kb(bytes) / SIZE;
  };
  gb = (bytes) => {
    return mb(bytes) / SIZE;
  };

  // Total Ram Memory
  console.log("Total Ram Memory:");
  console.log(`${os.totalmem()} bytes`);
  console.log(`${kb(os.totalmem())} kb`);
  console.log(`${mb(os.totalmem())} mb`);
  console.log(`${gb(os.totalmem())} gb`);
  console.log("");

  // Free memory we have in bytes units
  console.log("Free memory we have in kbytes units");
  console.log(`free Ram memory: ${os.freemem()} bytes`);
  console.log(`free Ram memory: ${kb(os.freemem())} kb`);
  console.log(`free Ram memory: ${mb(os.freemem())} mb`);
  console.log(`free Ram memory: ${gb(os.freemem())} mb`);
  console.log("");

  // Directory for the user root
  console.log("Directory for the user root");
  console.log(os.homedir());
  console.log("");

  // Directory for temporal files
  console.log("Directory for temporal files");
  console.log(os.tmpdir());
  console.log("");

  // Hostname of a server
  console.log("Hostname of any server");
  console.log(os.hostname());
  console.log("");

  // Actived Network interfaces right now
  console.log("Network Interfaces right now");
  console.log(os.networkInterfaces());
  console.log("");
};

function initialize() {
  printOptions();
}

initialize();

Nicolas Esteban Prieto Sarmiento

Rodolfo Ugalde Ochoa

Julio Flores

Enmanuel Castillo

ANTHONY JEAMPIER RANGEL RODRIGUEZ

Sebastian Amaya

Alejandro Giraldo Londoño

Daniel Said Rodríguez Ortiz

Jorge Fidel Zubieta Choque

Jesus David Urquijo Corredor

Gagandeep Dass

Juan Esteban Deossa Pertuz

Miguel Angel Reyes Moreno

Eduardo Rodriguez

Roberto Pérez Favela

Ginnio Sarabia

Jonathan Buitrago Roncancio

Uriel Mojica Mejía

Juan Jose Vega

Rodrigo Andrés Moreno Pertúz

Roberto Shirásago Domínguez

Miguel Angel Muñoz Pozos

Francisco Garcia [C6]

Abigail Perez

Cristian Mauricio Cavanzo Arias

Jossie Steeven Quintero Giron

Wilson Fernando Antury Torres

Omar Dario Melendrez

OS

Conocer los conceptos básicos de NodeJS

Instalación de Node.js

Node: orígenes y filosofía

EventLoop: asíncrona por diseño

Monohilo: implicaciones en diseño y seguridad

Configurar las variables de entorno en Node.js

Herramientas para ser más felices: Nodemon y PM2

Cómo manejar la asincronía

Callbacks

Callback Hell: refactorizar o sufrir

Promesas

Async/await

Entender los módulos del core

Globals

File system

Console

Errores (try / catch)

Procesos hijo

Módulos nativos en C++

HTTP

OS

Process

Utilizar los módulos y paquetes externos

Gestión de paquetes: NPM y package.json

Construyendo módulos: Require e Import

Módulos útiles

Datos almacenados vs en memoria

Buffers

Streams

Conocer trucos que no quieren que sepas

Benchmarking (console time y timeEnd)

Debugger

Error First Callbacks

Manejar herramientas con Node

Scraping

Automatización de procesos

Aplicaciones de escritorio