OS

Excelente clase!!! OMG, its so incredible all these things.
Les dejo para quienes deseen mis apuntes del video con algunos comentarios a lo programador, o sea, casi lo mismo xd:

const os = require('os')

// Architecture
console.log('Architecture:')
console.log(os.arch())
console.log('')

// Platform
console.log('Platform:')
console.log(os.platform())
console.log('')

// 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('')

RESUMEN:

El modulo de Node para OS me permite acceder a elementos de muy bajo nivel, y es útil en diferentes contextos.

const os = require('os');

console.log(os.hostname());//  Voy a saber el hostname de la máquina
console.log(os.networkInterfaces());// Puedo acceder a mi interfaz de red activas en mi máquina, puedo saber  IPVX
console.log(os.tmpdir())//-->Me muestra los directorios temporales, temproales una imagen que voy a procesar
console.log(os.homedir()) // Me permite saber cual es el directorio raíz
console.log(os.arch()); //----> Me devuelve la arquitecura de mi OS
console.log(os.platform());//---> Me dice en qué plataforma estoy
console.log(os.cpus());//--->podemos acceder a la información de las cpus de mi pc.
console.log(os.constants);//--->  Me muestran todos los errores de sistema.


//Acceder a espacios de memoria es muy útil para saber si tengo a memoria suficiente para realizar esta operación.
console.log(os.freemem());// ---> Me dice en bytes la memoria libre que tenemos
// console.log(kb(os.freemem()));
// console.log(mb(os.freemem()));
// console.log(gb(os.freemem()));
console.log(gb(os.totalmem())); // ---> Me muestra la memoria disponible del pc.

const SIZE = 1024;
function kb(bytes) { return bytes / SIZE }
function mb(bytes) { return kb(bytes) / SIZE }
function gb(bytes) { return mb(bytes) / SIZE }

Para ver más bonito lo de los cpus:

console.table(os.cpus());

Les recomiendo usar

console.table(os.cpus())
console.table(os.networkInterfaces())

Siempre que su console.log les regrese arrays, es mejor utilizar console.table

El modulo de OS, Operative System, nos permite ejecutar acciones de más bajo nivel en nuestro sistema, permitiéndonos conocer una gran variedad de detalles del mismo.
Como la memoria disponible que tiene, el total de la memoria, la interfaz de red, etc.
Esto nos será de gran ayuda a la hora de ejecutar o crear proyectos que necesiten información de una maquina para ejecutar una operación.

El profe es un crack.

Una pequeña corrección, la propiedad length utilizada en el método cpus indica el numero de hilos(threads) que tiene nuestro procesador, no los núcleos, por eso se itera el código un numero de veces dependiendo del numero de hilos que tengamos.

Que clase tan interesante, me hizo sentir un hacker 😅

Todos necesitamos más ram xd

Yo hice el siguiente código para ordenarlo un poco mejor a mi gusto:

var SIZE = 1024

var RAM = {
    kb(bytes) {
        return bytes / SIZE
    },
    mb(bytes) {
        return this.kb(bytes) / SIZE
    },
    gb(bytes) {
        return this.mb(bytes) / SIZE;
    },
}

