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

Introducción a streams

10/48
Recursos

Los Streams son una colección de datos como los arrays o strings sólo que se van procesando pedazo por pedazo, esta capacidad los hace muy poderosos porque podemos manejar una gran cantidad de datos de manera óptima.

Aportes 61

Preguntas 7

Ordenar por:

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

Estaba la pájara pinta sentada en un verde limón. Con el pico cortaba la rama, con la rama cortaba la flor. Ay, ay, ay! Cuándo vendrá mi amor…Me arrodillo a los pies de mi amante, me levanto constante, constante. Dame la mano, dame la otra, dame un besito sobre la boca.Daré la media vuelta, Daré la vuelta entera,Con un pasito atrás,Haciendo la reverencia. Pero no, pero no, pero no, porque me da vergüenza, pero sí, pero sí, pero sí, porque te quiero a ti. X 1e6

Les comparto un articulo muy bueno que encontré de streams en Node.js me ayudo a entender mejor, y saber porque uso los chunks en el vídeo anterior, espero que les ayude 😃 Streams en Node.js

RIP mi computador.

//módulo para crear un servidor
const http = require('http')
//módulo para trabajar con archivos
const fs = require('fs')
//inicializamos el servidor
const server = http.createServer()
//manejamos los eventos del servidor
server.on('request', (request, response) => {
  /**
   * lee el archivo como un stream
   * el tamaño del chunk por defecto es de 64kb
   * para un fs, para un stream normal es de 16kb
   */
  const src = fs.createReadStream('./big')
  
  /**
   * la función de 'pipe()' es limitar el 
   * almacenamiento en buffer de datos a niveles
   * aceptables de modo que no se sobrecargue la
   * memoria disponible.
   */
  src.pipe(response)
})

server.listen(3000)

Rendimiento sin streams

  1. Crea un archivo gigante: crea big-file.js, correlo con $ node big-file.js
  2. Crea un server que lo lea: crea file-server.js correlo con $ node file-server.js
  3. Monitoriza la lectura: $ curl -i localhost:3001
  4. Podrás ver como tu PC se quema por la sobrecarga. En administrador de tareas y ve como sube la RAM utilizada y el CPU.
//big-file.js
//al ejecutar esto se crea un archivo gigante de texto
//llamado big.txt
const fs = require('fs')
const file = fs.createWriteStream('./big.txt')
for (let i = 0; i < 1e6; i++) {
  file.write(
    'Estaba la pájara pinta sentada en un verde limón. Con el pico cortaba la rama, con la rama cortaba la flor. Ay, ay, ay! Cuándo vendrá mi amor…Me arrodillo a los pies de mi amante, me levanto constante, constante. Dame la mano, dame la otra, dame un besito sobre la boca.Daré la media vuelta, Daré la vuelta entera,Con un pasito atrás,Haciendo la reverencia. Pero no, pero no, pero no, porque me da vergüenza, pero sí, pero sí, pero sí, porque te quiero a ti. X 1e6'
  )
}
file.end()
//file-server.js
//Mediante esto leemos ese archivo gigante
const fs = require('fs')
const server = require('http').createServer()

// event => cb(info.req, res.data)
server.on('request', (req, res) => {
  // promise => cb(info.req, res.data)
  fs.readFile("./big.txt", (err, data) => {
    if (err) { //maneja el error
      console.log(err)
    } else { //maneja la data
      res.end(data)
    }
  })
})
server.listen(3001)
console.log('Server in port 3001')
<h3>Rendimiento con streams</h3>
  1. Crea un servidor que lea el archivo gigante con streams
  2. Correlo con $ node stream-server.js
  3. Monitoriza la lectura: $ curl -i localhost:3001
  4. Podrás ver como tu PC se quema, pero optimizadamente. En administrador de tareas y ve como sube la RAM utilizada y el CPU en comparacion a cuando no se usa streams, en mi caso fue optimizacion del 50%.
//stream-server.js
const fs = require('fs')
const server = require('http').createServer()

// event => cb(info.req, res.data)
//res es stream de los datos que regresamos
server.on('request', (req, res) => { 

  // event => cb(info.req, res.data)
  //obtenemos la data en forma de stream
  const src = fs.createReadStream('./big.txt') 
  
  // mediate pipe conectamos un stream de lectura con uno de escritura que es res
  src.pipe(res) 
})
server.listen(3001)
console.log('Server in port 3001')

Mi pc despues de hacer el curl -i

-Como k me boi a blokear

