JavaScript - από επιστροφές κλήσης σε ασύγχρονο / αναμονή

Το JavaScript είναι σύγχρονο. Αυτό σημαίνει ότι θα εκτελέσει το μπλοκ κώδικα σας κατά παραγγελία μετά την ανύψωση. Πριν εκτελεστεί ο κώδικας varκαι οι functionδηλώσεις «ανυψωθούν» στην κορυφή του πεδίου εφαρμογής τους.

Αυτό είναι ένα παράδειγμα σύγχρονου κώδικα:

console.log('1') console.log('2') console.log('3')

Αυτός ο κωδικός θα καταγράφει αξιόπιστα το "1 2 3".

Τα ασύγχρονα αιτήματα θα περιμένουν να τελειώσει ο χρονοδιακόπτης ή ένα αίτημα για απάντηση, ενώ ο υπόλοιπος κώδικας συνεχίζει να εκτελείται. Στη συνέχεια, όταν η ώρα είναι σωστή, μια επανάκληση θα ενεργοποιήσει αυτά τα ασύγχρονα αιτήματα.

Αυτό είναι ένα παράδειγμα ασύγχρονου κώδικα:

console.log('1') setTimeout(function afterTwoSeconds() { console.log('2') }, 2000) console.log('3')

Αυτό θα καταγράψει στην πραγματικότητα το "1 3 2", καθώς το "2" βρίσκεται σε ένα setTimeoutπου θα εκτελεστεί, μόνο με αυτό το παράδειγμα, μετά από δύο δευτερόλεπτα. Η εφαρμογή σας δεν κρέμεται περιμένοντας να ολοκληρωθούν τα δύο δευτερόλεπτα. Αντ 'αυτού συνεχίζει να εκτελεί τον υπόλοιπο κώδικα και όταν τελειώσει το χρονικό όριο, επιστρέφει σε AfterTwoSeconds.

Μπορείτε να ρωτήσετε "Γιατί είναι χρήσιμο αυτό;" ή "Πώς μπορώ να αποκτήσω τον συγχρονισμό μου για τον συγχρονισμό;". Ας ελπίσουμε ότι μπορώ να σας δείξω τις απαντήσεις.

"Το πρόβλημα"

Ας πούμε ότι στόχος μας είναι να αναζητήσουμε έναν χρήστη του GitHub και να λάβουμε όλα τα αποθετήρια αυτού του χρήστη. Το θέμα είναι ότι δεν γνωρίζουμε το ακριβές όνομα του χρήστη. Πρέπει λοιπόν να απαριθμήσουμε όλους τους χρήστες με παρόμοιο όνομα και τα αντίστοιχα αποθετήρια τους.

Δεν χρειάζεται σούπερ φανταχτερό, κάτι σαν αυτό

Σε αυτά τα παραδείγματα ο κωδικός αιτήματος θα χρησιμοποιεί XHR (XMLHttpRequest). Μπορείτε να το αντικαταστήσετε με το jQuery $.ajaxή την πιο πρόσφατη εγγενή προσέγγιση που ονομάζεται fetch. Και οι δύο θα σας δώσουν την προσέγγιση των υποσχέσεων από την πύλη.

Θα αλλάξει ελαφρώς ανάλογα με την προσέγγισή σας αλλά ως εκκινητής:

// 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(); }

Να θυμάστε ότι σε αυτά τα παραδείγματα το σημαντικό μέρος δεν είναι το τελικό αποτέλεσμα του κώδικα. Αντίθετα, ο στόχος σας πρέπει να είναι να κατανοήσετε τις διαφορές των προσεγγίσεων και πώς μπορείτε να τις αξιοποιήσετε για την ανάπτυξή σας.

Επιστροφή κλήσης

Μπορείτε να αποθηκεύσετε μια αναφορά μιας συνάρτησης σε μια μεταβλητή όταν χρησιμοποιείτε JavaScript. Στη συνέχεια, μπορείτε να τα χρησιμοποιήσετε ως ορίσματα μιας άλλης συνάρτησης για εκτέλεση αργότερα. Αυτή είναι η «επιστροφή κλήσης» μας.

Ένα παράδειγμα θα ήταν:

// 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() }

Η χρήση του callbackγια την επίλυση του προβλήματος μας επιτρέπει να κάνουμε κάτι τέτοιο στη requestλειτουργία που ορίσαμε νωρίτερα:

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(); }

Η λειτουργία μας για το αίτημα θα αποδεχτεί τώρα callbackέτσι ώστε όταν requestδημιουργηθεί θα καλείται σε περίπτωση σφάλματος και σε περίπτωση επιτυχίας.

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 }) }) })