console.log(RAM.mb(os.freemem()) + "mb");
console.log(RAM.kb(os.freemem()) + "kb");
console.log(RAM.gb(os.freemem()) + "gb");```

Que Bonito esto de Node.js

En verdad muy util. todo el tema de sistema operativo.

const os = require('os');

//muestra la arquitectura del equipo
//x64
console.log(os.arch());

//plataforma sistema operativo
//win32
console.log(os.platform());

//informaciòn de las cpu del equipo, cuantos core tiene, la velocidad etc
console.log(os.cpus());
console.log(`${os.cpus().length} cores`);

//errores y señales del sistema
//señales de prioridad
console.log(os.constants);

//memoria libre en bytes
//console.log(os.freemem());

const SIZE = 1024;
const kb = (bytes) => bytes / SIZE
const mb = (bytes) => kb(bytes) / SIZE
const gb = (bytes) => mb(bytes) / SIZE

// console.log(kb(os.freemem()));
// console.log(mb(os.freemem()));
console.log(`Memoria libre ${gb(os.freemem())} GB`);
console.log(`Total Memoria ${gb(os.totalmem())} GB`);

//muestra el directorio del usuario
console.log(`El directorio del usuaioro: ${os.homedir()}`);

//directorio de temporales
console.log(`El directorio de archivos temporales: ${os.tmpdir()}`);

//nombre del host o nombre de la maquina
console.log(os.hostname());

//interface de red
console.log(os.networkInterfaces());

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();

**módulo os:**permite acceder a todo lo que normalmente solo se puede acceder desde lenguaje de muy bajo nivel, como por ejemplo acceder a la memoria ram, N° de cores, N° de nucleos, tipo de sistema de archivos, etc.

El módulo ‘OS’ nos permite tener acceso a información de bajo nivel sobre la máquina.

-const os = require(‘os’);
//requerimos el modulo de node de os

-console.log(os.arch());
//indica el tipo de arquitectura del equipo

-console.log(os.platform())
//indica cual es el tipo de sistema operativo utilizado
-console.log(os.cpus().length)
//nos indica con cuantos nucleos cuenta el equipo

-console.log(os.constants)
//indica toda la informacion de las señales del sistema.

-console.log(os.freemem())
//Indica memoria en bytes libre

-console.log(os.totalmem())
// indica toda la memoria de la pc

-console.log(os.homedir());
//indica directorio de la pc

-console.log(os.tmpdir());
//indica directorio de archivos temporales

-console.log(os.hostname());
//indica el hostname de la pc

-console.log(os.networkInterfaces());
//indica todas las interfaces de redes a las cuales se encuentra conectadada la pc

os.hostname(): obtiene el nombre de la maquina

mi aporte

//que architecture
const os = require(‘os’);
console.log(os.arch());

//plataforma so
console.log(os.platform());

//cpus

console.log(os.cpus().length)

//information de problemas

console.log(os.constants);

const SIZE = 1024;

function kb(bytes){return bytes/SIZE}
function mb(bytes){return kb(bytes)/SIZE}
function gb(bytes){return mb(bytes)/SIZE}

//memoria libre

console.log(kb(os.freemem()));
console.log(mb(os.freemem()));
console.log(gb(os.freemem()));

//memoria en ocupacion
console.log(gb(os.totalmem()));

//ruta del directorio
console.log(os.homedir());

//ruta del directorio temporal
console.log(os.tmpdir());

//para servidores

console.log(os.hostname());

//interface de red

console.log(os.networkInterfaces());

El modulo de OS, Operative System, nos permite ejecutar acciones de más bajo nivel en nuestro sistema, permitiéndonos conocer una gran variedad de detalles del mismo.

Tengo Ubuntu y comparando la cantidad de memoria libre que muestra Node con el monitor de recursos de Ubuntu existe una diferencia.
A alguno mas le paso lo mismo???..

const { Console } = require('console');
const os = require('os');
const SIZE = 1024;


console.log(os.arch());
//console.log(os.platform());
console.log(os.userInfo());
console.log(os.cpus().length);
console.log(os.constants);
console.log(os.freemem());
console.log(kb( os.freemem() ) );
console.log(mb( os.freemem() ) );
console.log(gb( os.freemem() ) );
console.log(gb( os.totalmem() ) );


console.log(os.homedir())
console.log(os.tmpdir())
console.log(os.hostname())
console.log(os.networkInterfaces())




function kb(bytes) { return bytes / SIZE }
function mb(bytes) { return kb(bytes) / SIZE }
function gb(bytes) { return mb(bytes) / SIZE }

Pequeño script para dar información de tu Pc con NodeJs

const os = require("os");
console.log('*'.repeat(70))
console.log('Mi PC con Node.js'.padStart(35))
console.log("*".repeat(70));
//arquitectura de la máquina
console.log(`Arch: ${os.arch()}`);
//plataforma del codigo
console.log(`Pltaforma: ${os.platform()}`);
//Información de la CPU
const nThreads = os.cpus().length;
const { model, speed } = os.cpus()[0];
console.log(`Cpu model: ${model.trim()} ${nThreads} threads @ ${speed} Mhz`);

// información de la freemem
const SIZE = 1024;
const gb = (bytes) => bytes / SIZE ** 3;
console.log(
  `RAM: ${
      gb(os.freemem()).toFixed(2)
    } de ${
        gb(os.totalmem()).toFixed(2)
    } GB libres`
);
console.log("*".repeat(70));

Modulo OS

Con este modulo podremos usar o acceder a todos los elementos de bajo nivel que nos provee el OS.

const OS = require('os');

console.log(OS.arch()); // Saber la arquitectura que tiene la maquina
console.log(OS.platform()); // Que sistema operativo tiene
console.log(OS.cpus()); // Cuantas cpus cuenta la maquina
console.log(OS.constants); // Errores y señales del sistema
console.log(OS.freemem()); // Cuanto espacio de memoria libre tiene
console.log(OS.totalmem()); // Cuanta memoria tiene
console.log(OS.homedir()); // Directorio donde se encuentra el archivo
console.log(OS.tmpdir()); // Cual es la carpeta temporal
console.log(OS.hostname()); // Sabremos cual es nombre host de la maquina
console.log(OS.networkInterfaces()); // Nos muestra todas las interfaces de red disponibles

Cuando estén viendo los elementos de la cpu “console.log(os.cpus()”.
Pueden acceder a los elementos del formato JSON con:
EJEMPLOS:

console.log(os.cpus()[0].model)
console.log(os.cpus()[1].speed)
console.log(os.cpus()[2].times.user)
ETC...

Y así sucesivamente.

Resumen de la clase

/*
  El modulo os nos permite conocer informacion de bajo nivel
  de la maquina en la que está corriendo el codigo
*/

const os = require('os');

// arch nos sirve para saber la arquitectura de nuestra maquina
console.log(os.arch());
// platform nos permite saber en que plataforma estamos.
console.log(os.platform());
// cpus nos muestra la informacion y cantidad de CPU
console.log(os.cpus());
// constants nos permite visualizar errores y señales del sistema
console.log(os.constants);
// fremem permite ver cuantos bytes de memoria libre tengo
console.log(os.freemem());
// totalmem permite ver cuanta memoria hay en total
console.log(os.totalmem());
// homedir muestra el directorio raiz de la maquina
console.log(os.homedir());
// tmpdir muestra el directorio de archivos temporales
console.log(os.tmpdir());
// hostname muestra el nombre de la maquina
console.log(os.hostname());
// networkInterfaces nos permite ver las interfaces de red que tiene la maquina
console.log(os.networkInterfaces());```