Los streams al igual que un arreglo o una cadena de texto, es una colección de datos, con la diferencia que los stream dividen estos datos en varias sesiones, dándonos un mejor rendimiento en la memoria.
Para poder usar streams, lo hacemos con el modulo de fyle system, fs.
Este tendrá dos métodos, createReadStream y createWriteableStream.
El primero nos funciona para transformar archivos a stream, es decir, leerlos, mientras que el segundo para crearlos o editarlos.
Controlar los streams nos permitirá manejar mucho mejor el consumo de memoria de nuestro servidor.

La diferencia entre fs.readFile y fs.createReadStream es que el primero hace que el contenido se ocupe en una parte de la memoria, mientras que el segundo procesa la información por partes.

Interesante, en vez de cargar el archivo de una sola vez y agotar la memoria. Se va cargando por lotes o fracciones reduciendo así el consumo de memoria y una eventual sobrecarga del servidor.

Introducción a streams


Los streams son una colección de datos como los arrays o strings, solo que se van procesando por chunks. Esta capacidad es muy conveniente cuando tengas que manejar una gran cantidad de datos, pero que se maneje de manera óptima.

  1. Creamos un archivo que nos cree un archivo y coloque unos datos dentro

    const fs = require('fs')
    
    const file = fs.createWriteStream('./big')
    
    for (let i = 0; i <= 1e6; i++) {
        file.write('The free and open-source tutorial to learn all around GraphQL to go from zero to production.')
    }
    
    file.end()
    
  2. En este caso, vamos a leer el archivo, pero de tenemos dos forma de hacerlo.

    • Podemos hacer montando nuestro servidor y leer el archivo directamente, pero esto hará que nuestro archivo pese más y consumamos más memoria
    const fs = require('fs')
    const http = require('http')
    
    const server = http.createServer()
    
    server.on('request', (req, res) => {
        fs.readFile('./big', (err, data) => {
            if (err) {
                console.log('error', err)
            }
    
            res.end(data)
        })
    })
    
    server.listen(3000)
    
    • Podemos trabajar con los streams, y no tendremos los problemas de la anterior solución.
    const fs = require('fs')
    const http = require('http')
    
    const server = http.createServer()
    
    server.on('request', (req, res) => {
        const src = fs.createReadStream('./big')
    
        src.pipe(res)
    })
    
    server.listen(3000)
    

No entiendo nada :C ¿Qué curso debí de tomar antes de éste?

💥 Compañeros encontré esta lectura sobre streams! espero les sirva, esta muy interesante: https://elabismodenull.wordpress.com/2017/03/28/el-manejo-de-streams-en-nodejs/ 💥

Por poco muere mi computadora. xd

Para los que esten usando WSL (Windows Subsystem for Linux) con la distro de ubuntu y quieran ver el uso de memoria que toma nodejs pueden instalar el paquete htop el cual nos va a brindar una interfaz grafica para poder ver los procesos activos.

Para ejecutarlo escribimos en la terminal htop y para poder filtrar el proceso de node presionamos la tecla f4 y escribimos node.
Y si ejecutamos nuestro programa y hacemos la peticion vamos a poder ver como se mueve la memoria.
Les dejo la imagen:

Aqui un ejemplo grafico de como pasamos los datos por un stream dividiéndolos en chunks.

La memoria veo que no cambia en windows, pero el procesador es el que puja.

Con streams mejoro el rendimiento un 50%

Los Streams son una colección de datos como los arrays o strings sólo que se van procesando pedazo por pedazo,

Shit: de 14.0 el porcentaje de consumo de memoria a 2.0 el porcentaje más alto!

no se puede observar el error de memoria que mencionan en el vídeo ( tiempo 4:20)

¿Qué ocurre cuando se omite la línea

file.end();

Lo intenté y no noto nada extraño, pero seguramente algo sale mal, no?

Hice la misma prueba en mi Windows y sucede que en un primer momento me consumió 105Mb, pero luego volvió a la normalidad 5,7Mb aprox, sin embargo en la consola se seguí mostrando la data por un buen rato y ya lo que empezó a subir memoria y cpu fue la consola que llegó hasta un 37% de cpu. Imagino que lo inicial fue cuando node sirvió el archivo el resto ya fue pura impresión en la consola.

Es interesante, ahora entiendo mucho mejor para que sirven los Strams, para enviar flujos de datos y consumirlos poco a poco y no enviar todo de un solo golpe.

**Cumpliendo con el reto de la clase pasada **

Estoy usando exactamente el mismo codigo presentaodo pero con un archivo 100 mb mas ligero y me consume toda la memoria utilizando los streams

const fs = require("fs");

