JavaScript - fra tilbagekald til asynkronisering / afventning
JavaScript er synkron. Dette betyder, at den udfører din kodeblok efter ordre efter hejsning. Inden koden udføres, var
og function
erklæringer "hejses" til toppen af deres anvendelsesområde.
Dette er et eksempel på en synkron kode:
console.log('1') console.log('2') console.log('3')
Denne kode logger pålideligt “1 2 3”.
Asynkrone anmodninger venter på, at en timer er færdig, eller en anmodning om at svare, mens resten af koden fortsætter med at udføre. Så når tiden er inde, springer disse tilbagekald tilbage til disse asynkrone anmodninger.
Dette er et eksempel på en asynkron kode:
console.log('1') setTimeout(function afterTwoSeconds() { console.log('2') }, 2000) console.log('3')
Dette logger faktisk “1 3 2”, da “2” er på en, setTimeout
der kun udføres ved dette eksempel efter to sekunder. Din applikation hænger ikke og venter på, at de to sekunder er færdige. I stedet fortsætter den med at udføre resten af koden, og når timeoutet er afsluttet, vender det tilbage til afterTwoSeconds.
Du kan spørge "Hvorfor er det nyttigt?" eller “Hvordan får jeg min asynkroniseringskode til at blive synkroniseret?”. Forhåbentlig kan jeg vise dig svarene.
"Problemet"
Lad os sige, at vores mål er at søge efter en GitHub-bruger og få alle brugernes opbevaringssteder. Sagen er, at vi ikke ved det nøjagtige navn på brugeren. Så vi er nødt til at liste alle brugere med lignende navn og deres respektive arkiver.
Behøver ikke at være super fancy, noget som dette