const os = require("os");

console.log(os.arch()); // x64

console.log(os.platform()); // linux

console.log(os.cpus().length); // 4

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

// _____
const memoriaLibre = os.freemem(); // memoria libre en bytes
const memoriaTotal = os.totalmem(); // memoria total en bytes
const SIZE = 1024;

const kb = (bytes) => bytes / SIZE;
const mb = (bytes) => kb(bytes) / SIZE;
const gb = (bytes) => mb(bytes) / SIZE;

console.log(`Memoria libre: ${kb(memoriaLibre)} kb`);
console.log(`Memoria libre: ${mb(memoriaLibre)} mb`);
console.log(`Memoria libre: ${gb(memoriaLibre)} gb`);

console.log(`Memoria total: ${gb(memoriaTotal)} gb`);

// _____
console.log(os.homedir()); // directorio raiz
console.log(os.tmpdir()); // directorio de archivos temporales

console.log(os.hostname()); // muy util si estuvieramos en servidores
// console.log(os.networkInterfaces()); // interfaces de redes
console.log(os.networkInterfaces().wifi0[0].address); // IP

// _____
console.log(os.userInfo());

Por Fin cumpliré mi sueño de hacer un:

while(True){
memory.addBit(1024)
}

Que clase tan chevere no sabia que se podia hacer todo este con node

OS

Con OS podremos acceder a las especificaciones del dispositivo.

const os = require('os')

// Así pódras saber cuál es el procesador de la máquina
console.log(os.arch())

// Nos dice cuál es el sistema operativo sobre el cuál corre el código
console.log(os.platform())

// Nos muestra información sobre CPUs
console.log(os.cpus())

// Nos muestra todos los errores y señales del sistema
console.log(os.constants)

// Muestra toda la memoria que tenemos libre en bytes
console.log(os.freemem())

// Muestra el total de memoria
console.log(os.totalmem())

// Nos dice cuál es nuestro home
console.log(os.homedir())

// Nos muestra cuál es la carpeta de archivos temporales de la máquina
console.log(os.tmpdir())

// Nos muestra el nombre de nuestro host
console.log(os.hostname())

// Nos trae todas las interfaces de red que están activas en la máquina
console.log(os.networkInterfaces())

Podemos hacer la siguiente lógica cuando queramos saber cuánto es en MB o GB

const SIZE = 1024;

function kb(bytes) {
    return resultado = bytes / SIZE
}
function mb(bytes) {
    return resultado = kb(bytes) / SIZE
}
function gb(bytes) {
    return resultado = mb(bytes) / SIZE
}

let bits = os.freemem()

