Node.js Events: Emisión y recepción de eventos en Node.js

Clase 21 de 34 • Curso Básico de Node.js 2018

Resumen

Gran parte de la API central de Node.js se basa en una arquitectura asincrónica idiomática basada en eventos, en la que ciertos tipos de objetos (llamados “emisores”) emiten eventos con nombre que hacen que se llame a los objetos de función (“listeners”).

Francisco Peñalo Feliz

student•

Hice un ejemplo para entender mejor el uso de los eventos.

Crear el archivo db.js y ponerlo dentro de la carpeta src y pegar el código:

const Events = require('events');
class MyEventEmitter extends Events {}
const myEmitter = new MyEventEmitter();

class Db {
  constructor(dbName, user, pass) {
    this.db = dbName
    this.user = user
    this.pass = pass
  }

  open() {
    myEmitter.emit('status', 'opening')
    setTimeout(
      function () {
        myEmitter.emit('status', 'open')
      }, 3000)
  }

  close() {
    myEmitter.emit('status', 'close')
  }

  getTable(tableName) {
    myEmitter.emit('getTable', tableName)
    const data = [{
        name: 'Francisco',
        lastName: 'Peñalo'
      },
      {
        name: 'Emir',
        lastName: 'Salazar'
      },
      {
        name: 'Juan',
        lastName: 'Perez'
      }
    ]

    return data
  }

  on(type, params) {
    myEmitter.on(type, params)
  }
}

module.exports = Db

Luego en index.js poner el código:

const db = require('./src/db')
const objDb = new db('plazti', 'test', 'itzalp')

objDb.on('status', status => {
  console.log(`Estado de Base Datos: ${status}`)

  if (status === 'open') {
    const data = objDb.getTable('students')
    console.log('Datos de la tabla Student:\n', data)
    objDb.close()
  }
})

objDb.on('getTable', tableName => {
  console.log(`Consultando la tabla ${tableName}`)
})

objDb.open()

La salida por la consola es:

Estado de Base Datos: opening
Estado de Base Datos: open
Consultando la tabla students
Datos de la tabla Student:
 [ { name: 'Francisco', lastName: 'Peñalo' },
  { name: 'Emir', lastName: 'Salazar' },
  { name: 'Juan', lastName: 'Perez' } ]
Estado de Base Datos: close

Nathaly Stefani Riaño Bejarano

student•

Genial aporte!! me ayudo a entender mejor los eventos, muchas gracias! 👍

juan camilo castillo saucedo

student•

Excelente!! gracias 👍

Angel Solis

student•

¿Cuál podría ser la diferencia de usar eventos y exportar funciones?

Saul Maldonado Ortiz

student•

misma duda 😕 los ejemplos que puso bien se pudieron haber echo con simples funciones y callbacks

Rubén Maier Enzler

student•

tengo la misma duda… en el caso de NodeJS no le veo mucha utilidad, distinto al onclick o cosa así para el browser.

Ivan Cardozo

student•

Me gustó mucho esta clase , es la primera vez que veo en un curso que se me enseña a trabajar en conjunto con la documentación.

Reinaldo Mendoza

student•

Eso esta muy bueno, aprender a usar la documentacion es absolutamente fundamental

Luis Antonio Schmiel Paredes

student•

La documentación de Nodejs ORG aquí

Carlos Andres Castañeda Osorio

student•

El código de clase con comentarios:

const greet = require("./src/greet")

 greet.emit("clap") //Hacer llamado al evento sin argumento
 greet.emit("greet", "CC") //Hacer llamado al evento, con un argumento

 greet.emit("call", "Carlos Castañeda" ,name=> { //Llamado a evento con función Callback
     console.log(`Hi! ${name}`)
 })

Reinaldo Mendoza

student•

Gracias por el aporte

Jordi Santamaría Portolés

student•

Y asi es como, esta clase me sirvio para aprender a usar el patron observable de una forma muy simple

const EventEmitter = require("events");
class MyEmitter extends EventEmitter {}
const myEmitter = new MyEmitter();

export default class Observable {
  private varToObserve;

  constructor(varToObserve) {
    this.varToObserve = varToObserve;
  }

  public notifyChanges(newValue) {
    myEmitter.emit(this.varToObserve, newValue);
  }

  public subscribe(callback) {
    myEmitter.on(this.varToObserve, callback);
  }