I disse eksempler bruger anmodningskoden XHR (XMLHttpRequest). Du kan erstatte det med jQuery $.ajax
eller den nyere native-tilgang kaldet fetch
. Begge giver dig løfterne nærmer sig porten.
Det ændres lidt afhængigt af din tilgang, men som en starter:
// url argument can be something like '//api.github.com/users/daspinola/repos' function request(url) { const xhr = new XMLHttpRequest(); xhr.timeout = 2000; xhr.onreadystatechange = function(e) { if (xhr.readyState === 4) { if (xhr.status === 200) { // Code here for the server answer when successful } else { // Code here for the server answer when not successful } } } xhr.ontimeout = function () { // Well, it took to long do some code here to handle that } xhr.open('get', url, true) xhr.send(); }
Husk, at i disse eksempler er den vigtige del ikke, hvad slutresultatet af koden er. I stedet skal dit mål være at forstå forskellene i fremgangsmåderne, og hvordan du kan udnytte dem til din udvikling.
Ring tilbage
Du kan gemme en reference til en funktion i en variabel, når du bruger JavaScript. Derefter kan du bruge dem som argumenter for en anden funktion til at udføre senere. Dette er vores "tilbagekaldelse".
Et eksempel ville være:
// Execute the function "doThis" with another function as parameter, in this case "andThenThis". doThis will execute whatever code it has and when it finishes it should have "andThenThis" being executed. doThis(andThenThis) // Inside of "doThis" it's referenced as "callback" which is just a variable that is holding the reference to this function function andThenThis() { console.log('and then this') } // You can name it whatever you want, "callback" is common approach function doThis(callback) { console.log('this first') // the '()' is when you are telling your code to execute the function reference else it will just log the reference callback() }
Brug af callback
til at løse vores problem giver os mulighed for at gøre noget lignende til den request
funktion, vi definerede tidligere:
function request(url, callback) { const xhr = new XMLHttpRequest(); xhr.timeout = 2000; xhr.onreadystatechange = function(e) { if (xhr.readyState === 4) { if (xhr.status === 200) { callback(null, xhr.response) } else { callback(xhr.status, null) } } } xhr.ontimeout = function () { console.log('Timeout') } xhr.open('get', url, true) xhr.send(); }
Vores funktion til anmodningen accepterer nu a, callback
så når en request
er lavet, kaldes den i tilfælde af fejl og i tilfælde af succes.
const userGet = `//api.github.com/search/users?page=1&q=daspinola&type=Users` request(userGet, function handleUsersList(error, users) { if (error) throw error const list = JSON.parse(users).items list.forEach(function(user) { request(user.repos_url, function handleReposList(err, repos) { if (err) throw err // Handle the repositories list here }) }) })
Opdel dette:
- Vi anmoder om at få en brugers opbevaringssteder
- Når anmodningen er afsluttet, bruger vi tilbagekald
handleUsersList
- Hvis der ikke er nogen fejl, analyserer vi vores serverrespons i et objekt ved hjælp af
JSON.parse
- Derefter gentager vi vores brugerliste, da den kan have mere end en
For hver bruger beder vi om deres opbevaringsliste.
Vi bruger den url, der returneres pr. Bruger i vores første svar
Vi kalder
repos_url
som url til vores næste anmodninger eller fra det første svar - Når anmodningen har gennemført tilbagekaldet, ringer vi op
Dette håndterer enten dens fejl eller svaret med listen over opbevaringssteder for den bruger
Bemærk : At sende fejlen først som parameter er en almindelig praksis, især når du bruger Node.js.
En mere "komplet" og læsbar tilgang ville være at have en vis fejlhåndtering. Vi vil holde tilbagekaldet adskilt fra anmodningen.
Noget som dette:
try { request(userGet, handleUsersList) } catch (e) { console.error('Request boom! ', e) } function handleUsersList(error, users) { if (error) throw error const list = JSON.parse(users).items list.forEach(function(user) { request(user.repos_url, handleReposList) }) } function handleReposList(err, repos) { if (err) throw err // Handle the repositories list here console.log('My very few repos', repos) }
Dette ender med at have problemer som racing og problemer med fejlhåndtering. Racing sker, når du ikke styrer, hvilken bruger du får først. Vi anmoder om oplysningerne for dem alle, hvis der er mere end en. Vi tager ikke en ordre i betragtning. For eksempel kan bruger 10 komme først og bruger 2 sidst. Vi har en mulig løsning senere i artiklen.
Det største problem med tilbagekald er, at vedligeholdelse og læsbarhed kan blive en smerte. Det er allerede noget, og koden gør næppe noget. Dette er kendt som callback helvede, som kan undgås med vores næste tilgang.

Løfter
Løfter du kan gøre din kode mere læselig. En ny udvikler kan komme til kodebasen og se en klar rækkefølge for udførelse af din kode.
For at skabe et løfte kan du bruge:
const myPromise = new Promise(function(resolve, reject) { // code here if (codeIsFine) { resolve('fine') } else { reject('error') } }) myPromise .then(function whenOk(response) { console.log(response) return response }) .catch(function notOk(err) { console.error(err) })
Lad os nedbryde det:
- Et løfte initialiseres med et
function
der harresolve
ogreject
udsagn - Lav din async-kode inde i
Promise
funktionenresolve
når alt sker som ønsketEllers
reject
- Når a
resolve
er fundet.then
, udføres metoden for detPromise
Når a
reject
er fundet.catch
udløses viljen
Ting at huske på:
resolve
andreject
only accept one parameterresolve(‘yey’, ‘works’)
will only send ‘yey’ to the.then
callback function- If you chain multiple
.then
Add a
return
if you want the next.then
value not to beundefined
- When a
reject
is caught with.catch
if you have a.then
chained to itIt will still execute that
.then
You can see the
.then
as an “always executes” and you can check an example in this comment - With a chain on
.then
if an error happens on the first oneIt will skip subsequent
.then
until it finds a.catch
- A promise has three states
pending
- When waiting for a
resolve
orreject
to happenresolved
rejected
- Once it’s in a
resolved
orrejected
stateIt cannot be changed
Note: You can create promises without the function at the moment of declarations. The way that I’m showing it is only a common way of doing it.
“Theory, theory, theory…I’m confused” you may say.
Let’s use our request example with a promise to try to clear things up:
function request(url) { return new Promise(function (resolve, reject) { const xhr = new XMLHttpRequest(); xhr.timeout = 2000; xhr.onreadystatechange = function(e) { if (xhr.readyState === 4) { if (xhr.status === 200) { resolve(xhr.response) } else { reject(xhr.status) } } } xhr.ontimeout = function () { reject('timeout') } xhr.open('get', url, true) xhr.send(); }) }
In this scenario when you execute request
it will return something like this:

const userGet = `//api.github.com/search/users?page=1&q=daspinola&type=Users` const myPromise = request(userGet) console.log('will be pending when logged', myPromise) myPromise .then(function handleUsersList(users) { console.log('when resolve is found it comes here with the response, in this case users ', users) const list = JSON.parse(users).items return Promise.all(list.map(function(user) { return request(user.repos_url) })) }) .then(function handleReposList(repos) { console.log('All users repos in an array', repos) }) .catch(function handleErrors(error) { console.log('when a reject is executed it will come here ignoring the then statement ', error) })
This is how we solve racing and some of the error handling problems. The code is still a bit convoluted. But its a way to show you that this approach can also create readability problems.
A quick fix would be to separate the callbacks like so:
const userGet = `//api.github.com/search/users?page=1&q=daspinola&type=Users` const userRequest = request(userGet) // Just by reading this part out loud you have a good idea of what the code does userRequest .then(handleUsersList) .then(repoRequest) .then(handleReposList) .catch(handleErrors) function handleUsersList(users) { return JSON.parse(users).items } function repoRequest(users) { return Promise.all(users.map(function(user) { return request(user.repos_url) })) } function handleReposList(repos) { console.log('All users repos in an array', repos) } function handleErrors(error) { console.error('Something went wrong ', error) }
By looking at what userRequest
is waiting in order with the .then
you can get a sense of what we expect of this code block. Everything is more or less separated by responsibility.
This is “scratching the surface” of what Promises are. To have a great insight on how they work I cannot recommend enough this article.
Generators
Another approach is to use the generators. This is a bit more advance so if you are starting out feel free to jump to the next topic.
One use for generators is that they allow you to have async code looking like sync.
They are represented by a *
in a function and look something like:
function* foo() { yield 1 const args = yield 2 console.log(args) } var fooIterator = foo() console.log(fooIterator.next().value) // will log 1 console.log(fooIterator.next().value) // will log 2 fooIterator.next('aParam') // will log the console.log inside the generator 'aParam'
Instead of returning with a return
, generators have a yield
statement. It stops the function execution until a .next
is made for that function iteration. It is similar to .then
promise that only executes when resolved comes back.
Our request function would look like this:
function request(url) { return function(callback) { const xhr = new XMLHttpRequest(); xhr.onreadystatechange = function(e) { if (xhr.readyState === 4) { if (xhr.status === 200) { callback(null, xhr.response) } else { callback(xhr.status, null) } } } xhr.ontimeout = function () { console.log('timeout') } xhr.open('get', url, true) xhr.send() } }
We want to have the url
as an argument. But instead of executing the request out of the gate we want it only when we have a callback to handle the response.
Our generator
would be something like:
function* list() { const userGet = `//api.github.com/search/users?page=1&q=daspinola&type=Users` const users = yield request(userGet) yield for (let i = 0; i<=users.length; i++) { yield request(users[i].repos_url) } }
It will:
- Wait until the first
request
is prepared - Return a
function
reference expecting acallback
for the firstrequest
Our
request
function accepts aurl
and returns a
function
that expects acallback
- Expect a
users
to be sent in the next.next
- Iterate over
users
- Wait for a
.next
for each of theusers
- Return their respective callback function
So an execution of this would be:
try { const iterator = list() iterator.next().value(function handleUsersList(err, users) { if (err) throw err const list = JSON.parse(users).items // send the list of users for the iterator iterator.next(list) list.forEach(function(user) { iterator.next().value(function userRepos(error, repos) { if (error) throw repos // Handle each individual user repo here console.log(user, JSON.parse(repos)) }) }) }) } catch (e) { console.error(e) }
We could separate the callback functions like we did previously. You get the deal by now, a takeaway is that we now can handle each individual user repository list individually.
I have mixed felling about generators. On one hand I can get a grasp of what is expected of the code by looking at the generator.
But its execution ends up having similar problems to the callback hell.
Like async/await, a compiler is recommended. This is because it isn’t supported in older browser versions.
Also it isn’t that common in my experience. So it may generate confusing in codebases maintained by various developers.
An awesome insight of how generators work can be found in this article. And here is another great resource.
Async/Await
This method seems like a mix of generators with promises. You just have to tell your code what functions are to be async
. And what part of the code will have to await
for that promise
to finish.
sumTwentyAfterTwoSeconds(10) .then(result => console.log('after 2 seconds', result)) async function sumTwentyAfterTwoSeconds(value) { const remainder = afterTwoSeconds(20) return value + await remainder } function afterTwoSeconds(value) { return new Promise(resolve => { setTimeout(() => { resolve(value) }, 2000); }); }
In this scenario:
- We have
sumTwentyAfterTwoSeconds
as being an async function - We tell our code to wait for the
resolve
orreject
for our promise functionafterTwoSeconds
- It will only end up in the
.then
when theawait
operations finishIn this case there is only one
Applying this to our request
we leave it as a promise
as seen earlier:
function request(url) { return new Promise(function(resolve, reject) { const xhr = new XMLHttpRequest(); xhr.onreadystatechange = function(e) { if (xhr.readyState === 4) { if (xhr.status === 200) { resolve(xhr.response) } else { reject(xhr.status) } } } xhr.ontimeout = function () { reject('timeout') } xhr.open('get', url, true) xhr.send() }) }
We create our async
function with the needed awaits like so:
async function list() { const userGet = `//api.github.com/search/users?page=1&q=daspinola&type=Users` const users = await request(userGet) const usersList = JSON.parse(users).items usersList.forEach(async function (user) { const repos = await request(user.repos_url) handleRepoList(user, repos) }) } function handleRepoList(user, repos) { const userRepos = JSON.parse(repos) // Handle each individual user repo here console.log(user, userRepos) }
So now we have an async list
function that will handle the requests. Another async is needed in the forEach
so that we have the list of repos
for each user to manipulate.
We call it as:
list() .catch(e => console.error(e))
This and the promises approach are my favorites since the code is easy to read and change. You can read about async/await more in depth here.
A downside of using async/await is that it isn’t supported in the front-end by older browsers or in the back-end. You have to use the Node 8.
You can use a compiler like babel to help solve that.
“Solution”
You can see the end code accomplishing our initial goal using async/await in this snippet.
A good thing to do is to try it yourself in the various forms referenced in this article.
Conclusion
Depending on the scenario you might find yourself using:
- async/await
- callbacks
- mix
It’s up to you what fits your purposes. And what lets you maintain the code so that it is understandable to others and your future self.
Note: Any of the approaches become slightly less verbose when using the alternatives for requests like $.ajax
and fetch
.
Fortæl mig, hvad du ville gøre forskellige og forskellige måder, du fandt for at gøre hver tilgang mere læselig.
Dette er artikel 11 af 30. Det er en del af et projekt til offentliggørelse af en artikel mindst en gang om ugen, fra inaktive tanker til tutorials. Efterlad en kommentar, følg mig på Diogo Spínola og gå derefter tilbage til dit geniale projekt!