console.log(kb(bits))
console.log(mb(bits))
console.log(gb(bits))

Me encanto esta clase!!!

Veo que Node permite recolectar mucha información de los usuarios que llegan, ósea con esta clase podemos saber información del wifi del usuario, su directorio raíz, espacio libre, tipo de sistema, etc.

Documentación: https://nodejs.org/api/os.html

Tengo una duda. Estoy utilizando Windows pero en la terminal uso wsl de ubuntu y al dar os.platform() me sale en consola ‘linux’. Como puedo mostrar windows?

const os = require('os')

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

console.log(os.arch())
console.log(os.platform())
console.log(os.cpus())
console.log(os.constants)
console.log(kb(os.freemem()))
console.log(mb(os.freemem()))
console.log(gb(os.freemem()))
console.log(gb(os.totalmem()))
console.log(os.homedir())
console.log(os.tmpdir())
console.log(os.hostname())
console.log(os.networkInterfaces())

const os = require('os')

const networkInterfaces = os.networkInterfaces()

function get_WiFi_IPv4_Address(data){
    const networks = Object.values(data)
    const wi_fi = networks[1]

    // returns an array with a single element
    const IPv4 = wi_fi.filter(sub_network => sub_network.family === 'IPv4' ? sub_network : null )

    const IPv4_Address = IPv4[0].address
    return IPv4_Address

}

console.log(get_WiFi_IPv4_Address(networkInterfaces))

/* - OS
    Asi podemos acceder a toda la informacion de nuestro sistema operativo (de bajo nivel) utilizando JavaScript */

const OS = require('os');


/* Esto nos da la arquitectura de bits de nuestra maquina*/
console.log(OS.arch()); 

/* Esto nos dice que sistema operativo estamos usando */
console.log(OS.platform());


/* Estos nos muestra la informacion de nuestra CPUS */
console.log(OS.cpus());

/* Esto te muestra todos los errores y senales del sistema */
console.log(OS.constants);

/* Esto muestra  la memoria libre que disponemos */

const SIZE = 1024;
function kb(bytes) { return bytes / SIZE }
function mb(bytes) { return kb(bytes) / SIZE }
function gb(bytes) { return mb(bytes) / SIZE }

console.log(OS.freemem());
console.log(kb(OS.freemem()));
console.log(mb(OS.freemem()));
console.log(gb(OS.freemem()));


/* Esto te da la cantidad total de memoria que tienes */
console.log(gb(OS.totalmem()));

/* Esto muestra directorio raiz del usuario */
console.log(OS.homedir());

/* Esto muestra directorio de archivos temporales */
console.log(OS.tmpdir());

/* Nos muestra el nombre del host de la maquina */
console.log(OS.hostname());

/* Muestra el interfaz de red */

console.log(OS.networkInterfaces());

os.tempdir(): obtiene el directorio de archivos temporales

os.networkinterfaces(): muestras todas las interfaces de red activas

os.homedir(): obtiene el directorio raiz dle usuario

os.totalmem(): indica el total de memoria disponible que se tiene en la maquina

os.constants: muestra los errores del sistema operativo

os.freemem(): es la memoria libre que se tiene en BYTES

++os.cpus.length: ++ cantidad de cores que tiene la maquina

os.cpus(): se puede acceder a modelo de CPU, velocidad, tiempo que lleva detenido, tiempo que lleva ejecutandose,

os.cpus(): se puede acceder a la info de las cpu que estan corriendo en el SO.

os.arch(): indica la arquitectura de tu pc, que puede ser x64 o x32

os.plattform(): se encarga de identificar en que sistema operativo esta corriendo node js

fascinante esta clase

Wow, una muy buena clase, muy interesante

crack

el homedir es solo para linux

Esta increíble todo esto 😱

const os = require('os');

let arquitectura = os.arch();
let plataforma = os.platform()
let cpus = os.cpus().length;
let memoriaLibre = (os.freemem() / 1024)
let usuario = (os.hostname())

console.table([{
    'Arquitectura': arquitectura,
    'Plataforma': plataforma,
    'CPU': cpus,
    'Memoria libre (kb)': memoriaLibre,
    'Usuario': usuario
} 
]);

Tenía duda sobre que memoria total se estaba hablando, así que investigué y encontré el notion de este curso de PLATZI
LINK: https://platzi.com/tutoriales/1759-fundamentos-node/9490-notas-curso-de-fundamentos-de-nodejs-notion/

Hola, Comunidad 👋

