Welcome to the Linux Foundation Forum!

9.1 9.2 solutions

9.1

The code below is my solution for Lab 9.1

The only code that I added in is the line `ee.once('tick', listener);

This code could have been added anywhere in the file, and the output would have looked correct. Although that is only because the event emitter is continuously emitting events. If the event listener ee.once is after the setInterval(() => {ee.emit}, 100) then the emit method will have been called once already. And the 'ee.once' will miss the first event and then hear the second emit, the once method then removes the listener from the ee event instance so that it will not hear anymore 'tick' events .

If we intentionally use the EventEmitter.prototype.on() method then will get an error. Because the listener function has runs two tests during its execution. One being the number of times the listener is executed and another checking the listener is being called by the correct event object.

'use strict'
const assert = require('assert')
const { EventEmitter } = require('events')

const ee = new EventEmitter()
let count = 0

ee.once('tick', listener);

setInterval(() => {
  ee.emit('tick')
}, 100)

function listener () {
  count++
  setTimeout(() => {
    assert.equal(count, 1)
    assert.equal(this, ee)
    console.log('passed!')
  }, 250)
}

9.2

In this lab we are asked to write some code that prevents the default behavior of the error event. The only thing that we need to do to do this is to add an event listener that is listening for the error event prior to the 'error' emit event.

The process.nextTick() method is a method that is used to asynchronously call events. Although it does not work with the event loop in the way that you might think.

' This is because process.nextTick() is not technically part of the event loop. Instead, the nextTickQueue will be processed after the current operation is completed, regardless of the current phase of the event loop. Here, an operation is defined as a transition from the underlying C/C++ handler, and handling the JavaScript that needs to be executed. '

For more information on next to tick you can look here: https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/

Anyhow, by simply listening for the 'error' and passing any callback we can get the 'passed' output from the process.nextTick() method. Preictably the callback function passed to the listener does execute prior to the process.nextTick() method call.

If we pass a console.log() call to the event listener we will se this in action.

'use strict'
const { EventEmitter } = require('events')

process.nextTick(console.log, 'passed!')

const ee = new EventEmitter()

ee.on('error', ()=>{});

ee.emit('error', Error('timeout'))


Sign In or Register to comment.