Async Programming

Why async?

 const fs = require('fs');
 
 const file_data = fs.readFileSync('file.txt', 'utf8');
 
 console.log("Data inside the file:: " + file_data);
 
 console.log("Hi there!");

Why async?

 const fs = require('fs');
 
 const file_data = fs.readFileSync('file.txt', 'utf8');
 
 console.log("Data inside the file:: " + file_data);
 
 console.log("Hi there!");

This operation does not depend on the loaded file. Why, then, are we waiting for it to be loaded first?

Why async?

 const fs = require('fs');
 
 const file_data = fs.readFileSync('file.txt', 'utf8');
 
 console.log("Data inside the file:: " + file_data);
 
 console.log("Hi there!");

This line is blocking the rest of the code

Why async?

 const fs = require('fs');
  
 fs.readFile('file.txt', 'utf-8', function (err, data) {
     if (err) throw err;
     console.log("Data inside the file:: " + data)
 
 });
 
 console.log("hello")

Why async?

This read operation no longer blocks the execution. "hello" will be logged before the file content, even though it appears later in the code

 const fs = require('fs');
  
 fs.readFile('file.txt', 'utf-8', function (err, data) {
     if (err) throw err;
     console.log("Data inside the file:: " + data)
 
 });
 
 console.log("hello")

Event Loop

Event Loop

JavaScript is a single-threaded programming language, meaning it has only a single thread

Event Loop

Call stack

 const fs = require('fs');
 
 const file_data = fs.readFileSync('file.txt', 'utf8');
 
 console.log("Data inside the file:: " + file_data);
 
 console.log("Hi there!");

main()

The call stack stores the function calls. If we invoke a function, we insert it into the call stack, when this function returns, we pop the function out of the stack

Event Loop

Call stack

 const fs = require('fs');
 
 const file_data = fs.readFileSync('file.txt', 'utf8');
 
 console.log("Data inside the file:: " + file_data);
 
 console.log("Hi there!");

main()

require('fs')

The call stack stores the function calls. If we invoke a function, we insert it into the call stack, when this function returns, we pop the function out of the stack

Event Loop

Call stack

 const fs = require('fs');
 
 const file_data = fs.readFileSync('file.txt', 'utf8');
 
 console.log("Data inside the file:: " + file_data);
 
 console.log("Hi there!");

main()

readFileSync(...)

The call stack stores the function calls. If we invoke a function, we insert it into the call stack, when this function returns, we pop the function out of the stack

Event Loop

Call stack

 const fs = require('fs');
 
 const file_data = fs.readFileSync('file.txt', 'utf8');
 
 console.log("Data inside the file:: " + file_data);
 
 console.log("Hi there!");

main()

readFileSync(...)

... taking to long...

The call stack stores the function calls. If we invoke a function, we insert it into the call stack, when this function returns, we pop the function out of the stack

Event Loop

Call stack

 const fs = require('fs');
 
 const file_data = fs.readFileSync('file.txt', 'utf8');
 
 console.log("Data inside the file:: " + file_data);
 
 console.log("Hi there!");

main()

console.log(...)

The call stack stores the function calls. If we invoke a function, we insert it into the call stack, when this function returns, we pop the function out of the stack

Event Loop

Call stack

 const fs = require('fs');
 
 const file_data = fs.readFileSync('file.txt', 'utf8');
 
 console.log("Data inside the file:: " + file_data);
 
 console.log("Hi there!");

main()

The call stack stores the function calls. If we invoke a function, we insert it into the call stack, when this function returns, we pop the function out of the stack

console.log(...)

Event Loop

Call stack

main()

The task queue stores tasks to be executed later. The event loop will be watching it.

Task queue

 const fs = require('fs');
  
 fs.readFile('file.txt', 'utf-8', function (err, data) {
     if (err) throw err;
     console.log("Data inside the file:: " + data)
 
 });
 
 console.log("hello")

Event Loop

Call stack

main()

The task queue stores tasks to be executed later. The event loop will be watching it.

 const fs = require('fs');
  
 fs.readFile('file.txt', 'utf-8', function (err, data) {
     if (err) throw err;
     console.log("Data inside the file:: " + data)
 
 });
 
 console.log("hello")

