Arquitectura orientada a eventos

Clase 8 de 48 • Curso de Backend con Node.js 2019

Jasan Azael Hernández Bautista

student•

Les dejo mis notas que me apoyaron en el aprendizaje del curso 😄 https://github.com/JasanHdz/backendnodejs/tree/master/notes No se rindan, éxito 💪 Mis mejores notas ⭐⭐⭐⭐⭐

Juan Jose Vega

student•

Crack, gracias!

Angie Mayoli Cortes Montaño

student•

Gracias eres muy amable!!!

Cristian Fabian Tovar

student•

Muy teso pa' explicar!!! en una sola clase entendí lo que no pude en un mes!, Mounstro!!!!

Samuel Pilay Muñoz

student•

Investigando un poco y respondiéndome a mi pregunta jeje 😄, según la versión de Node.js v12.11.1 estos son los módulos nativos que vienen por default:

Karina Magaly Marroquín García

student•

muchas gracias por tu aporte y tomarte el tiempo en investigar

Eduardo Romero

student•

Muy buen aporte, gracias

Juan David González Rodríguez

student•

Apuntes de la clase espero les sirvan:

Jimmy Buriticá Londoño

student•

Muy bien explicado, gracias.

RODRIGO ALEJANDRO CASTILLO MONTERROSA

student•

En windows para dar formato al código es alt + shift + f

Steven Benjamín Diaz Flores

student•

Gracias

Oscar Rodrigo Leon Mojica

student•

Una arquitectura orientada por eventos es un patron de diseño el cual permite a un conjunto de sistemas comunicarse entre si de forma reactiva mediante la publicacion y el consumo de eventos, los cuales se pueden interpretar como cambios de estado de objetos

Daniel Páez

student•

Damas y caballeros se va poniendo dificil la cuestión

Guillermo Rodas

teacher•

Cualquier duda, por aca estoy. :)

Daniel Páez

student•

Guau! Gracias profe, cualquier cosa concreta le digo. Ahora ando con el desafío del miniservidor con el cumpleaños.

Edwin García

student•

Un experimento enviando código asíncrono dentro del callback. Para que se mantenga el orden se deben usar callbacks, promesas o como en este caso async-await

const EventEmmiter = require('events')

class Logger extends EventEmmiter {
    execute(cb) {
        (async() => {
            console.log('Before')
            this.emit('start')
            try{
                const res = await cb()
                console.log(res)
            }catch(e){
                console.log(e)
            }
            this.emit('finish')
            console.log('After')
        })()
    }
}

const logger = new Logger()

logger.on('start', () => console.log('Starting'))

logger.on('finish', () => console.log('Finishing'))
logger.on('finish', () => console.log('It\'s Done!'))

logger.execute(() => new Promise((resolve, reject) => {
    setTimeout(() => {
        if(Math.random() < 0.5) {
            resolve('Hello world!')
        }else {
            reject(new Error('Hello error!'))
        }
    }, 2000)
}))

Luis Fernando Cruz Carrillo

student•

Hola, en lugar de una función auto ejecutada para el async-await creo que es mejor ponerlo así:

class Logger extends EventEmiter {                                                                                                                                                      
      async execute(cb) {                                                                                                                                                                   
        console.log("Before");                                                                                                                                                              
        this.emit("start");                                                                                                                                                                 
        try {                                                                                                                                                                               
          const resp = await cb();                                                                                                                                                          
          console.log(resp);                                                                                                                                                                
        } catch (e) {                                                                                                                                                                       
          console.log(e);                                                                                                                                                                   
        }                                                                                                                                                                                   
       this.emit("finish");                                                                                                                                                                
       console.log("After");                                                                                                                                                               
     }                                                                                                                                                                                     
   }

Edwin García

student•

Con async-await no es necesario que se envuelva la promesa dentro de una función. Se puede dejar igual a como se estaba manejando con .then y .catch y asignar el resultado a la nueva variable usando el async A mí me funciona así

