Asynchronous Code
When cleaning your home, it wouldn't be very time efficient to first put the clothes in the laundry and sit there and wait until the clothes are done before moving on to the dishes.
Ideally, you'd want to start some task, and while that task is running, start another task. That's what's known as working in an asynchronous (async) manner!
Just as it applies to the real world, async code also exists. As such, this section will specifically cover the following pieces of async code as they relate to JavaScript:
- Creating Callbacks Overview
- Creating Promises Overview
- Homework: Putting it all together
Creating Callbacks
With some local businesses opening up, people are starting to spend time together at area restaurants.
Imagine you and a friend are outside of the United States and decide to go to a restaurant. The process is usually the same wherever you go: You both provide your orders to the waiter, the waiter goes off, while you two continue conversing. After a while your order comes back.
This is a callback in real life😲
Simply put, you asked for something (a meal) and when the food is done, you will be notified.
Here's a small code example of a callback
In the above example, we first create a function that takes in as an argument, a function🤯. Remember that in JavaScript, functions can be passed around just like any other piece of data. Note that it's common to name this generic function callback
.
This function, fetchQuarantineMood
is in charge of generating a random mood, and then calling the passed in function (hence the name "callback") with that mood.
Now that we've seen an example of what a basic callback looks like, it's a good time to point out a common notion: When using a callback, the implementation details of the callback logic are not important. It's a black box.
The other part to consider, is that because this is asynchronous, any code we have after our call to fetchQuarantineMood
will run. This notion of running our synchronous code first, then running our asynchronous code is known as the JavaScript event loop and is explained amazingly well in this YouTube video👇🏽
With a stronger understanding of callbacks, feel free to take a moment to review a more real world example below. I made sure to add comments to help understand what is happening, though you're encouraged to play around with the code as well.
Creating Promises
If the analogy for a callback is placing an order at a restaurant, the analogy for a promise is asking someone if they want to watch a movie.
In the above situation, there're a few ways this could turn out:
Good: You can go to the movies🍿
Bad: You're going to Netflix and quarantine alone😩
And in the meantime...I don't know.
This maps directly to how JavaScript promises work. However, we don't say good, bad and I don't know.
Instead, we say resolved, rejected, and pending respectively.
Similar to before, let's take a look at what creating and using a basic promise looks like.
In the above example, fetchUser
is a function and inside of its body, we return
a new
Promise
. The Promise
function expects a single function (a callback!) that gives us resolve
and reject
.
Now there's a lot of functions being thrown around here, but just note that resolve
and reject
are also functions. However, only one of them will be called based of off some condition--hence the if-statement.
Using a Promise
When calling a promise-based function, what is returned is an object whereby one of the properties we can use is then
. This property is a function that when called, takes in two arguments: A function that will run if things go well (resolved
), and another that will run with things do not (rejected
).
🗒️ An important item to remember, especially when starting out, is that whatever value that we return from a promise, is wrapped in a promise. This allows us to chain promises together. You'll see an example of this in the example below.
Example: Promise Chaining and Error Handling
🚨Homework: Challenge Area🚨
In the above sandbox example, note that we are not checking for an error state. Let's fix that!
In the above sandbox:
- Create a function called
createErrorMessage
that will:- Take in as an argument, a "message".
- Create an empty paragraph tag.
- Return a paragraph tag that has its
innerText
set to the provided message.
- Change the
addImageNodeToScreen
function to be more generic so that it can accommodate adding any DOM node to the screen. Be sure to refactor areas where it's called. - In the first
.then
offetchUser
, add a second argument.- This function will be called if there is an issue fetching data from the api.
- This function should return an error message set to a string of your choosing, but beginning with "Error:" ie "Error: unable to fetch image"
- In the final
.then
offetchUser
, check if the given string startsWithError:
- If it does, call
createErrorMessage
with that string. - Else, call
createImageNode
as it currently is.
- If it does, call
- Test out your solution by removing some characters from the
randomuser.me/api
string at the top of the file and then clicking the button.
You should see your error message!
As is JavaScript, there's much more that we could discuss when it comes to callbacks, promises, and asynchronous code in general.
However, I hope this serves as a practical guide to help you understand how to both use and create an async workflow!
Thanks for following along and I look forward to seeing your solutions, improvements, and thoughts in the comments!
🙏🏽 cover image and top image provided by icons 8
Top comments (0)