Task queue

require('fs')

Event Loop

Call stack

main()

The task queue stores tasks to be executed later. The event loop will be watching it.

 const fs = require('fs');
  
 fs.readFile('file.txt', 'utf-8', function (err, data) {
     if (err) throw err;
     console.log("Data inside the file:: " + data)
 
 });
 
 console.log("hello")

Task queue

readFile(... callback())

Event Loop

Call stack

main()

The task queue stores tasks to be executed later. The event loop will be watching it.

 const fs = require('fs');
  
 fs.readFile('file.txt', 'utf-8', function (err, data) {
     if (err) throw err;
     console.log("Data inside the file:: " + data)
 
 });
 
 console.log("hello")

Task queue

callback function

readFile(... callback())

Event Loop

Call stack

main()

The task queue stores tasks to be executed later. The event loop will be watching it.

 const fs = require('fs');
  
 fs.readFile('file.txt', 'utf-8', function (err, data) {
     if (err) throw err;
     console.log("Data inside the file:: " + data)
 
 });
 
 console.log("hello")

Task queue

callback()

callback function

Event Loop

Call stack

main()

The task queue stores tasks to be executed later. The event loop will be watching it.

 const fs = require('fs');
  
 fs.readFile('file.txt', 'utf-8', function (err, data) {
     if (err) throw err;
     console.log("Data inside the file:: " + data)
 
 });
 
 console.log("hello")

Task queue

callback()

console.log()

Event Loop

Call stack

main()

The task queue stores tasks to be executed later. The event loop will be watching it.

 const fs = require('fs');
  
 fs.readFile('file.txt', 'utf-8', function (err, data) {
     if (err) throw err;
     console.log("Data inside the file:: " + data)
 
 });
 
 console.log("hello")

Task queue

callback()

Done?

Event Loop

Call stack

main()

The task queue stores tasks to be executed later. The event loop will be watching it.

 const fs = require('fs');
  
 fs.readFile('file.txt', 'utf-8', function (err, data) {
     if (err) throw err;
     console.log("Data inside the file:: " + data)
 
 });
 
 console.log("hello")

Task queue

callback()

Event loop

Event Loop

Call stack

main()

The task queue stores tasks to be executed later. The event loop will be watching it.

 const fs = require('fs');
  
 fs.readFile('file.txt', 'utf-8', function (err, data) {
     if (err) throw err;
     console.log("Data inside the file:: " + data)
 
 });
 
 console.log("hello")

Task queue

callback()

Event Loop

Call stack

main()

The task queue stores tasks to be executed later. The event loop will be watching it.

 const fs = require('fs');
  
 fs.readFile('file.txt', 'utf-8', function (err, data) {
     if (err) throw err;
     console.log("Data inside the file:: " + data)
 
 });
 
 console.log("hello")

Task queue

callback()

console.log()

Event Loop

Call stack

main()

The task queue stores tasks to be executed later. The event loop will be watching it.

 const fs = require('fs');
  
 fs.readFile('file.txt', 'utf-8', function (err, data) {
     if (err) throw err;
     console.log("Data inside the file:: " + data)
 
 });
 
 console.log("hello")

Task queue

callback()

Event Loop

Call stack

main()

The task queue stores tasks to be executed later. The event loop will be watching it.

 const fs = require('fs');
  
 fs.readFile('file.txt', 'utf-8', function (err, data) {
     if (err) throw err;
     console.log("Data inside the file:: " + data)
 
 });
 
 console.log("hello")

Task queue

 (function() {
 
   console.log('1');
 
   setTimeout(function cb() {
     console.log('2');
   }, 10);
 
   console.log('3');
 
   setTimeout(function cb1() {
     console.log('4');
   }, 20);
 
   console.log('5');
 
 })();

What is going to be the logging order?

Activity #1 - callbacks: call me maybe?

Activity #1 - callbacks: call me maybe?

 (function() {
 
   console.log('1');
 
   setTimeout(function cb() {
     console.log('2');
   }, 10);
 
   console.log('3');
 
   setTimeout(function cb1() {
     console.log('4');
   }, 20);
 
   console.log('5');
 
 })();

