Jasan Azael Hernández Bautista
Juan Jose Vega
Angie Mayoli Cortes Montaño
Cristian Fabian Tovar
Samuel Pilay Muñoz
Karina Magaly Marroquín García
Eduardo Romero
Juan David González Rodríguez
Jimmy Buriticá Londoño
RODRIGO ALEJANDRO CASTILLO MONTERROSA
Steven Benjamín Diaz Flores
Oscar Rodrigo Leon Mojica
Daniel Páez
Guillermo Rodas
Daniel Páez
Edwin García
Luis Fernando Cruz Carrillo
Edwin García
Bryan Condor
yerson lasso
José María Cuevas Ramírez
Kevin Nick Pascual Tuesta
Abigail Perez
Pedro Alvarado Garcia
Ivan Santiago
Oscar Rodrigo Leon Mojica
Andrea Méndez Díaz
Anna Duarte
Guillermo Rodas
Jesús Duarte García
Juan Carlos Pinzón
Marcial Ambriz
David Vargas Domínguez
Alejandro González Reyes
Daniel Sánchez
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 ⭐⭐⭐⭐⭐
Crack, gracias!
Gracias eres muy amable!!!
Muy teso pa' explicar!!! en una sola clase entendí lo que no pude en un mes!, Mounstro!!!!
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:
muchas gracias por tu aporte y tomarte el tiempo en investigar
Muy buen aporte, gracias
Apuntes de la clase espero les sirvan:
Muy bien explicado, gracias.
En windows para dar formato al código es alt + shift + f
Gracias
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
Damas y caballeros se va poniendo dificil la cuestión
Cualquier duda, por aca estoy. :)
Guau! Gracias profe, cualquier cosa concreta le digo. Ahora ando con el desafío del miniservidor con el cumpleaños.
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) }))
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"); } }
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()
es correcto, justo esa era mi duda, porque lo pusieron dentro de una función, si funciona sin ella ?
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
Desconocía la existencia del modulo events 🤯
El curso deberia de llamarse "te vas ir pa atras aprendiendo node". No sabia que habia tantas formas de hacer una simple instrucción
Los eventos start y finish son del proceso principal de node js?
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.
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
en windows, para formatear el documento shft+alt+f
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
Es arquitectura orientada a eventos o paradigma orientado a eventos ? saludos
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.
Para mantener el orden con event-emitter ¿Es necesario combinarlo con promesas o async-await?
Si realmente necesita el orden, sería coherente que funcione con async/await
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!
Algunas librerías internas de node que extienden de EventEmitter son las librerías fs y process. Veamos unos ejemplos.
import { createReadStream } from "fs"; let chunkIndex = 0; const readStream = createReadStream("./data.txt"); readStream.on("open", () => { console.log("Started Reading..."); }); readStream.on("end", () => { console.log("Completed Reading..."); }); readStream.on("data", chunk => { console.log("Chunk: " + ++chunkIndex); console.log("-----------------------------------------"); console.log(chunk); console.log("\n"); });
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 ---------------------------------------------------------- <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 ... > Chunk: 2 ---------------------------------------------------------- <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 ... > Chunk: 3 ---------------------------------------------------------- <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 ... > 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!
ahora ya entiendo como trabaja SocketIO. emito un evento con información, escucho eventos y proceso la data.
Repositorio de la clase: https://github.com/glrodasz/platzi-backend-node/tree/arquitectura-orientada-a-eventos
