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 ⭐⭐⭐⭐⭐
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?
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Aportes 102
Preguntas 10
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 ⭐⭐⭐⭐⭐
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:
Apuntes de la clase espero les sirvan:
En windows para dar formato al código es alt + shift + f
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
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)
}))
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()
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
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
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
me sale este error
Con Ctrl + K + F
también se puede hacer el formato.
Me gusto mucho esta clase.
fuaaaa no habia visto lo del event emmit aun lo sigo procesando XD
Hay diferentes maneras de hacer que el código sea asíncrono (o al menos que se comporte como tal). En JavaScript podemos hacer esto con callbacks, promises o con async-await. Pero con Node.js hay otra forma de hacerlo, y esto es usando EventEmmiter
de los módulos nativos de Node.js.
Dentro de la función execute, se deben escribir correctamente el nombre de los eventos, ya que al momento de suscribirse realizará lo que se indique de acuerdo al nombre que se haya declarado
Se puede hacer suscripciones a los evento tanto como necesitemos
logger.on(‘start’, () => console.log(‘starting’))
permite que se muestre mensaje cuando ocurre el evento start
const logger = new Logger();
Se crea instancia de clase Logger
this.emit(‘finish’): permite lanzar evento finish
this.emit(‘start’) : permite lanzar el evento start
Lo que requiere async await es que se devuelva una promesa.
El problema con los callbacks y las promesas es que se empieza a generar código en cascada que es difícil de leer con el tiempo.
¿Cual es el problema con los callback y las promesas?
Capturar el error de la promesa se hace utilizando catch
Agregando then a la promise
Paradigma de programación mas popular en NodeJs es la Arquitectura orientada a eventos
Para que serviria ese AWAIT del minuto 07:24??, gracias!
Event emitter
en mi mala suerte me aparecieron puros errores en las primeras ejecuciones y pensé que había codeado mal, pero no es un simple juego de probabilidad 😅
Callbacks con una sintaxis mas comoda para mi
const callback = (err, msg) => {
if(err){
console.log(err)
}
else{
console.log(msg)
}
}
const asyncCallback = (callback) => {
setTimeout( () => {
if(Math.random() < 0.5 ){
return callback(null, 'hello world')
}
else{
callback(new Error ('Esto salio mal'), null)
}
}, 1000)
}
asyncCallback(callback)
promise
const promesa = new Promise((resolve, reject) => {
setTimeout( () => {
if(Math.random() < 0.5 ){
resolve('hello world')
}
else{
reject(new Error ('Esto salio mal'))
}
}, 1000)
})
promesa
.then(resolve => resolve.toUpperCase())
.then(resolve => console.log(resolve))
.catch(err => console.log(err))
async await
const functionPromise = () => new Promise((resolve, reject) => {
setTimeout( () => {
if(Math.random() < 0.5 ){
resolve('hello world')
}
else{
reject(new Error ('Esto salio mal'))
}
}, 500)
})
const asyncAwait = async() => {
try{
const msg = await functionPromise()
console.log(msg)
}
catch(error){
console.log(error)
}
}
asyncAwait()
EventEmmiter
// Crear objeto EventEmmiter para dar sus propiedes a la clase Hola
// require() trae el modulo 'events'
const EventEmmiter = require('events')
// extendemos las propiedades del objeto EventEmmiter para la clase Hola
class Hola extends EventEmmiter{
// Creamos el metodo hola dentro de la clase Hola
hola(callback){
console.log('before')
this.emit('start')
callback()
this.emit('finish')
console.log('after')
}
execute(callback){
console.log('before')
this.emit('start')
callback()
this.emit('finish')
console.log('after')
}
}
// Instanciamos la clase hola
const logger = new Hola()
// .on nos ayuda a detectar si el logger, que es una instancia de nuestra clase hola
// esta teniendo algun evento.
// Si obtiene el evento 'start' ejecuta lo siguiente.... lo mismo con 'finish'
logger.on('start', () => console.log('starting'))
logger.on('finish', () => console.log('finishing'))
logger.on('finish', () => console.log('it\'s Done'))
// disparamos el metodo que creamos en nuestra clase hola
logger.hola( () => setTimeout( () => console.log('hello world') , 1000 ))
logger.execute(() => console.log('hello world'))
Espero a alguien le sirva
✌
NodeJS a partir de la versión 10 implementa promisify en util. Lo que permite convertir callbacks error-first en promesas de una forma sencilla: https://nodejs.org/dist/latest-v8.x/docs/api/util.html
Cada vez entiendo mejor cada contenido. 😉
-Callback: “First Error”
-Promise: Devuelve una promesa. Se anida con then(), catch()
-Async-await: Devuelve una función que devuelve una promesa. Código más legible.
-Event-emitter: No exclusivo. Parte del módulo “events”.
const EventEmitter = require('events');
class Logger extends EventEmitter {
execute(cb) {
this.emit('start');
cb();
this.emit('gol');
this.emit('finish');
console.log('Resultado');
}
}
const logger = new Logger();
logger.on('start', () => console.log('Inicia el juego, 0 min'));
logger.on('gol', () => console.log(`En el minuto 89 Venezuela mete gol a Colombia`));
logger.on('finish', () => console.log('Culmina el juego'));
logger.execute(() => {
return console.log(`45 min Mitad de tiempo`)
});
Tambien se pueden hacer funciones async con la sintaxis de ES6:
const funcionAsincrona = async () => {
// ...
}
alguien sabe que paso en este código que no me imprime el resultado?
Agradezco la ayuda, gracias!!
Los eventos: nos permiten manipular el codigo asincrono de una mejor manera! 😍💗
Me costo un poco el event emitter, creo que practicando voy a entenderlo mejor.
¡Bastante bien explicado!
Con tanto repaso de asincronía me queda mucho más claro todo esto.
La clase EventEmitter es interesante 😄
Las ultimas noticias del motor V8
cuales son los modulos nativos con los que viene por default NodeJS ?
el event emiter solo puede aplicarse en classes?
Un practica corta de event emmiter:
const EventEmmiter= require('events');
class Contador extends EventEmmiter{
init(tiempo,incremento,start){
this.tiempo=tiempo;
this.incremento=incremento;
this.number=start;
this.counter=setInterval(()=>{
this.number+=this.incremento;
if(this.esPrimo(this.number)){
this.emit('primo');
}
if(this.number%2==0){
this.emit('par');
}else{
this.emit('impar');
}
},this.tiempo);
}
esPrimo(n){
var primo=true;
if(n>2){
for(let i=2;i<n;i++){
if(n%i==0){
primo=false;
}
}
}
return(primo);
}
detener(){
clearInterval(this.counter);
}
}
const conteo=new Contador();
conteo.init(200,1,0);
conteo.on('primo',()=>console.log(conteo.number));```
¿Por qué en el primer caso del callback (cb), cuando se devuelve un error no es necesario agregar el return?, me refiero a la parte que hacemos:
else{
cb(new Error('This is an Error'))
}
Aquí la documentación del event emitter
Al ejecutar node callback.js me aparece el error SyntaxError: Unexpected identifier , saben porque ??
event emmiter
se ve muy interesante el event emitter, no lo conocia
asyc-await.js
const promiseFunction = () => new Promise((resolve, reject) => {
setTimeout(() => {
if (Math.random() < 0.5)
resolve("hello world")
else
reject(new Error("hello error "));
}, 500);
})
async function asyncAwait() {
try {
const msg = await promiseFunction();
console.log('message => ', msg)
} catch(e){
console.log('error => ',e)
}
}
asyncAwait(); ```
callback.js
const asyncCallback = function (cb) {
setTimeout(() => {
if (Math.random() < 0.5) {
return cb(null, "hello world")
} else {
cb(new Error("hello error "));
}
}, 2000);
};
asyncCallback((err, msg) => {
if (err)
console.log("error", err)
else
console.log("message", msg)
})```
promise.js
const promise = new Promise((resolve, reject) => {
setTimeout(() => {
if (Math.random() < 0.5)
resolve("hello world")
else
reject(new Error("hello error "));
}, 2000);
})
promise
.then(msg => msg.toUpperCase())
.then(msg => console.log("MAYUSCULAS => ", msg))
.catch(err => console.error("Esto es el error => ", err))
socket io y la ejecución de procesos hijos (‘child-process’) entre otras funcionalidades trabajan con EventEmiter, sin embargo no me daba por enterado. Me pareció muy practico en su momento y ahora que se de donde viene estoy fascinado. Excelente estó, en verdad nunca paro de aprender con los cursos de platzi.
Es muuy bueno seguir la ruta de aprendizaje, no llegas tan perdido y refuerzas conocimiento ;D
No ma lo de EventEmmiter no me la sabia!
Arquitectura Orientada a objetos: permite manipular código asíncrono
¿Alguien sabe qué Theme está usando en la consola?
Hola! Pregunta! ¿Que editor estas usando?
Explicacion rapida
//Requerimos el modulo events
`const EventEmitter = require(‘events’)
//Creamos una nueva instancia
var e = new EventEmitter();
//Creamos un nuevo evento relacionado con la palabra happy
e.on(‘happy’, function(){console.log(‘good’)});
e.emit(‘happy’);`
Una forma más de hacer codigo asincrono!
const EventEmitter = require('events');
class Logger extends EventEmitter {
execute(cb) {
console.log('before')
this.emit('start')
cb()
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(()=> console.log('hello world'))
async await
Event emitter
No había visto lo de Event Emitter
Se que a estas alturas puede parecer un consejo un poco obvio pero para aquellos que despues de escribir :
require (’’)
No les da sugerencias el intellisense de VS Code al intentar escribir entre las comillas ‘events’ requerden instalar node en su proyecto con el comando :
npm install node
shift + alt + f ==> si tienen windows para dar formato
Qué buena clase, nuevos conocimientos. Seguimos aprendiendo 😄
Excelente!!!
Gran clase!
In computer programming, the async/await pattern is a syntactic feature of many programming languages that allows an asynchronous, non-blocking function to be structured in a way similar to an ordinary synchronous function. It is semantically related to the concept of a coroutine and is often implemented using similar techniques, and is primarily intended to provide opportunities for the program to execute other code while waiting for a long-running, asynchronous task to complete, usually represented by promises or similar data structures. source
Todo claro 👌, interesante lo de EventEmitter.
Esto es nuevo
Plugin “Prettier”, usado en el min 2:44
No sabía de la existencia de event emite, muchas gracias por esta clase
Muy bien
WoW me parecio genial el event emiter no lo conocia.
práctica:
Una arquitectura orientada por eventos es un patrón de diseño el cual permite a un conjunto de sistemas comunicarse entre si de forma reactiva mediante la publicación y el consumo de eventos, los cuales se pueden interpretar como cambios de estado de objetos
Me parece que se complico mucho para explicar algo tan simple como son los eventos.
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?