Esta es otra forma de mostrar tu memoria libre sin tener que hacer muchas funciones.

function convertToGB(bytes) {
  const SIZE = 1024;
  const kiloBytes = (bytes / SIZE);
  const megaBytes = (kiloBytes / SIZE);
  const gigaBytes = (megaBytes / SIZE);
  return gigaBytes;
};

console.log(convertToGB(os.freemem));

De Frontend Developer a Hackerman

Muy interesante esta clase

Foaaaa es re poderoso node 😮 yo solo pensaba que era para web xD gracias Platzi por la calidad de este curso

Con nosJS se puede atacar toda la info del sistema operativo.
Esto se puede hacer usando el módulo OS:

• os.arch() se puede saber el tipo de arquitectura de la máquina.
• os.platform() permite saber información de la plataforma sobre la cual se corre el código.
• os.cpus() se puede saber la información de cada núcleo.
• os.constants, permite saber información sobre las señales del sistema.
• os.freemem() permite saber la memoria libre que se tiene.
• os.homedir() permite saber el directorio raíz del usuario.
• os.hostname() permite saber el nombre del host de la máquina.

Muy interesante como se puede acceder a los datos de la máquina desde TS.
Nos puede ayudar un montón.

soy el unico que se sintio malvado al escribir console.log(os.networkInterfaces()); xD?

cheat sheet de node

// OS

// OS fundamental cuando se quiere saber sobre cosas del sistema ya sea para usarlo como condiciones o para saber como ejecutarse.

const os = require('os');

const SIZE = 1024;
function kb(bytes){return bytes / SIZE}
function mb(bytes){return kb(bytes) / SIZE}
function gb(bytes){return mb(bytes) / SIZE}

console.log(os.cpus());
console.log(os.freemem());
console.log(kb(os.freemem));
console.log(mb(os.freemem));
console.log(gb(os.freemem));
console.log(os.tmpdir());
console.log(os.hostname());

Creo que en esta clase puedes redescubrir lo limites de node

wow, this is awesome!

😱 Este curso no para de sorprenderme

const os = require('os');
console.log(os)

Demasiado interesante. Node es una super herramienta para un buen backend. EL manejo de memoria, la cantidad de núcleos, el homedir, el tempdir, las interfaces y tantas otras. El profe un crack

[preview]

[codigo]

const os = require('os');


//arquitectura
console.log('Arquitectura: ' + os.arch());

//plataforma o so
console.log('Sistema Operativo: ' +os.platform());

//informacion de la cpu
console.log('Numero de Nucleos: ' + os.cpus().length);
console.log('Detalle de Nucleos:');
console.table(os.cpus());

//señales d del sistema
// console.table(os.constants)

//memoria libre

console.log('Memoria Libre:');

const SIZE = 1024;
function kb(bytes){ return bytes/SIZE}
function mb(bytes){ return kb(bytes)/SIZE }
function gb(bytes){ return mb(bytes)/SIZE }
// console.log(os.freemem());
console.log('-> ' + kb(os.freemem()) + ' kilobytes');
console.log('-> ' + mb(os.freemem()) + ' megabytes');
console.log('-> ' + gb(os.freemem()) + ' gygabytes');

//memoria disponible
console.log('Memoria Disponible:');
console.log(gb(os.totalmem()));

//directorio principal
console.log('Directorio Principal:');
console.log(os.homedir());

//Interfaz de Red Activa
console.log('Interfaz de Red Activa:');
console.table(os.networkInterfaces())

//Hostname de una maquina
console.log('Hostname de una maquina:'+os.hostname());
console.log();

OS

Podemos obtener información de bajo nivel desde Node. Por ejemplo, para reconocer la arquitectura del Sistema Operativo que estamos utilizando podemos hacer lo siguiente.

1. Vamos a requerir el modulo os en Node.

const os = require('os')

1. Para obtener la información de la arquitectura debemos hacer lo siguiente:

console.log(os.arch())
// --> x64

Otra opción que tenemos con el módulo Os, puede ser obtener la información de la plataforma que esta utilizando nuestro PC (Sistema Operativo).

console.log(os.platform())
// --> linux

Esto puede servir para determinar funciones según el sistema operativo que se esta usando, o recopilar información del OS que utilizan los usuarios de la aplicación que se está desarrollando.

Para obtener información de los núcleos que tiene un procesador, se puede utilizar el siguiente método.

