Asynchronous Programming Module #20

Question 1

What arguments will setTimeout accept?

Answer 1

A FUNCTION and the TIME to wait before the function is executed. Here’s an example:

setTimeout( ( ) => {
  // runs after 2 seconds
  console.log('inside the function')
}, 2000)

Question 2

Callbacks are cool. But how would you write one? Hint: Think arrow function.

Answer 2

Assign a variable to an arrow func invoking the callback keyword. Here’s an example:

const doSomething = callback => {
  //do things
  //do things
  const result = 'test'
  callback(result)
}

Question 3

What’s a common strategy for error handling in callback functions?

Answer 3

By using error-first callbacks. The first parameter to be returned in this situation is the error object. If it returns NULL, all good. If there is an error a description of the error will be returned. Here’s an example of what one looks like.

s.readFile('/file.json', (err, data) => {
  if (err !== null) {
    //handle error
    console.log(err)
    return
  }

  //no errors, process data
  console.log(data)
})

Question 4

What is a “promise” in JavaScript?

Answer 4

A Promise is an object that’s returned by a function that has not yet completed its work. The promise literally represents a promise made by the function that it will eventually return a result through the promise object.

When the called function finishes its work asynchronously, a function on the promise object called a resolution (or fulfillment, or completion) handler is called to let the original caller know that the task is complete.

««««&laquo_space;Extra Credit&raquo_space;»»»»»»»»»»»»»»

A Promise is in one of these states:

pending: initial state, neither fulfilled nor rejected.
fulfilled: meaning that the operation was completed successfully.
rejected: meaning that the operation failed.

Chained Promises
The methods promise.then( ), promise.catch( ), and promise.finally( ) are used to associate further action with a promise that becomes settled.

Read all about it! https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise

Question 5

What problem does the promise function solve?

Answer 5

The main problem with this approach is that if we need to use the result of this function in the rest of our code, all our code must be nested inside the callback, and if we have to do 2-3 callbacks we enter in what is usually defined “callback hell” with many levels of functions indented into other functions:

doSomething((result) => {
  doSomethingElse((anotherResult) => {
    doSomethingElseAgain((yetAnotherResult) => {
      console.log(result)
    })
  })
})

Question 6

What two methods are invoked after the promise function ends?

Answer 6

.then and .catch

Example code snippet below:

doSomething()
  .then((result) => {
    console.log(result)
  })
  .catch((error) => {
    console.log(error)
  })

Question 7

How is a promise object constructed?

Answer 7

const doSomething = ( ) => new Promise( )

Question 8

What does it mean to resolve a promise?

Answer 8

Resolving a promise means complete it successfully (which results in calling the .then( ) method in who uses it).

Question 9

What does it mean to reject a promise?

Answer 9

Rejecting a promise means ending it with an error which results in calling the .catch( ) method in who uses it.

Question 10

How is an async function different than a promise function?

Answer 10

An async function is a function declared with the async keyword, and the await keyword is permitted within them.

The async and await keywords enable asynchronous, promise-based behavior to be written in a cleaner style, avoiding the need to explicitly configure promise chains.

The purpose of async/await is to simplify the syntax necessary to consume promise-based APIs. The behavior of async/await is similar to combining generators and promises.

Async functions always return a promise. If the return value of an async function is not explicitly a promise, it will be implicitly wrapped in a promise.

For example, the following:

async function foo( ) {
return 1
}

…is equivalent to:

function foo( ) {
   return Promise.resolve( 1 )
}

Question 11

What is a use case where you absolutely need to terminate a code block with a semi-colon?

Answer 11

A self invoking function. Such as this:

( ( ) => {
consoloe.log( ‘test’ )
} ) ( )

You will need the semi-colon on a line preceding the function or just before the first set of parenthesis.

Question 12

What is the self-invoking function for and how is it written?

Answer 12

;( async ( ) => {
const result = await doSomething( )
console.log( result )
} ) ( )

Question 13

What’s the Fetch API

Answer 13

Fetch is used in AJAX calls to “FETCH” data, it is a native function in the browser. It’s an efficient way on snagging data from a server and adding it to a page without a need for a reload.

Question 14

What are the advantages of async functions?

Answer 14

They are easily chain-able and much more readable than plain promises.

Question 15

What would you use to delay the execution of function?

Answer 15

setTimeout( ) Example:

setTimeout( ( )
// runs after 2 seconds
}, 2000

This syntax defines a new function. You can call whatever other function you want in there, or you can pass an existing function name, and a set of parameters:

const myFunction = (firstParam, secondParam) => {
  // do something
}

// runs after 2 seconds
setTimeout(myFunction, 2000, firstParam, secondParam)

setTimeout returns the timer id. This is generally not used, but you can store this id, and clear it if you want to delete this scheduled function execution:

const id = setTimeout(() => {
  // should run after 2 seconds
}, 2000)

// I changed my mind
clearTimeout(id)

Question 16

What’s the difference between setTimeout( ) and setInterval( ) ?

Answer 16

Instead of running the callback function once, it runs forever, for specified time duration defined in (miliseconds)

Example:
setInterval(() => {
  // runs every 2 seconds
}, 2000)

Question 17

How do you tell a setInterval( ) function to stop executing?

Answer 17

By using clearInterval( )

The function below runs every 2 seconds unless you tell it to stop, using clearInterval, passing it the interval id that setInterval returned:

const id = setInterval( ( ) => {
  // runs every 2 seconds
}, 2000)

clearInterval(id)