Tu primera experiencia con Node.js

1

¿Dónde aprender backend con Node.js actualizado?

2

Todo lo que aprenderás sobre backend con Node.js

3

¿Qué es Node.js?

4

¿Qué es Node.js y para qué sirve?

5

Diferencias entre Node.js y JavaScript

6

Resumen: Diferencias Nodejs y Javascript

7

Instalación de Node.js

8

Arquitectura orientada a eventos

9

Node.js para la web

Manejo y uso de Streams con Node.js

10

Introducción a streams

11

Readable y Writable streams

12

Duplex y Transforms streams

Uso de utilidades de Node.js

13

Sistema operativo y sistema de archivos

14

Administrar directorios y archivos

15

Consola, utilidades y debugging

16

Clusters y procesos hijos

Crea tu primer proyecto en Express.js

17

¿Qué es Express.js y para qué sirve?

18

Creando tu primer servidor con Express.js

19

Request y Response Objects

Aprende a crear un API con REST

20

Anatomía de una API Restful

21

Estructura de una película con Moockaru

22

Implementando un CRUD en Express.js

23

Métodos idempotentes del CRUD

24

Implementando una capa de servicios

Cómo conectarse con librerías externas en Express.js

25

Creación de una BD en MongoAtlas

26

Conexión a MongoAtlas una instancia de MongoDB

27

Conexión con Robot3T y MongoDB Compass a una BD

28

Implementación de las acciones de MongoDB

29

Conexión de nuestros servicios con MongoDB

Conoce como funcionan los Middleware en Express.js

30

¿Qué es un middleware? Capa de manejo de errores usando un middleware

31

Manejo de errores asíncronos y síncronos en Express

32

Capa de validación de datos usando un middleware

33

¿Qué es Joi y Boom?

34

Implementando Boom

35

Implementando Joi

36

Probar la validación de nuestros endpoints

37

Middlewares populares en Express.js

Implementa tests en Node.js

38

Creación de tests para nuestros endpoints

39

Creación de tests para nuestros servicios

40

Creación de tests para nuestras utilidades

41

Agregando un comando para coverage

42

Debugging e inspect

Despliega tu primera aplicación en Express.js

43

Considerando las mejores prácticas para el despliegue

44

Variables de entorno, CORS y HTTPS

45

¿Cómo implementar una capa de manejo de caché?

46

¿Cómo contener tu aplicación en Docker?

47

Despliegue en Now

Conclusiones

48

¿Qué aprendiste en este curso?

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Sistema operativo y sistema de archivos

13/48
Recursos

En esta clase vemos dos módulos básicos:

  • os. Sirve para consultar y manejar los recursos del sistema operativo.
  • fs. Sirve para administrar (copiar, crear, borrar etc.) archivos y directorios.

Los métodos contenidos en estos módulos (y en todo Node.js) funcionan de forma asíncrona por default, pero también se pueden ejecutar de forma síncrona, por ejemplo el método readFile() tiene su versión síncrona readFileSync().

Aportes 55

Preguntas 6

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

En la versión 12.10 de Node me interpreta undefined en el objeto os.networkInterfaces().en0
Mirando la doc solo acepta lo o eth0. En mi casa estoy conectado con Wifi así me quedo así:

Naranja.txt:
Naranja dulce
Limon partido
Dame un abrazo
Que yo te pido
Si fuera falso
Mis juramentos
En otros tiempos
Se olvidaran
Toca la marcha
Mi pecho llora
Adios senora
Yo ya me voy
A mi casita
De sololoy
A comer tacos
Y no le doy

Una forma para ver los cpus de una manera más agradable es con console.table()

Para windows pueden hacer primero hacen

console.log('IP address', os.networkInterfaces());

con eso se fijan todas sus interfaces de su red y luego con esto pueden mapear alguna para mostrarla