const promise = new Promise((resolve, reject) => {
    setTimeout(() => {
        if(Math.random() < 0.5) {
            resolve('Hello world!')
        }else {
            reject(new Error('Hello error!'))
        }
    }, 2000)
})

async function asyncAwait() {
    try{
        const msg = await promise
        console.log(`Message: ${msg}`)
    }catch(err){
        console.log(`Error: ${err}`)
    }
}

asyncAwait()

Bryan Condor

student•

es correcto, justo esa era mi duda, porque lo pusieron dentro de una función, si funciona sin ella ?

yerson lasso

student•

Probablemente lo hace para que el código sea más limpio, en ocasiones no importa que halla más código o menos si no del que tan legible es

José María Cuevas Ramírez

student•

Desconocía la existencia del modulo events 🤯

Kevin Nick Pascual Tuesta

student•

El curso deberia de llamarse "te vas ir pa atras aprendiendo node". No sabia que habia tantas formas de hacer una simple instrucción

Abigail Perez

student•

Los eventos start y finish son del proceso principal de node js?

Pedro Alvarado Garcia

student•

No. Estos son de los que creamos en el EventEmmiter. Si te das cuenta, en el Logger que extiende del EventEmmiter tenemos lo siguiente:

class Logger extends EventEmmiter {
    execute(cb) {
        console.log("Before");
        this.emit('start');
        cb();
        this.emit('finish');
        console.log('After');

    }
}

El start y finish a los que te refieres son los this.emit.

Ivan Santiago

student•

No es necesario ejecutar el comando para formatearlo el código siempre. En VsCode puedes abrir el archivo de configuración y agregar la siguiente línea:

"editor.formatOnSave": true

Oscar Rodrigo Leon Mojica

student•

en windows, para formatear el documento shft+alt+f

Andrea Méndez Díaz

student•

Para que les salga la paleta de comando que usa el profesor en el minuto 2.38 en mac deben de pulsar -> cmd + shift + p

Anna Duarte

student•

Es arquitectura orientada a eventos o paradigma orientado a eventos ? saludos

Guillermo Rodas

teacher•

Es algo que se puede discutir, pero de acuerdo a la documentación oficial: https://nodejs.org/api/events.html#events_events

Much of the Node.js core API is built around an idiomatic asynchronous event-driven architecture in which certain kinds of objects (called "emitters") emit named events that cause Function objects ("listeners") to be called.

Jesús Duarte García

student•

Para mantener el orden con event-emitter ¿Es necesario combinarlo con promesas o async-await?

Juan Carlos Pinzón

student•

Si realmente necesita el orden, sería coherente que funcione con async/await

Marcial Ambriz

student•

Porque no ejecuta los eventos start y finish cuando coloco una callback asincrono antes de que se suscriba una función a los eventos start o finish?

class Logger extends EventEmmiter {
  execute(cb) {
    console.log('Before');
    this.emit('start');
    cb();
    this.emit('finish');
    console.log('After'); 
  }
}

// At the beginnig
logger.execute(() => setTimeout(() => console.log('Hello human!'), 1000));

logger.on('start', () => console.log('It´s Starting'));
logger.on('finish', () => console.log('It´s Done'));

// Output
// 	Before
// 	After
// 	Hello human!

// At the end

logger.on('start', () => console.log('It´s Starting'));
logger.on('finish', () => console.log('It´s Done'));

logger.execute(() => setTimeout(() => console.log('Hello human!'), 1000));

// Output
// 	Before
//	It´s Starting
//It´s Done
// 	After
// 	Hello human!

David Vargas Domínguez

student•

Algunas librerías internas de node que extienden de EventEmitter son las librerías fs y process. Veamos unos ejemplos.

import { createReadStream } from &quot;fs&quot;;

let chunkIndex = 0;
const readStream = createReadStream(&quot;./data.txt&quot;);

readStream.on(&quot;open&quot;, () =&gt; {
    console.log(&quot;Started Reading...&quot;);
});

readStream.on(&quot;end&quot;, () =&gt; {
    console.log(&quot;Completed Reading...&quot;);
});

