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

Arquitectura orientada a eventos

8/48
Recursos

Aportes 102

Preguntas 10

Ordenar por:

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

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!!!

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 鈥渢e vas ir pa atras aprendiendo node鈥. No sabia que habia tantas formas de hacer una simple instrucci贸n

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

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 鈥榦pen鈥, 鈥榚nd鈥 y 鈥榙ata鈥, 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.

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(鈥榮tart鈥, () => console.log(鈥榮tarting鈥))
permite que se muestre mensaje cuando ocurre el evento start

const logger = new Logger();
Se crea instancia de clase Logger

this.emit(鈥榝inish鈥): permite lanzar evento finish

this.emit(鈥榮tart鈥) : 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: 鈥淔irst 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 鈥渆vents鈥.

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 (鈥榗hild-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

  • el callback = es el par谩metro que se va a ejecutar despu茅s
  • async-await = manera de escribir codigo asyncrono que no se vea asyncrono

驴Alguien sabe qu茅 Theme est谩 usando en la consola?

Hola! Pregunta! 驴Que editor estas usando?

Explicacion rapida

//Requerimos el modulo events
`const EventEmitter = require(鈥榚vents鈥)

//Creamos una nueva instancia
var e = new EventEmitter();

//Creamos un nuevo evento relacionado con la palabra happy
e.on(鈥榟appy鈥, function(){console.log(鈥榞ood鈥)});

e.emit(鈥榟appy鈥);`

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 鈥榚vents鈥 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.

esto se supone que se ten铆a que entender? no explic贸 nada