No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Quedan menos de 24 hrs para aprender Ingl茅s, AI y m谩s a precio especial.

Antes: $249

Currency
$209
Suscr铆bete

Termina en:

0 D铆as
10 Hrs
56 Min
8 Seg

OS

18/31
Recursos

Aportes 108

Preguntas 10

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

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

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.

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 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 鈥極S鈥 nos permite tener acceso a informaci贸n de bajo nivel sobre la m谩quina.

-const os = require(鈥榦s鈥);
//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(鈥榦s鈥);
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 鈥渃onsole.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)
}
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
} 
]);

Nunca tuve semejante hipe al comienzo de una clase 鉂わ笍 ___ 鉂わ笍 !!!

Que buena clase!

el profe es master race

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/

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 鈥榣inux鈥. 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())
<h3>Mostrar en consola la direcci贸n IP de tu red WiFi</h3>
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 馃槺

Como terminal estoy usando Bash en vez de Powershell (la de windows) y no me mostraba nada el console.log. Lo solusion茅 utilizando el metodo .toString() ```js console.log(os.arch().toString()) ```Saludos!!
El m贸dulo `os` en Node.js proporciona una serie de utilidades relacionadas con el sistema operativo subyacente. Este m贸dulo te permite acceder a informaci贸n sobre el sistema operativo, el entorno y realizar operaciones espec铆ficas del sistema operativo. Aqu铆 hay un resumen de algunas de las funciones m谩s comunes proporcionadas por el m贸dulo `os` en Node.js: 1\. \*\*os.platform():\*\* Devuelve una cadena que identifica la plataforma del sistema operativo, como "darwin" en macOS, "win32" en Windows o "linux" en sistemas basados en Linux. 2\. \*\*os.arch():\*\* Devuelve una cadena que identifica la arquitectura del procesador del sistema, como "x64" o "arm". 3\. \*\*os.cpus():\*\* Devuelve un arreglo de objetos que describen cada n煤cleo de la CPU del sistema, incluyendo informaci贸n como el modelo, la velocidad y los tiempos de uso. 4\. \*\*os.totalmem():\*\* Devuelve la cantidad total de memoria del sistema en bytes. 5\. \*\*os.freemem():\*\* Devuelve la cantidad de memoria libre en el sistema en bytes. 6\. \*\*os.hostname():\*\* Devuelve el nombre de host del sistema. 7\. \*\*os.networkInterfaces():\*\* Devuelve un objeto que contiene informaci贸n sobre las interfaces de red disponibles en el sistema, incluyendo direcciones IP y otras propiedades. 8\. \*\*os.userInfo(\[options]):\*\* Devuelve un objeto que contiene informaci贸n sobre el usuario actual, como el nombre de usuario, el UID y el directorio de inicio. 9\. \*\*os.tmpdir():\*\* Devuelve el directorio temporal predeterminado para el sistema. Estas son solo algunas de las funciones proporcionadas por el m贸dulo `os` en Node.js. Puedes consultar la documentaci贸n oficial de Node.js para obtener m谩s informaci贸n sobre todas las funciones disponibles y sus usos espec铆ficos.
Esta excelente esto ! Intente hacer un codigo de ejemplo simulando la que necesito descargar un archivo y esta comprobando cuanta memoria libre tiene mi maquina para poder descargar. Aqui les dejo el ejemplo: ```js const oS = require('os'); function requirements() { const SIZE = 1024; const memory = oS.freemem(); const gb = (bytes) => bytes / SIZE / SIZE / SIZE; const valor = gb(memory); if (valor >= 5) { console.log('Download valid requirements'); } else { console.log('Download invalid requirements'); } } requirements(); ```const oS = require('os'); function requirements() { 聽聽聽聽const SIZE = 1024; 聽聽聽聽const memory = oS.freemem(); 聽聽聽聽const gb = (bytes) => bytes / SIZE / SIZE / SIZE; 聽聽聽聽const valor = gb(memory); 聽聽聽聽if (valor >= 5) { 聽聽聽聽聽聽聽聽console.log('Download valid requirements'); 聽聽聽聽} else { 聽聽聽聽聽聽聽聽console.log('Download invalid requirements'); 聽聽聽聽} } requirements();