readStream.on(&quot;data&quot;, chunk =&gt; {
    console.log(&quot;Chunk: &quot; + ++chunkIndex);
    console.log(&quot;-----------------------------------------&quot;);
    console.log(chunk);
    console.log(&quot;\n&quot;);
});

El módulo fs usa internamente EventEmitter, específicamente 'open', 'end' y 'data', respectivamente cuando se abre un archivo, cuando se termina de leer un archivo o cuando se está leyendo uno. Y este sería el output.

Started Reading...
Chunk: 1
----------------------------------------------------------
&lt;Buffer 4c 6f 72 65 6d 20 69 70 73 75 6d 20 64 6f 6c 6f 72 20 73 69 74 20 61 6d 65 74 2c 20 63 6f 6e 73 65 63 74 65 74 75 72 20 61 64 69 70 69 73 63 69 6e 67 ... &gt;
Chunk: 2
----------------------------------------------------------
&lt;Buffer 74 20 6e 75 6e 63 20 76 69 74 61 65 20 66 65 72 6d 65 6e 74 75 6d 2e 20 49 6e 20 75 74 20 61 72 63 75 20 74 65 6d 70 6f 72 2c 20 66 61 75 63 69 62 75 ... &gt;
Chunk: 3
----------------------------------------------------------
&lt;Buffer 20 76 69 74 61 65 2c 20 65 67 65 73 74 61 73 20 69 64 20 73 65 6d 2e 20 44 6f 6e 65 63 20 75 74 20 75 6c 74 72 69 63 69 65 73 20 6c 6f 72 65 6d 2c 20 ... &gt;
Completed Reading...

Muy bueno la clase de EventEmitter! Este ejemplo lo conseguí de este link. Explica con claridad los conceptos y métodos de esta clase. Lo recomiendo!

Alejandro González Reyes

student•

ahora ya entiendo como trabaja SocketIO. emito un evento con información, escucho eventos y proceso la data.

Daniel Sánchez

teacher•

Repositorio de la clase: https://github.com/glrodasz/platzi-backend-node/tree/arquitectura-orientada-a-eventos

Arquitectura orientada a eventos

Tu primera experiencia con Node.js

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

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

¿Qué es Node.js?

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

Diferencias entre Node.js y JavaScript

Resumen: Diferencias Nodejs y Javascript

Instalación de Node.js

Arquitectura orientada a eventos

Node.js para la web

Manejo y uso de Streams con Node.js

Introducción a streams

Readable y Writable streams

Duplex y Transforms streams

Uso de utilidades de Node.js

Sistema operativo y sistema de archivos

Administrar directorios y archivos

Consola, utilidades y debugging

Clusters y procesos hijos

Crea tu primer proyecto en Express.js

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

Creando tu primer servidor con Express.js

Request y Response Objects

Aprende a crear un API con REST

Anatomía de una API Restful

Estructura de una película con Moockaru

Implementando un CRUD en Express.js

Métodos idempotentes del CRUD

Implementando una capa de servicios

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

Creación de una BD en MongoAtlas

Conexión a MongoAtlas una instancia de MongoDB

Conexión con Robot3T y MongoDB Compass a una BD

Implementación de las acciones de MongoDB

Conexión de nuestros servicios con MongoDB

Conoce como funcionan los Middleware en Express.js

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

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

Capa de validación de datos usando un middleware

¿Qué es Joi y Boom?

Implementando Boom

Implementando Joi

Probar la validación de nuestros endpoints

Middlewares populares en Express.js

Implementa tests en Node.js

Creación de tests para nuestros endpoints

Creación de tests para nuestros servicios

Creación de tests para nuestras utilidades

Agregando un comando para coverage

Debugging e inspect

Despliega tu primera aplicación en Express.js

Considerando las mejores prácticas para el despliegue

Variables de entorno, CORS y HTTPS

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

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

Despliegue en Now

Conclusiones

¿Qué aprendiste en este curso?