What is going to be the logging order?

1, 3, 5, 2, 4

Activity #2 - Chaining callbacks: highway to hell

(function() {
 
 console.log("Calling the async functionality");
 
 setTimeout(function initialCB() {
     console.log('Beginning');
 
     setTimeout(function cb() {
         console.log('Reading the folder');
 
         setTimeout(function cb1() {     
             console.log('Going through the files');
         });
      });
 });
 
 console.log("After async");
 
 })();

Activity #2 - Chaining callbacks: highway to hell

(function() {
 
 console.log("Calling the async functionality");
 
 setTimeout(function initialCB() {
     console.log('Beginning');
 
     setTimeout(function cb() {
         console.log('Reading the folder');
 
         setTimeout(function cb1() {     
             console.log('Going through the files');
         });
      });
 });
 
 console.log("After async");
 
 })();

Async block

Activity #2 - Chaining callbacks: highway to hell

What if we want to perform some more async methods on these files?

Activity #2 - Chaining callbacks: highway to hell

(function() {
 
 console.log("Calling the async functionality");
 
 setTimeout(function initialCB() {
     console.log('Beginning');
 
     setTimeout(function cb() {
         console.log('Reading the folder');
 
         setTimeout(function cb1() {     
             console.log('Going through the files');

             setTimeout(function cb2() {
                 console.log("Transform this data");
             });
         });
      });
 });
 
 console.log("After async");
 
 })();

Activity #2 - Chaining callbacks: highway to hell

What if we want to perform even more async methods?

Activity #2 - Chaining callbacks: highway to hell

What if we want to perform even more async methods?

Activity #2 - Chaining callbacks: highway to hell

 (function() {
 
 console.log("Calling the async functionality");
 
 setTimeout(function initialCB() {
     console.log('Beginning');
 
     setTimeout(function cb() {
         console.log('Reading the folder');
 
         setTimeout(function cb1() {     
             console.log('Going through the files');
             setTimeout(function cb2() {
                 console.log("Transform this data");
 
                 setTimeout(function cb3() {
                     console.log("Transform this data");
                     
                     setTimeout(function cb4() {
                         console.log("Transform this data");
                         
                         setTimeout(function cb5() {
                             console.log("Transform this data");
                         });
                     });
                 });
             });
         });
      });
 });
 
 console.log("After async");
 
 })();

Activity #2 - Chaining callbacks: highway to hell

(function() {

console.log("Calling the async functionality");

setTimeout(function initialCB() {
    console.log('Beginning');

    setTimeout(function cb() {
        console.log('Reading the folder');

        setTimeout(function cb1() {
            console.log('Going through the files');
            setTimeout(function cb2() {
                console.log("Transform this data");

                setTimeout(function cb3() {
                    console.log("Transform this data");

                    setTimeout(function cb4() {
                        console.log("Transform this data");

                        setTimeout(function cb5() {
                            console.log("Transform this data");

                            setTimeout(function cb6() {
                                    console.log('Reading the folder');

                                    setTimeout(function cb7() {
                                        console.log('Going through the files');
                                        setTimeout(function cb8() {
                                            console.log("Transform this data");

                                            setTimeout(function cb9() {
                                                console.log("Transform this data");

                                                setTimeout(function cb10() {
                                                    console.log("Transform this data");

                                                    setTimeout(function cb11() {
                                                        console.log("Transform this data");

                                                        setTimeout(function cb12() {
                                                            console.log("Transform this data");

                                                            setTimeout(function cb13() {
                                                                    console.log('Reading the folder');

                                                                    setTimeout(function cb14() {
                                                                        console.log('Going through the files');
                                                                        setTimeout(function cb15() {
                                                                            console.log("Transform this data");

                                                                            setTimeout(function cb16() {
                                                                                console.log("Transform this data");

                                                                                setTimeout(function cb17() {
                                                                                    console.log("Transform this data");

                                                                                    setTimeout(function cb18() {
                                                                                        console.log("Transform this data");
                                                                                    });
                                                                                });
                                                                            });
                                                                        });
                                                                    });
                                                                 });
                                                            });
                                                    });
                                                });
                                            });
                                        });
                                    });
                                 });
                            });
                    });
                });
            });
        });
     });
});

console.log("After async");

})();