console.log(os.cpus())
/*
[
  {
    model: 'Intel(R) Core(TM) i5-4200U CPU @ 1.60GHz',
    speed: 2294,
    times: { user: 1328320, nice: 1260, sys: 100080, idle: 6443010, irq: 0 }
  },
  {
    model: 'Intel(R) Core(TM) i5-4200U CPU @ 1.60GHz',
    speed: 2294,
    times: { user: 1296970, nice: 1620, sys: 93900, idle: 6498050, irq: 0 }
  },
  {
    model: 'Intel(R) Core(TM) i5-4200U CPU @ 1.60GHz',
    speed: 2309,
    times: { user: 1329030, nice: 1400, sys: 103500, idle: 6453900, irq: 0 }
  },
  {
    model: 'Intel(R) Core(TM) i5-4200U CPU @ 1.60GHz',
    speed: 2311,
    times: { user: 1309210, nice: 510, sys: 93120, idle: 6516140, irq: 0 }
  }
]
*/

Esto puede funcionar para determinar que acciones ejecutar dependiendo de la información que nos retorna el procesador del cliente, además para conocer la cantidad de núcleos que tiene el procesador se puede hacer lo siguiente.

console.log(os.cpus().length)
//--> 4

Para conocer la cantidad de memoria (RAM) que tienes disponible podemos obtener el valor con el método os.freemem() ó para conocer el total os.totalmem() .

//MEMORY
const SIZE = 1024
function kb(bytes) {
  return bytes / SIZE
}
function mb(bytes) {
  return kb(bytes) / SIZE
}
function gb(bytes) {
  return mb(bytes) / SIZE
}

// Memoria Disponible
console.log(kb(os.freemem())) // 807296
console.log(mb(os.freemem())) // 787.16015625
console.log(gb(os.freemem())) // 0.7687110900878906

// Memoria total
console.log(kb(os.totalmem())) // 8044964
console.log(mb(os.totalmem())) // 7856.41015625
console.log(gb(os.totalmem())) // 7.672275543212891

Si deseo conocer el directorio raíz del cliente, puedo utilizar el método os.homedir() y me va a retornar la ruta correspondiente. Esto puede servir para el momento que desee guardar algún archivo dentro del pc del cliente y necesite partir desde el directorio raíz.

También existe el método os.tmpdir() que me permite conocer la carpeta de archivos temporales del cliente, esto puede ayudar a gestionar archivos que no se quieren guardar, sino que son archivos que se van a usar en un solo momento determinado.

En caso de trabajar en un servidor, podemos utilizar el método os.hostname() , esto permite saber el hostname de la máquina y permite acceder a microservicios o elementos necesarios en un servidor. También se puede obtener información de las interfaces de red con el método os.networkInterfaces() .

console.log(os.hostname()) // --> santiagobr
console.log(os.networkInterfaces()) 

En resumen el módulo de Operative System en Node.js permite acceder a información de muy bajo nivel con el cuál se pueden trabajar cosas esenciales del sistema.

EXcelente clase, queda uno perplejo ante tantas funcionalidades pero ahí vamos agarrando

Conocer la version del sistema operativo:

console.log(os.release())

El profesor con su poderosa maquina de 16GB vs Mi poderosa y diosa maquina de 2GB 😃

el profe es master race

Hoy en dia arm64 con el chip M1 de Apple.

Que crack es el profesor, de verdad se le entiende todo y deja ideas de como puede ser utilizado cada modulo.

Dejo en un pastebin las notas de estas clase. Ha sido bastante interesante y entretenida.

Módulo OS de Nodej.js

Un saludo y gracias.

Increíble lo que se puede hacer con Node 🤯

ver código

Que buena clase!

WAOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO!!! genial este Modulo

Por si alguno necesita más información sobre el modulo os:

https://nodejs.org/api/os.html

Nunca tuve semejante hipe al comienzo de una clase ❤️ ___ ❤️ !!!

Con process tambien se puede saber algunos de estos datos, como la arquitectura, la plataforma y el hostname

Interesante

Les comparto la documentación de OS de node

https://nodejs.org/api/os.html

Es cierto!! Fue una clase muy divertida y OS es muy poderoso!

Que loco, de verdad esta clase me volo la cabeza.

😃

La mejor clase de la ruta de backend hasta el momento, Genio!!!

no sabia que tengo 12 nucleos en mi pc

Lo sexy que es lenguaje a bajo nivel ❤️

Genial, esta clase

Excelente clase! C:

Excelente clase.

Excelente clase, me ha gustado mucho Carlos como profesor.