console.log('IP address', os.networkInterfaces()['nombre red].map(i => i.address));
/* ------ Con el modulo OS podemos acceder a todo el sistema operativo ------ */

const os = require('os');

//Me devuelve la arquitectura de mi OS
console.log(os.arch()); 

//Me dice en qué plataforma estoy
console.log(os.platform());

//podemos acceder a la información de las cpus de mi pc.
    //Si añades .length podrás saber el numero de hilos
console.log(os.cpus()); 

//  Voy a saber el hostname de la máquina
console.log(os.hostname());

// Puedo acceder a mi interfaz de red activas en mi máquina, puedo saber  IPVX
console.log(os.networkInterfaces());

//Me muestra los directorios temporales, temporales una imagen que voy a procesar
console.log(os.tmpdir())

//Me permite saber cual es el directorio raíz
console.log(os.homedir())

//Me muestran todos los errores de sistema.
console.log(os.constants);


/* Acceder a espacios de memoria es muy útil para saber 
si tengo a memoria suficiente para realizar esta operación. */

//Me dice en bytes la memoria libre que tenemos
console.log(os.freemem());
 console.log('Memoria en kb'+kb(os.freemem()));
 console.log('Memoria en mb'+mb(os.freemem()));
 console.log('Memoria en gb'+gb(os.freemem()));

//Me muestra la memoria disponible del pc.
console.log(gb(os.totalmem())); 

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

Jamas pensé que Juanes fuera desarrollador Backend en su tiempo libre

Para interfaces WiFi en windows.

console.log("IP addres", os.networkInterfaces().WiFi.map(i => i.address));

process.argv argumentos en vector, tiene los siguientes items

[0] Node /usr/bin/node
[1] Path
[2] Nombre del archivo ejecutando

Ojo con la pronunciación cuando se menciona “de manera sincrona” o “de manera asincrona” hay momentos en los que no se logra comprender lo que se está diciendo, ya que para el oído, decir manera sincrona y manera asincrona no tiene mucha diferencia

En el curso de fundamentos de NodeJS tambien de la Escuela de JS, profundiza mas con OS, para el que quiera ver mas 😃

cada vez que quiero ejecutar el código del archivo async-files.js naranja.txt y lo mismo con el syc-files naranja.txt me sale undefined

¿alguien que me de una manito con esto por favor?

Hola buenas, a alguien más le salta un mensaje “undefined” al ejecutar tanto el código síncrono como el asíncrono? Estoy perdido no se como resolverlo 😦

Cumpliendo con el reto de la clase anterior

el código

y el resultado

Aqui les dejo un** npm** package que les ayudara con el display/La muestra de los logs Chalk

Para las versiones más recientes de node, les dejo la

Documentación de os.networkInterfaces:

Returns an object containing network interfaces that have been assigned a network address. Each key on the returned object identifies a network interface. The associated value is an array of objects that each describe an assigned network address. The properties available on the assigned network address object include:


{
  lo: [
    {
      address: '127.0.0.1',
      netmask: '255.0.0.0',
      family: 'IPv4',
      mac: '00:00:00:00:00:00',
      internal: true,
      cidr: '127.0.0.1/8'
    },
    {
      address: '::1',
      netmask: 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff',
      family: 'IPv6',
      mac: '00:00:00:00:00:00',
      scopeid: 0,
      internal: true,
      cidr: '::1/128'
    }
  ],
  eth0: [
    {
      address: '192.168.1.108',
      netmask: '255.255.255.0',
      family: 'IPv4',
      mac: '01:02:03:0a:0b:0c',
      internal: false,
      cidr: '192.168.1.108/24'
    },
    {
      address: 'fe80::a00:27ff:fe4e:66a1',
      netmask: 'ffff:ffff:ffff:ffff::',
      family: 'IPv6',
      mac: '01:02:03:0a:0b:0c',
      scopeid: 1,
      internal: false,
      cidr: 'fe80::a00:27ff:fe4e:66a1/64'
    }
  ]
}

Módulos de NodeJs

Funciones y objetos de Node relacionados al sistema operativo

Funciones y objetos de Node relacionados al sistema de archivos

al ver su pc solo queda decir…

JAJA, ni modo toca trabajar para tener una así

Dejo por aca mi programa con expresiones regulares

const {
  Transform
} = require('stream')

function toCamelCase (str) {
  return str.replace(/(?:^\w|[A-Z]|\b\w|\s+)/g, function (match, index) {
    if (+match === 0) return '' // or if (/\s+/.test(match)) for white spaces
    return index === 0 ? match.toLowerCase() : match.toUpperCase()
  })
}

const transformStream = new Transform({
  transform (chunck, encoding, callback) {
    this.push(toCamelCase(chunck.toString()))
    callback()
  }
})

process.stdin.pipe(transformStream).pipe(process.stdout)

Hay un detalle al mapear las address de os.networkInterfaces: no es la MAC address y la IP, como dice en el video, sino la IPv6 y la IPv4.

Alguien sabe por qué me da error el map?

C:\Users\juand\Documents\MEGA\Learning\Programación\Webdeveloaped\Proyectos\Node\NodeJsClass\Uso de utilidades de Node>node SystemOs.js        
C:\Users\juand\Documents\MEGA\Learning\Programación\Webdeveloaped\Proyectos\Node\NodeJsClass\Uso de utilidades de Node\SystemOs.js:4
console.log("IP addres", os.networkInterfaces().WiFi.map(i => i.address));
                                                    ^

TypeError: Cannot read property 'map' of undefined
    at Object.<anonymous> (C:\Users\juand\Documents\MEGA\Learning\Programación\Webdeveloaped\Proyectos\Node\NodeJsClass\Uso de utilidades de Node\SystemOs.js:4:53)
    at Module._compile (internal/modules/cjs/loader.js:1138:30)```

✌

Me gusto mucho la clase. No sabia que así se leían los parámetros cuando ejecutabas un script en node 😮

estoy conectado por lan para conseguir la ip:

console.log('IP address:', os.networkInterfaces().Ethernet.map(i => i.address))

Hola gente, estoy trabajando en Windows cuando quiero obtener el ip del os la propiedad lo, eth0 me dan undefined, estoy usando la version 10 de node.

En mi caso para acceder a las interfaces de red utilizo wifi0 o lo

os.networkInterfaces().wifi0.map((i) => i.address)
os.networkInterfaces().lo.map((i) => i.address)

Apuntes:

const os = require("os");

// Informacion sobre cada nucleo logico de la CPU
console.log("CPU Info:", os.cpus());

// Dirrecion IP que se encuantra trabajando nuestra maquina
console.log(
  "IP address",
  os.networkInterfaces().wifi0.map((i) => i.address)
);

// Memoria libre de nuestro sistema
console.log("Free memory", os.freemem());

// Tipo de sistema operativo tenemos
console.log("Type", os.type());

// Version del sistema operativo
console.log("50 version", os.release());

// Informacion del usuario
console.log("User info", os.userInfo());

En linux, pude encontrar la info de la ip y mac

console.log("IP address", os.networkInterfaces().wlp2s0.map(i => i.address));```

Memoria disponible en gigas

console.log("Free memory ", (((os.freemem() / 1024) / 1024) / 1024).toFixed(2), "gb"); ```

leer canción

sacar las líneas de un archivo con async

Con Node podremos interactuar directamente con el sistema operativo gracias a su modulo os, (operative system).
Gracias a este modulo podremos conocer las diferentes características de nuestro sistema o del sistema donde esta en uso, para poder ejecutar acciones según esta.
Por ejemplo, la cantidad de cpus que tiene, o la capacidad de memoria libre que tiene actualmente.
También con Node podremos manipular los directorios y archivos de nuestro sistema, con el módulo fs, (File System). Con este módulo podremos hacer prácticamente todas las acciones que nosotros podemos hacer en nuestro directorio, crear, editar y/o eliminar archivos o carpetas enteras.
Es importante tener en cuenta que la mayoría de los métodos de estos módulos suelen ser asíncronos, ya que Node siempre trata de ser así, pero Node también nos ofrece su versión síncrona por si lo llegamos a requerir.

excelente!

En ocasiones podemos leer el archivo de forma asincrona, en otras de forma sincrona.

Node Js nos permite elegir ambas muy facilmente.

Una pregunta, que es?
console.log(“IP address”, os.networkInterfaces().|||en0|||.map(i => i.address));

EN0 <=== que es eso???, cuando pongo el punto no me aparece como opcion, metodo o propiedad de networkInterfaces, gracias!.

¿Cómo se podría modificar la última línea ya sea cambiarla por otro texto o simplemente eliminarla para que queden 15 lineas?

El console.log(‘Free Memory’, os.freemem()/1e9) nos da la cantidad de memoria ram en uso. Lo aclaro por el profesor solo se refiere a memoria… y sabemos que existen varias.
Si lo dividen por 1e9, les dara el valor en Gigas

Buen video!

ese pc es el 141 en esa red hay un monton de equipos conectados en platzit



Ninguno de los scripts para obtener la IP de mi red WiFI me funcionó. Decidí hacerlo manualmente.
Acá les dejo el pequeño script

const os = require('os')

const networkInterfaces = os.networkInterfaces()

function get_WiFi_IPv4_Address(data){
    const networks = Object.entries(data)
    /* networks = [
        [ 'vEthernet (WSL)', [ [Object], [Object] ] ],
        [ 'Wi-Fi', [ [Object], [Object], [Object], [Object] ] ],
        [ 'Conexión de área local* 10', [ [Object], [Object] ] ],
        [ 'Loopback Pseudo-Interface 1', [ [Object], [Object] ] ]
      ]
    */
    const wifiNetwork = networks.filter(([key, values]) => key === 'Wi-Fi' ? values : null)
        // wifi = [ [ 'Wi-Fi', [ [Object], [Object], [Object], [Object] ] ] ]
    const wifiObj = wifiNetwork[0][1]
        //wifiObj = [ {Object}, {Object}, {Object}, {Object} ]

    // returns an array with a single element
    const IPv4 = wifiObj.filter(sub_network => sub_network.family === 'IPv4' ? sub_network : null )
    /*
        IPv4 = [
            {
                address: 'your_ip',
                netmask: '255.255.255.0',
                family: 'IPv4',
                mac: ' :) ',
                internal: false,
                cidr: 'your_ip/24'
            }
        ]
    */

    const IPv4_Address = IPv4[0].address
    // IPv4_Address = your_ip
    return IPv4_Address

}

const WiFi_IPv4_Address = get_WiFi_IPv4_Address(networkInterfaces)
console.log(WiFi_IPv4_Address)
    //Output = your_ip

Sistema operativo y sistema de archivos


Con el módulo os podemos saber cuánto especificaciones de la maquina que estamos usando.

const os = require('os')

console.log('CPU info', os.cpus())
console.log('IP address', os.networkInterfaces())
console.log('IP address', os.networkInterfaces()['vEthernet (WSL)'].map(i => i.address))
console.log(os.freemem())
console.log('Type', os.type())
console.log('SO version', os.release())
console.log('User info',os.userInfo())

Usando el fs esto sería de forma síncrona, pero recuerda que en Node.js tenemos que evitar que sea sync

const fs = require('fs')

try {
    const file = process.argv[2]

    const content = fs.readFileSync(file).toString()

    const lines = content.split('\n').length

    console.log(lines)
} catch (error) {
    console.log(error) 
}
npx nodemon sync-files.js naranja.txt

Así sería de forma Asíncrona

const fs = require('fs')

const file = process.argv[2]

if (!file) {
    throw new Error('Debes poner el archivo')
}

const content = fs.readFile(file, (err, content) => {
    if (err) {
        return console.log(err)
    }

    const lines = content.toString().split('\n').length
    
    console.log(lines)
})

Les comparto el mismo ejercicio, pero usando promesas 😄

const fsPromise = require("fs").promises
async function countLinePromise(file) {
    try {
        const content = await fsPromise.readFile(file)
        const lines = content.toString().split("\n").length
        console.log("Lines contadas en una promesa " + lines)
    } catch (error) {
        console.log(error)
    }
}

const file = process.argv[2]

countLinePromise(file)

La versión implementada con promesas:

const fs = require('fs/promises');

const file = process.argv[2];
if (!file) {
  throw new Error('Debes indicar el archivo que quieres leer');
}

(async function () {
  try {
    const content = await fs.readFile(file);
    const lines = content.toString().split('\n').length;
    console.log(lines);
  } catch (err) {
    console.error(err);
  }
})();

Para aquellos que no les funciona .en0 o eth0 en mi caso funcionó haciendo **.Ethernet ** y de ahí hacerle un mapeo, me di cuenta al realizar solamente el console.log de os.networkInterface()

me divertí de lo lindo con esta clase 😃

<h3>process.argv#</h3>

Added in: v0.1.27

The process.argv property returns an array containing the command-line arguments passed when the Node.js process was launched. The first element will be [process.execPath](https://nodejs.org/docs/latest/api/process.html#process_process_execpath). See process.argv0 if access to the original value of argv[0] is needed. The second element will be the path to the JavaScript file being executed. The remaining elements will be any additional command-line arguments.

For example, assuming the following script for process-args.js:

// print process.argv
process.argv.forEach((val, index) => {
  console.log(`${index}: ${val}`);
});

Launching the Node.js process as:

$ node process-args.js one two=three four

Would generate the output:

0: /usr/local/bin/node
1: /Users/mjr/work/node/process-args.js
2: one
3: two=three
4: four

Excelenteeeee 😃 gracias!!

Con Node podremos interactuar directamente con el sistema operativo gracias a su modulo os, (operative system).
Gracias a este modulo podremos conocer las diferentes características de nuestro sistema o del sistema donde esta en uso, para poder ejecutar acciones según esta.

Para que node les diga su IP, pueden tener un error que dice que en0 no esta definido.

Esto pasa porque en0 hace referencia al adaptador de red del que quieren saber la IP. Si no estan seguros por que adaptador de red estan conectados pueden usar el comando ‘ip a’ en linux y en windows el comando ‘ipconfig’ desde cmd o powershell.

const fs = require("fs");
const file = process.argv[2];

if (!file) {
  throw new Error("File parameter required");
}
fs.readFile(file, function (err, content) {
  if (err) {
    return console.log(err);
  }
  const lines = content.toString().split("\n").length;
  console.log(`File(${file}) length:`, lines);
});

Veo algunas similitudes con el modulo os de Python 😃