Κατανοώντας αυτό:

  • Κάνουμε ένα αίτημα για λήψη αποθετηρίων χρήστη
  • Αφού ολοκληρωθεί το αίτημα, χρησιμοποιούμε επιστροφή κλήσης handleUsersList
  • Εάν δεν υπάρχει σφάλμα, αναλύουμε την απόκριση του διακομιστή μας σε ένα αντικείμενο χρησιμοποιώντας JSON.parse
  • Στη συνέχεια επαναλαμβάνουμε τη λίστα χρηστών μας, καθώς μπορεί να έχει περισσότερα από ένα

    Για κάθε χρήστη ζητάμε τη λίστα αποθετηρίων του.

    Θα χρησιμοποιήσουμε τη διεύθυνση URL που επέστρεψε ανά χρήστη στην πρώτη μας απάντηση

    Καλούμε repos_urlως url για τα επόμενα αιτήματά μας ή από την πρώτη απάντηση

  • Όταν το αίτημα έχει ολοκληρωθεί η επιστροφή κλήσης, θα καλέσουμε

    Αυτό θα χειριστεί είτε το σφάλμα είτε την απόκριση με τη λίστα αποθετηρίων για αυτόν τον χρήστη

Σημείωση : Η αποστολή του σφάλματος πρώτα ως παράμετρος είναι μια συνήθης πρακτική ειδικά όταν χρησιμοποιείτε το Node.js.

Μια πιο «ολοκληρωμένη» και ευανάγνωστη προσέγγιση θα ήταν να έχουμε κάποιο χειρισμό σφαλμάτων. Θα διατηρούσαμε την επιστροφή κλήσης ξεχωριστή από την εκτέλεση του αιτήματος.

Κάτι σαν αυτό:

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) }

Αυτό καταλήγει να έχει προβλήματα όπως αγώνες αγώνων και προβλήματα χειρισμού σφαλμάτων. Ο αγώνας συμβαίνει όταν δεν ελέγχετε ποιος χρήστης θα αποκτήσετε πρώτος. Ζητούμε τις πληροφορίες για όλους σε περίπτωση που υπάρχουν περισσότερα από ένα. Δεν λαμβάνουμε υπόψη μας μια παραγγελία. Για παράδειγμα, ο χρήστης 10 μπορεί να έρθει πρώτος και ο χρήστης 2 τελευταίος. Έχουμε μια πιθανή λύση αργότερα στο άρθρο.

Το κύριο πρόβλημα με τις επιστροφές κλήσεων είναι ότι η συντήρηση και η αναγνωσιμότητα μπορεί να γίνει πόνος. Είναι ήδη και ο κώδικας δεν κάνει σχεδόν τίποτα. Αυτό είναι γνωστό ως callback hell που μπορεί να αποφευχθεί με την επόμενη προσέγγισή μας.

Υποσχέσεις

Υποσχέσεις μπορείτε να κάνετε τον κωδικό σας πιο ευανάγνωστο. Ένας νέος προγραμματιστής μπορεί να έρθει στη βάση κώδικα και να δει μια σαφή σειρά εκτέλεσης στον κώδικά σας.

Για να δημιουργήσετε μια υπόσχεση μπορείτε να χρησιμοποιήσετε:

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) })

Ας το αποσυνθέσουμε:

  • Μια υπόσχεση αρχικοποιείται με ένα functionπου έχει resolveκαι rejectδηλώσεις
  • Φτιάξτε τον κωδικό ασύγχρονής σας μέσα στη Promiseσυνάρτηση

    resolve όταν όλα συμβαίνουν όπως επιθυμείτε

    Σε διαφορετική περίπτωση reject

  • Όταν resolveβρεθεί a , η .thenμέθοδος θα εκτελεστεί για αυτόPromise

    Όταν reject βρεθεί το a , .catch θα ενεργοποιηθεί

Πράγματα που πρέπει να θυμάστε:

  • resolve and reject only accept one parameter

    resolve(‘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 be undefined

  • When a reject is caught with .catch if you have a .then chained to it

    It 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 one

    It will skip subsequent .then until it finds a .catch

  • A promise has three states

    pending

  • When waiting for a resolve or reject to happen

    resolved

    rejected

  • Once it’s in a resolved or rejected state

    It 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 a callback for the first request

    Our request function accepts a url

    and returns a function that expects a callback

  • Expect a users to be sent in the next .next
  • Iterate over users
  • Wait for a .next for each of the users
  • 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 or reject for our promise function afterTwoSeconds
  • It will only end up in the .then when the await operations finish

    In 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.

Επιτρέψτε μου να ξέρω τι θα κάνατε διαφορετικούς και διαφορετικούς τρόπους που βρήκατε για να κάνετε κάθε προσέγγιση πιο ευανάγνωστη.

Αυτό είναι το άρθρο 11 του 30. Είναι μέρος ενός έργου για τη δημοσίευση ενός άρθρου τουλάχιστον μία φορά την εβδομάδα, από αδρανείς σκέψεις έως σεμινάρια. Αφήστε ένα σχόλιο, ακολουθήστε με στο Diogo Spínola και μετά επιστρέψτε στο λαμπρό έργο σας!