const server = require("http").createServer();

server.on("request", (req, res) => {
  const src = fs.createReadStream('./big');
  src.pipe(res);
});

server.listen(3000);

Alguna idea de a que se deba esto?

en conclusion es mas rapido utilizar createReadStream en vez de readFile, para cuando se lee un archivo

cuando intento abrir el archivo “big” mi pc se queda cargando y no lo abre 😮

Supongo que si alguien hace…

for (let i = 0; i < 1e10 ; i++)

Carga toda la memoria de su ordenador

Por si alguien lo esta intentando en Powershell el comando que es apropiado es:

📌 Stream. Colección de datos que se van manejando pedazo por pedazo, esto hace que los streams sean verdaderamente poderosos para manejar grandes cantidades de datos.

en español

const http = require('http');
const server = http.createServer();

server.on('request', (req, res) => {
    if (req.method === 'POST' && req.url == '/birthday'){
        let body = [];
        req.on('data', chunk => {
            body.push(chunk)
        })
        .on('end', () => {
            res.writeHead(200, {'Content-Type': 'text-plain'});
            body = Buffer.concat(body).toString().split('-');
            const year = body[2];
            const month = body[1] -1;
            const day = body[0];
            var options = { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' };

            const birthday = new Date(year, month, day);
            res.end(birthday.toLocaleDateString("es-ES", options).split(',')[0]);
        });
        
    }else{
        res.statusCode = 404;
        res.end();
    }
});

server.listen(8001);

Saludos, me surge una duda, como realmente esta funcionando esto sin pipe?

server.on('request', (request, response) => {
  const src = fs.createReadStream('./big')
  pipe(response)
})

Trate de hacer algo parecido con eventos, pero no logre el mismo resultado

server.on('request', (req, res) => {
  const src = fs.createReadStream('./big');
  src.on('data', (chunk) => {
    res.write(chunk)
  }).on('end', () => res.end())
})

¿Alguien sabe entonces como podríamos hacer esto sin pipe?, o es que los pipe agregan mas cosas y por eso la memoria no se ve tan afectada… un tema interesante 😄

Genial!!

stream-server.js

const fs = require('fs');
const server = require('http').createServer();

server.on('request', (req, res) => {
    const src = fs.createReadStream('./big');
    src.pipe(res);

})

server.listen(3000)

Hacer una petición al servidor stream-server.js con curl

curl -i localhost:3000

big-file.js

const fs = require('fs');
const file = fs.createWriteStream('./big');

for (let i = 0; i < 1e6; i++) {
    file.write('La escuela de JS es nuestro primer paso para un gran futuro');
}

file.end();

file-server.js

const fs = require('fs');
const server = require('http').createServer();

server.on('request', (req, res) => {
    fs.readFile("./big", (err, data) => {
        if(err){
            console.log('error', err)
        }

        res.end(data)
    })
})

server.listen(3000)

Hacer una petición al servidor file-server.js con curl

curl -i localhost:3000

Este script con pipe ( Funciona como tubería ) es muy bueno, ya que consume muy pocos recursos

const fs  = require("fs");
const server = require('http').createServer();

server.on("request", (req, res) => {
    const src = fs.createReadStream("./big.txt")
    src.pipe(res);
})

server.listen(3000, () => console.log('Corriendo en el puerto 3000'))```

link con un articulo pequeño que reforzara esta clase
https://guru99.es/node-js-streams-filestream-pipes/

Hola, les comparto un artículo donde explican los pipes
y otro donde explican los streams

Interesante ver como en mi maquina se mantiene estable el consumo de la memoria

Poderoso este manejo de stream.

Si se intenta leer el archivo es probable que tu pc falle, aquí comando para probar

vi big

Genial

Para los que al momento de mandar la peticion al stream-server.js le sale vacio o empty, prueben usar __dirname :

const src = fs.createReadStream(__dirname + '/big.txt');```

Para los que le crea el archivo big en la raiz y no en la carpeta, usen el __dirname mas el nombre del archivo, y les creara en la carpeta streams el archivo:

const file = fs.createWriteStream(__dirname + '/big.txt');```

Me gustó mucho esta clase!!!

JAJAJJA me sentí todo un hacker con el texto mostrándose en la terminal

xd

hay pero que cosas tan geniales estoy aprendiendo en este curso 😃

Pusé 1e20 en vez de 1e6 y a la hora que leer los datos mi pc se congelo y empezó a calentarse demasiado. JAJAJAJAJA épico

wao, acabo de aprender que podemos escribir numeros con notacion cientifica en Javascript 😮