Activity #2 - Chaining callbacks: highway to hell

(function() {

console.log("Calling the async functionality");

setTimeout(function initialCB() {
    console.log('Beginning');

    setTimeout(function cb() {
        console.log('Reading the folder');

        setTimeout(function cb1() {
            console.log('Going through the files');
            setTimeout(function cb2() {
                console.log("Transform this data");

                setTimeout(function cb3() {
                    console.log("Transform this data");

                    setTimeout(function cb4() {
                        console.log("Transform this data");

                        setTimeout(function cb5() {
                            console.log("Transform this data");

                            setTimeout(function cb6() {
                                    console.log('Reading the folder');

                                    setTimeout(function cb7() {
                                        console.log('Going through the files');
                                        setTimeout(function cb8() {
                                            console.log("Transform this data");

                                            setTimeout(function cb9() {
                                                console.log("Transform this data");

                                                setTimeout(function cb10() {
                                                    console.log("Transform this data");

                                                    setTimeout(function cb11() {
                                                        console.log("Transform this data");

                                                        setTimeout(function cb12() {
                                                            console.log("Transform this data");

                                                            setTimeout(function cb13() {
                                                                    console.log('Reading the folder');

                                                                    setTimeout(function cb14() {
                                                                        console.log('Going through the files');
                                                                        setTimeout(function cb15() {
                                                                            console.log("Transform this data");

                                                                            setTimeout(function cb16() {
                                                                                console.log("Transform this data");

                                                                                setTimeout(function cb17() {
                                                                                    console.log("Transform this data");

                                                                                    setTimeout(function cb18() {
                                                                                        console.log("Transform this data");
                                                                                    });
                                                                                });
                                                                            });
                                                                        });
                                                                    });
                                                                 });
                                                            });
                                                    });
                                                });
                                            });
                                        });
                                    });
                                 });
                            });
                    });
                });
            });
        });
     });
});

console.log("After async");

})();

Problems with callback style

1. Complex error handling

Problems with callback style

1. Complex error handling

2. Callback hell

Promises in-depth

Promises work like callback functions, in fact, promises are built on top of callback functions. Promises make it way easier to deal with async code. You have to keep in mind two main differences when dealing with promises: using promises and defining promises

Defining promises

function createAsyncFunction () {
  return new Promise(function (resolve, reject) {
    // Do something
    if (allGood) {
      resolve(randomNumber)
    } else {
      reject(randomNumber)
    }
  })
}

Promises in-depth

Promises work like callback functions, in fact, promises are built on top of callback functions. Promises make it way easier to deal with async code. You have to keep in mind two main differences when dealing with promises: using promises and defining promises

p.then((result) => {
  // do something with the result
})
.catch((err) => {
  // do something with error
})

Using promises

Promises in-depth

Promises work like callback functions, in fact, promises are built on top of callback functions. Promises make it way easier to deal with async code. You have to keep in mind two main differences when dealing with promises: using promises and defining promises

try {
    let v = await p();
} catch(e) {
    Log.fatal(e)
}

Using promises

Promises in-depth

function generateRandomNumber () {
  return new Promise(function (resolve, reject) {
    var randomNumber = Math.floor((Math.random() * 10) + 1)
    if (randomNumber <= 5) {
      resolve(randomNumber)
    } else {
      reject(randomNumber)
    }
  })
}

generateRandomNumber().then(function(result) {
  console.log('Success: ' + result)
}).catch(function(error) {
  console.log('Error: ' + error)
})

Promises in-depth

function generateRandomNumber () {
  return new Promise(function (resolve, reject) {
    var randomNumber = Math.floor((Math.random() * 10) + 1)
    if (randomNumber <= 5) {
      resolve(randomNumber)
    } else {
      reject(randomNumber)
    }
  })
}

generateRandomNumber().then(function(result) {
  console.log('Success: ' + result)
}).catch(function(error) {
  console.log('Error: ' + error)
})

Defining an async method using promise

Promises in-depth