  public subscribeOneChange(callback) {
    myEmitter.once(this.varToObserve, callback);
  }
}```

Como usarlo?

const x = 5
observeX = new Observable(x)
observeX.subscribe(()=> console.log("x ha cambiado de valor a ", x))
x = 10
observeX.notifyChanges(x)

En cuanto llamas a notifyChanges, se llama el callback haciendo lo que tu querias una vez cambia el valor de la variable.

Juan Jose Rojas Rojas

student•

El profe no logra demostrar cual sería la diferencia entre usar los Emitters y usar unas Funciones cualquiera. Quizás si usa otro ejemplo sería mucho mejor y se podría apreciar mejor la teoría que explica. 😕

Daniel Moreno

student•

Las funciones se ejecutan cuando tu las invocas manualmente en el código, pero que pasa si te topas con algo que quieres que se ejecute en un tiempo que tu no controlas. Por ejemplo la conexión a un servidor, tu no sabes cuando va a terminar de conectarse pero en bien termine de conectarse quieres que se ejecute algo, en estos casos son muy útiles los eventos.

Jair Israel Avilés Eusebio

student•

El mismo profesor aclara al final de la clase que en las siguientes clases se vera el uso de eventos en otros ambitos. Con esto quedara mas claro el uso de eventos :)

Carlos Enrique Ramírez Flores

student•

Gran clase, y creo que esto de eventos se va usar mucho en el desarrollo de app con node!

Juan Pablo Rodríguez Morales

student•

¿Podría decirse que estos eventos son el análogo al manejo del DOM que maneja JS en los exploradores?

Miguel Angel Ramos Rodríguez

student•

Genial me gusto la emisión de eventos en la parte de Call cuando se envio el callback 😄

Jecsham Castillo

student•

Los eventos son buenos para loggear la consola al iniciar una aplicación en node 😀

Carlos Alberto Rosales

student•

Buen día

Que diferencias o beneficios tiene usar las funciones call back

myEmitter.on(‘event’, () => {
console.log(“an event occurred!”);
});

myEmitter.on(‘event’, function(){
console.log(“an event occurred!”);
});

¿Por qué existen variantes en declarar funciones?

David Vargas Domínguez

student•

Son lo mismo, la única diferencia es que los arrow functions heredan el contexto (this) del padre

greet.emit('request', 'Carlos', 'archivo.txt', function (name, file) {
    console.log(`${name}, ${file} está vacío`)
    console.log(this) // {...}
})

greet.emit('request', 'Carlos', 'archivo.txt', (name, file) => {
    console.log(`${name}, ${file} está vacío`)
    console.log(this) // {}
})

Fabián Antonio Salgado Sepúlveda

student•

Es verdad lo que dice davo_ te recomiendo que tomes el curso de fundamentos de javascript.
Contexto de funciones y Arrow Functions

Iván Toro

student•

Están geniales estos temas.

Emilio Jose Ugeda Sanoja

student•

const greet = require("./src/greet");

greet.emit('clap');
greet.emit('shout', 'Oh Yeahh');
greet.emit('call', 'Eventos  ---> "Ohh Yeahhh"',(name)=>{
    console.log(`Estamos trabajando con: ${name}`)
});

greet.emit('call', 'Emir ',(name)=>{
    console.log(`Estamos estudiando con: ${name} ---> eres lo maximo!!!`)
});```

Node.js Events: Emisión y recepción de eventos en Node.js

Introducción al curso

¿Dónde aprender Node.js actualizado?

Todo lo que aprenderás sobre node.js

Aspectos generales de Node.js

Introducción a Node.js

Historia de Node.js

Preparación del entorno de trabajo

Creación de máquina virtual de trabajo

Instalación de recursos de proyecto en MacOSX

Instalación de recursos de proyecto

Clonación de repositorio del curso

Gestión de proyectos con Node y NPM

Introducción a Node.js: CLI y REPL

Creación de proyectos de Node.js con NPM

Módulos en Node.js: require() y module.exports

Manejando modulos externos con NPM y require()

Asincronismo en Node.js

Fundamentos de asincronismo con Node.js

Callbacks y Promesas: Casos de estudio

Hacia el futuro: asincronismo con Async/Await

Módulos nativos básicos de Node.js

Node.js FileSystem: Lectura/Escritura de archivos en Node.js

Node.js Readline: Introducción de datos por terminal

Node.js Child Process: Ejecución de subprocesos con Node.js

Node.js Debugger: Depuración de código en Node.js

Node.js Errors: Manejo de errores en Node.js

Node.js Events: Emisión y recepción de eventos en Node.js

Servicios web en Node.js con Express.js

Introducción al protocolo HTTP

Creación de un servidor web básico con HTTP

Creación de un servidor web con Express.js

Construcción de un API con Express.js

Servicios de datos en Node.js con MongoDB

MongoDB: Conexión y escritura de datos con Node.js

Completando nuestro API con MongoDB

Aplicaciones Real-Time en Node.js con Socket.io

Bienvenido a la sección del Proyecto del Curso

Introducción a Socket.io y proyecto de curso

Presentación del proyecto final: Tic-tac-toe

Bases y fundamentos del proyecto final: Tic-tac-toe

Desarrollo del Proyecto final del curso: Tic-tac-toe

Finalizando el proyecto final del curso: Tic-tac-toe

Conclusiones

Consideraciones finales