RESUMEN

November 28, 2023

Este fragmento de c贸digo utiliza el m贸dulo os en Node.js para obtener informaci贸n sobre el sistema operativo. Aqu铆 hay un resumen de las funciones y m茅todos utilizados:

  1. os.arch():
    • Devuelve la arquitectura del sistema.
  2. os.platform():
    • Devuelve la plataforma del sistema.
  3. os.cpus():
    • Devuelve informaci贸n sobre los n煤cleos de la CPU.
  4. os.constants:
    • Proporciona constantes espec铆ficas del sistema operativo.
  5. Conversiones de Memoria:
    • Las funciones btokb, btomb, y btogb convierten bytes a kilobytes, megabytes y gigabytes respectivamente.
  6. os.freemem():
    • Devuelve la cantidad de memoria libre en bytes.
  7. os.totalmem():
    • Devuelve la cantidad total de memoria del sistema en bytes.
  8. os.homedir():
    • Devuelve el directorio de inicio del usuario.
  9. os.tmpdir():
    • Devuelve el directorio temporal del sistema.
  10. os.hostname():
    • Devuelve el nombre del host del sistema.
  11. os.networkInterfaces():
    • Devuelve un objeto que contiene informaci贸n sobre las interfaces de red del sistema.
  12. os:
    • Imprime informaci贸n completa sobre el m贸dulo os.

El c贸digo proporciona detalles sobre la arquitectura, la plataforma, la informaci贸n de la CPU, la memoria disponible, el directorio de inicio, el directorio temporal, el nombre del host y las interfaces de red del sistema.

const os = require('os');

 console.log(os.arch());
 console.log(os.platform());
 console.log(os.cpus());
 console.log(os.cpus());
 console.log(os.constants);

 const SIZE = 1024;
 const btokb = bytes => bytes/SIZE;
 const btomb = bytes => btokb(bytes)/SIZE;
 const btogb = bytes => btomb(bytes)/SIZE;

 console.log(btokb(os.freemem()));
 console.log(btomb(os.freemem()));
 console.log(btogb(os.freemem()));

 console.log(btogb(os.totalmem()));

 console.log(os.homedir());
 console.log(os.tmpdir());

 console.log(os);
 console.log(os.hostname());

console.log(os.networkInterfaces());
Esta excelente esto ! Intente hacer un codigo de ejemplo simulando la que necesito descargar un archivo y esta comprobando cuanta memoria libre tiene mi maquina para poder descargar. Aqui les dejo el ejemplo: ```js const oS = require('os'); function requirements() { const SIZE = 1024; const memory = oS.freemem(); const gb = (bytes) => bytes / SIZE / SIZE / SIZE; const valor = gb(memory); if (valor >= 5) { console.log('Download valid requirements'); } else { console.log('Download invalid requirements'); } } requirements(); ```

Usaba el x2 en la reproducci贸n del video hasta que lleg贸 un profesor que habla x2 馃槃

Dios mio鈥 node servira en otras arquitectura? que delicia seria montar un servidor web en una orange pi,

De casualidad probando el c贸digo de esta clase hice que node escribiera en un archivo .json y eso hac铆a que nodemon reiniciara constantemente y al reiniciar ejecutaba y volv铆a a escribir el .json y as铆 sucesivamente, entonces buscando encontr茅 que se puede ejecutar el nodemon para que atienda 煤nicamente a cambios en los archivos .js escribiendo el comando nodemon --ext js os.js y as铆 no se reinicia constantemente.

Por si quieren una funci贸n que les indique el tama帽o de la memoria directamente en la unidad m谩s cercana,

function bytesToSize(bytes) {
  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
  if (!bytes) return '0 Byte';
  const i = parseInt(Math.floor(Math.log(bytes) / Math.log(1024)));
  return `${Math.round(bytes / Math.pow(1024, i))} ${sizes[i]}`;
}

Por ejemplo, 6659919872 鈫 6 GB

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.

incre铆ble lo que permite node js, ahora en el trabajo cuantos de nosotros usaremos ello? , muy poco pero bueno saberlo

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

// 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 馃槂

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

WAOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO!!! genial este Modulo

Por si alguno necesita m谩s informaci贸n sobre el modulo os:

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

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.