function generateRandomNumber () {
  return new Promise(function (resolve, reject) {
    var randomNumber = Math.floor((Math.random() * 10) + 1)
    if (randomNumber <= 5) {
      resolve(randomNumber)
    } else {
      reject(randomNumber)
    }
  })
}

generateRandomNumber().then(function(result) {
  console.log('Success: ' + result)
}).catch(function(error) {
  console.log('Error: ' + error)
})

Using the previously defined async method

Promises in-depth

function generateRandomNumber () {
  return new Promise(function (resolve, reject) {
    var randomNumber = Math.floor((Math.random() * 10) + 1)
    if (randomNumber <= 5) {
      resolve(randomNumber)
    } else {
      reject(randomNumber)
    }
  })
}

generateRandomNumber().then(function(result) {
  console.log('Success: ' + result)
}).catch(function(error) {
  console.log('Error: ' + error)
})

This function can only be used asynchronously

Promises in-depth

function generateRandomNumber () {
  return new Promise(function (resolve, reject) {
    var randomNumber = Math.floor((Math.random() * 10) + 1)
    if (randomNumber <= 5) {
      resolve(randomNumber)
    } else {
      reject(randomNumber)
    }
  })
}

generateRandomNumber().then(function(result) {
  console.log('Success: ' + result)
}).catch(function(error) {
  console.log('Error: ' + error)
})

A promise returns 2 callbacks that you must use to settle the promise

Promises in-depth

function generateRandomNumber () {
  return new Promise(function (resolve, reject) {
    var randomNumber = Math.floor((Math.random() * 10) + 1)
    if (randomNumber <= 5) {
      resolve(randomNumber)
    } else {
      reject(randomNumber)
    }
  })
}

generateRandomNumber().then(function(result) {
  console.log('Success: ' + result)
}).catch(function(error) {
  console.log('Error: ' + error)
})

resolve the promise if all good

reject otherwise

Promises in-depth

function generateRandomNumber () {
  return new Promise(function (resolve, reject) {
    var randomNumber = Math.floor((Math.random() * 10) + 1)
    if (randomNumber <= 5) {
      resolve(randomNumber)
    } else {
      reject(randomNumber)
    }
  })
}

generateRandomNumber().then(function(result) {
  console.log('Success: ' + result)
}).catch(function(error) {
  console.log('Error: ' + error)
})

Call the method (which is async)

Promises in-depth

function generateRandomNumber () {
  return new Promise(function (resolve, reject) {
    var randomNumber = Math.floor((Math.random() * 10) + 1)
    if (randomNumber <= 5) {
      resolve(randomNumber)
    } else {
      reject(randomNumber)
    }
  })
}

generateRandomNumber().then(function(result) {
  console.log('Success: ' + result)
}).catch(function(error) {
  console.log('Error: ' + error)
})

Continue with the normal execution (remember the call stack)

Promises in-depth

function generateRandomNumber () {
  return new Promise(function (resolve, reject) {
    var randomNumber = Math.floor((Math.random() * 10) + 1)
    if (randomNumber <= 5) {
      resolve(randomNumber)
    } else {
      reject(randomNumber)
    }
  })
}

generateRandomNumber().then(function(result) {
  console.log('Success: ' + result)
}).catch(function(error) {
  console.log('Error: ' + error)
})

When the function returns, we enter the `then()` or `catch()`

Promises in-depth

Chaining promises

doSomething(function(result) {
  doSomethingElse(result, function(newResult) {
    doThirdThing(newResult, function(finalResult) {
      console.log('Got the final result: ' + finalResult);
    }, failureCallback);
  }, failureCallback);
}, failureCallback);

Chaining async callbacks

Chaining promises

doSomething().then(function(result) {
  return doSomethingElse(result);
})
.then(function(newResult) {
  return doThirdThing(newResult);
})
.then(function(finalResult) {
  console.log('Got the final result: ' + finalResult);
})
.catch(failureCallback);

Chaining promises

Chaining promises

try {
    let result = await doSomething()
    let nextResult = await doSomethingElse(result)
    let finalResult = await doThirdThing(nextResult)
    console.log('Got the final result: ' + finalResult);
} catch {
 //failureCallback
}

Chaining promises with async/await

Many promises and promises.all()

