By the end of this, developers should be able to:
- Explain the value of using promises instead of callback interfaces.
- Read Node documentation that uses callbacks and translate that into implementations using promises.
- Rewrite Node scripts using callbacks as scripts using promises.
- Fork and clone this repository.
- Install dependencies with
npm install.
Asynchronous code necessitates callbacks. But dealing with lots of callbacks can be tricky:
- Callbacks can be messy when they're nested: "callback hell". See
lib/copy-json.js. - Each callback will have to handle it's own errors if necessary.
- In complex programs, it will be hard to tell in what order callbacks fire.
Fortunately, there's a better way: Promises.
Promises are objects that represent steps in an asynchronous process. As of 2016, they are natively supported in Node.
Take a few minutes to read the API documentation on Promises. Note function signatures and argument types as you read. What arguments does a promise take when it is constructed?
Promises offer several advantages over callbacks.
- Promises, like callbacks, make asynchronicity explicit.
- Promises, unlike callbacks, clarify the order of execution.
- Promises are easier to read than callbacks.
- Promises can simplify error handling.
// remember that callback is something you write, in this case to perform some
// processing on parsed JSON
const readJSON = function (filename, callback){
fs.readFile(filename, 'utf8', function (err, res){
if (err) {
return callback(err); // what's going on here?
}
callback(null, JSON.parse(res)); // what if JSON.parse errors out?
});
};What are some weaknesses in this code? And the following?
const readJSON = function (filename, callback){ // 👀 here
fs.readFile(filename, 'utf8', function (err, res){
if (err) {
return callback(err); // pass the error from readFile
}
try {
res = JSON.parse(res);
} catch (ex) {
return callback(ex); // pass the error from JSON.parse
}
callback(null, res); // don't pass the error, since we should have caught it
});
};What about this instead?
const readJSON = function (filename) { // <-- look here
return new Promise((resolve, reject) => {
fs.readFile(filename, { encoding: 'utf8' }, (err, res) => {
if (err) {
reject(err);
} else {
resolve(res);
}
});
})
.then((res) => {
return JSON.parse(res)
});
};
readJSON('./example.json')
.then((pojo) => {
callback(pojo); // do something with the object
})
.catch((err) => { // handle error conditions
console.error(err);
});That's too verbose. This is better:
const readJSON = function (filename) {
return new Promise((resolve, reject) => {
fs.readFile(filename, { encoding: 'utf8' }, (err, res) => {
if (err) {
reject(err);
} else {
resolve(res);
}
});
})
.then(JSON.parse); // what can we surmise about .then?
};
readJSON('./example.json')
.then(callback) // do something with the object
.catch(console.error); // handle error conditions- Promise - JavaScript | MDN
- Promises
- Common Promise Mistakes
- Promisees · Courtesy of ponyfoo.com
- wbinnssmith/awesome-promises: A curated list of useful resources for JavaScript Promises
- How to escape Promise Hell — Medium
- All content is licensed under a CCBYNCSA 4.0 license.
- All software code is licensed under GNU GPLv3. For commercial use or alternative licensing, please contact [email protected].
React
Typescript
Django
Laravel
Facebook
Microsoft
Google
Alibaba
D3
Tencent