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:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

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 “te 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 ‘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.

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

  • 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(‘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.

esto se supone que se tenía que entender? no explicó nada