There are cases where you want to perform the same async action multiple times and wait for all of them to finish in order to continue with the workflow.

Many promises and promises.all()

 function getRandomInt(max) {
   return Math.floor(Math.random() * Math.floor(max));
 }
 
 var asyncMethod = function() {
    var promise = new Promise(function(resolve, reject){
       setTimeout(function() {
          console.log('Async method completed');
          resolve({status: 200});
       }, getRandomInt(5)*1000 );
    });
    return promise;
 };
 
 console.log("Starting to create many promises")
 
 var p1 = asyncMethod()
 var p2 = asyncMethod()
 var p3 = asyncMethod()
 var p4 = asyncMethod()
 var p5 = asyncMethod()
 
 Promise.all([p1, p2, p3, p4, p5]).then(values => {
   console.log("done: " + JSON.stringify(values))
 });
 
 console.log("I'm going to run before all these guys!");

Many promises and promises.all()

 function getRandomInt(max) {
   return Math.floor(Math.random() * Math.floor(max));
 }
 
 var asyncMethod = function() {
    var promise = new Promise(function(resolve, reject){
       setTimeout(function() {
          console.log('Async method completed');
          resolve({status: 200});
       }, getRandomInt(5)*1000 );
    });
    return promise;
 };
 
 console.log("Starting to create many promises")
 
 var p1 = asyncMethod()
 var p2 = asyncMethod()
 var p3 = asyncMethod()
 var p4 = asyncMethod()
 var p5 = asyncMethod()
 
 Promise.all([p1, p2, p3, p4, p5]).then(values => {
   console.log("done: " + JSON.stringify(values))
 });
 
 console.log("I'm going to run before all these guys!");

Define async function

Many promises and promises.all()

 function getRandomInt(max) {
   return Math.floor(Math.random() * Math.floor(max));
 }
 
 var asyncMethod = function() {
    var promise = new Promise(function(resolve, reject){
       setTimeout(function() {
          console.log('Async method completed');
          resolve({status: 200});
       }, getRandomInt(5)*1000 );
    });
    return promise;
 };
 
 console.log("Starting to create many promises")
 
 var p1 = asyncMethod()
 var p2 = asyncMethod()
 var p3 = asyncMethod()
 var p4 = asyncMethod()
 var p5 = asyncMethod()
 
 Promise.all([p1, p2, p3, p4, p5]).then(values => {
   console.log("done: " + JSON.stringify(values))
 });
 
 console.log("I'm going to run before all these guys!");

Run many promises

Many promises and promises.all()

 function getRandomInt(max) {
   return Math.floor(Math.random() * Math.floor(max));
 }
 
 var asyncMethod = function() {
    var promise = new Promise(function(resolve, reject){
       setTimeout(function() {
          console.log('Async method completed');
          resolve({status: 200});
       }, getRandomInt(5)*1000 );
    });
    return promise;
 };
 
 console.log("Starting to create many promises")
 
 var p1 = asyncMethod()
 var p2 = asyncMethod()
 var p3 = asyncMethod()
 var p4 = asyncMethod()
 var p5 = asyncMethod()
 
 Promise.all([p1, p2, p3, p4, p5]).then(values => {
   console.log("done: " + JSON.stringify(values))
 });
 
 console.log("I'm going to run before all these guys!");

Run this only when ALL promises are fulfilled

Many promises and promises.all()

 function getRandomInt(max) {
   return Math.floor(Math.random() * Math.floor(max));
 }
 
 var asyncMethod = function() {
    var promise = new Promise(function(resolve, reject){
       setTimeout(function() {
          console.log('Async method completed');
          resolve({status: 200});
       }, getRandomInt(5)*1000 );
    });
    return promise;
 };
 
 console.log("Starting to create many promises")
 
 var p1 = asyncMethod()
 var p2 = asyncMethod()
 var p3 = asyncMethod()
 var p4 = asyncMethod()
 var p5 = asyncMethod()
 
 Promise.all([p1, p2, p3, p4, p5]).then(values => {
   console.log("done: " + JSON.stringify(values))
 });
 
 console.log("I'm going to run before all these guys!");

Many promises and promises.all()

 function getRandomInt(max) {
   return Math.floor(Math.random() * Math.floor(max));
 }
 
 var asyncMethod = function() {
    var promise = new Promise(function(resolve, reject){
       setTimeout(function() {
          console.log('Async method completed');
          resolve({status: 200});
       }, getRandomInt(5)*1000 );
    });
    return promise;
 };
 
 console.log("Starting to create many promises")
 
 var p1 = asyncMethod()
 var p2 = asyncMethod()
 var p3 = asyncMethod()
 var p4 = asyncMethod()
 var p5 = asyncMethod()
 
 Promise.all([p1, p2, p3, p4, p5]).then(values => {
   console.log("done: " + JSON.stringify(values))
 });
 
 console.log("I'm going to run before all these guys!");

All promises fulfilled, run this.

Many promises and promises.all()

 function getRandomInt(max) {
   return Math.floor(Math.random() * Math.floor(max));
 }
 
 var asyncMethod = function() {
    var promise = new Promise(function(resolve, reject){
       setTimeout(function() {
          console.log('Async method completed');
          resolve({status: 200});
       }, getRandomInt(5)*1000 );
    });
    return promise;
 };
 
 console.log("Starting to create many promises")
 
 var p1 = asyncMethod()
 var p2 = asyncMethod()
 var p3 = asyncMethod()
 var p4 = asyncMethod()
 var p5 = asyncMethod()
 
 Promise.all([p1, p2, p3, p4, p5]).then(values => {
   console.log("done: " + JSON.stringify(values))
 });
 
 console.log("I'm going to run before all these guys!");

Hint: you will want to use this when parsing a single course file. A single course file == a promise. Many of these promises == your dataset.

.all() them all

Testing async methods

it('should do something with promises', function() {
  var blah = 'foo';

  var result = asyncMethod();

  return result.then(function(data) {
    expect(data).to.equal(blah);
  })
  .catch(function(err) {
    Log.test("Something went wrong. Message: " + err);
    expect.fail();
  })
});

Using .then() and .catch()

Testing async methods

it('should do something with promises', function() {
  var blah = 'foo';

  var result = asyncMethod();

  return result.then(function(data) {
    expect(data).to.equal(blah);
  })
  .catch(function(err) {
    Log.test("Something went wrong. Message: " + err);
    expect.fail();
  })
});

Using .then() and .catch()

Blocks the test flow and waits for the return

Testing async methods

it('should do something with promises', function() {
  var blah = 'foo';

  var result = asyncMethod();

  return result.then(function(data) {
    expect(data).to.equal(blah);
  })
  .catch(function(err) {
    Log.test("Something went wrong. Message: " + err);
    expect.fail();
  })
});

Using .then() and .catch()

Testing async methods

it("Should add a valid dataset", async () => {
        const id: string = "courses";
        const expectedCode: number = 204;
        let response: InsightResponse;

        try {
            response = await insightFacade.addDataset(id,
                                                      datasets[id],
                                                      InsightDatasetKind.Courses);
        } catch (err) {
            response = err;
        } finally {
            expect(response.code).to.equal(expectedCode);
        }
});

Using async/await

Common mistake

function generateRandomNumber () {
  return new Promise(function (resolve, reject) {
    var randomNumber = Math.floor((Math.random() * 10) + 1)
    if (randomNumber <= 5) {
      resolve(randomNumber)
    } else {
      reject(randomNumber)
    }
  })
}

var number;

generateRandomNumber().then(function(result) {
  number = result;
  console.log('Success: ' + result)
}).catch(function(error) {
  console.log('Error: ' + error)
})

console.log(number);

Common mistake

function generateRandomNumber () {
  return new Promise(function (resolve, reject) {
    var randomNumber = Math.floor((Math.random() * 10) + 1)
    if (randomNumber <= 5) {
      resolve(randomNumber)
    } else {
      reject(randomNumber)
    }
  })
}

var number;

generateRandomNumber().then(function(result) {
  number = result;
  console.log('Success: ' + result)
}).catch(function(error) {
  console.log('Error: ' + error)
})

console.log(number);

What's going to be logged?

Resources

deck

By Rodrigo Araújo

deck

  • 627
Loading comments...

More from Rodrigo Araújo