StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PO
primarykey
Id
14220323
data
AcceptedAnswerId
0
AnswerCount
0
ClosedDate
CommentCount
36
CommunityOwnedDate
CreationDate
2013-01-08T17:06:14.013
FavoriteCount
0
LastActivityDate
2018-08-27T11:15:35.347
LastEditDate
2018-08-27T11:15:35.347
LastEditorUserId
6081445
OwnerUserId
218196
ParentId
14220321
PostTypeId
2
Score
4703
ViewCount
0
LastEditorDisplayName
text
Body
<blockquote> <code>-></code> For a more general explanation of async behaviour with different examples, please see <a href="https://stackoverflow.com/q/23667086/218196">Why is my variable unaltered after I modify it inside of a function? - Asynchronous code reference</a> <code>-></code> If you already understand the problem, skip to the possible solutions below. </blockquote> <h1>The problem</h1> The A in <a href="https://en.wikipedia.org/wiki/Ajax_(programming)" rel="nofollow noreferrer">Ajax</a> stands for <a href="https://www.merriam-webster.com/dictionary/asynchronous" rel="nofollow noreferrer">asynchronous</a> . That means sending the request (or rather receiving the response) is taken out of the normal execution flow. In your example, <code>$.ajax</code> returns immediately and the next statement, <code>return result;</code>, is executed before the function you passed as <code>success</code> callback was even called. Here is an analogy which hopefully makes the difference between synchronous and asynchronous flow clearer: <h2>Synchronous</h2> Imagine you make a phone call to a friend and ask him to look something up for you. Although it might take a while, you wait on the phone and stare into space, until your friend gives you the answer that you needed. The same is happening when you make a function call containing "normal" code: <pre><code>function findItem() { var item; while(item_not_found) { // search } return item; } var item = findItem(); // Do something with item doSomethingElse(); </code></pre> Even though <code>findItem</code> might take a long time to execute, any code coming after <code>var item = findItem();</code> has to wait until the function returns the result. <h2>Asynchronous</h2> You call your friend again for the same reason. But this time you tell him that you are in a hurry and he should call you back on your mobile phone. You hang up, leave the house and do whatever you planned to do. Once your friend calls you back, you are dealing with the information he gave to you. That's exactly what's happening when you do an Ajax request. <pre><code>findItem(function(item) { // Do something with item }); doSomethingElse(); </code></pre> Instead of waiting for the response, the execution continues immediately and the statement after the Ajax call is executed. To get the response eventually, you provide a function to be called once the response was received, a callback (notice something? call back ?). Any statement coming after that call is executed before the callback is called. <hr> <h1>Solution(s)</h1> Embrace the asynchronous nature of JavaScript! While certain asynchronous operations provide synchronous counterparts (so does "Ajax"), it's generally discouraged to use them, especially in a browser context. Why is it bad do you ask? JavaScript runs in the UI thread of the browser and any long running process will lock the UI, making it unresponsive. Additionally, there is an upper limit on the execution time for JavaScript and the browser will ask the user whether to continue the execution or not. All of this is really bad user experience. The user won't be able to tell whether everything is working fine or not. Furthermore, the effect will be worse for users with a slow connection. In the following we will look at three different solutions that are all building on top of each other: <ul> <li>Promises with <code>async/await</code> (ES2017+, available in older browsers if you use a transpiler or regenerator)</li> <li>Callbacks (popular in node)</li> <li>Promises with <code>then()</code> (ES2015+, available in older browsers if you use one of the many promise libraries)</li> </ul> All three are available in current browsers, and node 7+. <hr> <h2>ES2017+: Promises with <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function" rel="nofollow noreferrer"><code>async/await</code></a></h2> The new ECMAScript version released in 2017 introduced syntax-level support for asynchronous functions. With the help of <code>async</code> and <code>await</code>, you can write asynchronous in a "synchronous style". Make no mistake though: The code is still asynchronous, but it's easier to read/understand. <code>async/await</code> builds on top of promises: an <code>async</code> function always returns a promise. <code>await</code> "unwraps" a promise and either result in the value the promise was resolved with or throws an error if the promise was rejected. Important: You can only use <code>await</code> inside an <code>async</code> function. That means that at the very top level, you still have to work directly with the promise. You can read more about <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function" rel="nofollow noreferrer"><code>async</code></a> and <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/await" rel="nofollow noreferrer"><code>await</code></a> on MDN. Here is an example that builds on top of delay above: <pre><code>// Using 'superagent' which will return a promise. var superagent = require('superagent') // This is isn't declared as `async` because it already returns a promise function delay() { // `delay` returns a promise return new Promise(function(resolve, reject) { // Only `delay` is able to resolve or reject the promise setTimeout(function() { resolve(42); // After 3 seconds, resolve the promise with value 42 }, 3000); }); } async function getAllBooks() { try { // GET a list of book IDs of the current user var bookIDs = await superagent.get('/user/books'); // wait for 3 seconds (just for the sake of this example) await delay(); // GET information about each book return await superagent.get('/books/ids='+JSON.stringify(bookIDs)); } catch(error) { // If any of the awaited promises was rejected, this catch block // would catch the rejection reason return null; } } // Async functions always return a promise getAllBooks() .then(function(books) { console.log(books); }); </code></pre> Newer <a href="https://kangax.github.io/compat-table/es2016plus/#test-async_functions" rel="nofollow noreferrer">browser</a> and <a href="http://node.green/#ES2017-features-async-functions" rel="nofollow noreferrer">node</a> versions support <code>async/await</code>. You can also support older environments by transforming your code to ES5 with the help of <a href="https://github.com/facebook/regenerator" rel="nofollow noreferrer">regenerator</a> (or tools that use regenerator, such as <a href="https://babeljs.io/" rel="nofollow noreferrer">Babel</a>). <hr> <h2>Let functions accept callbacks</h2> A callback is simply a function passed to another function. That other function can call the function passed whenever it is ready. In the context of an asynchronous process, the callback will be called whenever the asynchronous process is done. Usually, the result is passed to the callback. In the example of the question, you can make <code>foo</code> accept a callback and use it as <code>success</code> callback. So this <pre><code>var result = foo(); // Code that depends on 'result' </code></pre> becomes <pre><code>foo(function(result) { // Code that depends on 'result' }); </code></pre> Here we defined the function "inline" but you can pass any function reference: <pre><code>function myCallback(result) { // Code that depends on 'result' } foo(myCallback); </code></pre> <code>foo</code> itself is defined as follows: <pre><code>function foo(callback) { $.ajax({ // ... success: callback }); } </code></pre> <code>callback</code> will refer to the function we pass to <code>foo</code> when we call it and we simply pass it on to <code>success</code>. I.e. once the Ajax request is successful, <code>$.ajax</code> will call <code>callback</code> and pass the response to the callback (which can be referred to with <code>result</code>, since this is how we defined the callback). You can also process the response before passing it to the callback: <pre><code>function foo(callback) { $.ajax({ // ... success: function(response) { // For example, filter the response callback(filtered_response); } }); } </code></pre> It's easier to write code using callbacks than it may seem. After all, JavaScript in the browser is heavily event-driven (DOM events). Receiving the Ajax response is nothing else but an event. Difficulties could arise when you have to work with third-party code, but most problems can be solved by just thinking through the application flow. <hr> <h2>ES2015+: Promises with <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" rel="nofollow noreferrer">then()</a></h2> The <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise" rel="nofollow noreferrer">Promise API</a> is a new feature of ECMAScript 6 (ES2015), but it has good <a href="http://caniuse.com/#feat=promises" rel="nofollow noreferrer" title="caniuse">browser support</a> already. There are also many libraries which implement the standard Promises API and provide additional methods to ease the use and composition of asynchronous functions (e.g. <a href="https://github.com/petkaantonov/bluebird" rel="nofollow noreferrer">bluebird</a>). Promises are containers for future values. When the promise receives the value (it is resolved) or when it is cancelled (rejected), it notifies all of its "listeners" who want to access this value. The advantage over plain callbacks is that they allow you to decouple your code and they are easier to compose. Here is a simple example of using a promise: <pre><code>function delay() { // `delay` returns a promise return new Promise(function(resolve, reject) { // Only `delay` is able to resolve or reject the promise setTimeout(function() { resolve(42); // After 3 seconds, resolve the promise with value 42 }, 3000); }); } delay() .then(function(v) { // `delay` returns a promise console.log(v); // Log the value once it is resolved }) .catch(function(v) { // Or do something else if it is rejected // (it would not happen in this example, since `reject` is not called). }); </code></pre> Applied to our Ajax call we could use promises like this: <pre><code>function ajax(url) { return new Promise(function(resolve, reject) { var xhr = new XMLHttpRequest(); xhr.onload = function() { resolve(this.responseText); }; xhr.onerror = reject; xhr.open('GET', url); xhr.send(); }); } ajax("/echo/json") .then(function(result) { // Code depending on result }) .catch(function() { // An error occurred }); </code></pre> Describing all the advantages that promise offer is beyond the scope of this answer, but if you write new code, you should seriously consider them. They provide a great abstraction and separation of your code. More information about promises: <a href="http://www.html5rocks.com/en/tutorials/es6/promises/" rel="nofollow noreferrer">HTML5 rocks - JavaScript Promises</a> <h3>Side note: jQuery's deferred objects</h3> <a href="https://stackoverflow.com/questions/4866721/what-are-deferred-objects">Deferred objects</a> are jQuery's custom implementation of promises (before the Promise API was standardized). They behave almost like promises but expose a slightly different API. Every Ajax method of jQuery already returns a "deferred object" (actually a promise of a deferred object) which you can just return from your function: <pre><code>function ajax() { return $.ajax(...); } ajax().done(function(result) { // Code depending on result }).fail(function() { // An error occurred }); </code></pre> <h3>Side note: Promise gotchas</h3> Keep in mind that promises and deferred objects are just containers for a future value, they are not the value itself. For example, suppose you had the following: <pre><code>function checkPassword() { return $.ajax({ url: '/password', data: { username: $('#username').val(), password: $('#password').val() }, type: 'POST', dataType: 'json' }); } if (checkPassword()) { // Tell the user they're logged in } </code></pre> This code misunderstands the above asynchrony issues. Specifically, <code>$.ajax()</code> doesn't freeze the code while it checks the '/password' page on your server - it sends a request to the server and while it waits, immediately returns a jQuery Ajax Deferred object, not the response from the server. That means the <code>if</code> statement is going to always get this Deferred object, treat it as <code>true</code>, and proceed as though the user is logged in. Not good. But the fix is easy: <pre><code>checkPassword() .done(function(r) { if (r) { // Tell the user they're logged in } else { // Tell the user their password was bad } }) .fail(function(x) { // Tell the user something bad happened }); </code></pre> <hr> <h2>Not recommended: Synchronous "Ajax" calls</h2> As I mentioned, some(!) asynchronous operations have synchronous counterparts. I don't advocate their use, but for completeness' sake, here is how you would perform a synchronous call: <h3>Without jQuery</h3> If you directly use a <a href="http://www.w3.org/TR/XMLHttpRequest/" rel="nofollow noreferrer"><code>XMLHTTPRequest</code></a> object, pass <code>false</code> as third argument to <a href="http://www.w3.org/TR/XMLHttpRequest/#the-open%28%29-method" rel="nofollow noreferrer"><code>.open</code></a>. <h3>jQuery</h3> If you use <a href="http://api.jquery.com/jQuery.ajax/" rel="nofollow noreferrer">jQuery</a>, you can set the <code>async</code> option to <code>false</code>. Note that this option is deprecated since jQuery 1.8. You can then either still use a <code>success</code> callback or access the <code>responseText</code> property of the <a href="http://api.jquery.com/jQuery.ajax/#jqXHR" rel="nofollow noreferrer">jqXHR object</a>: <pre><code>function foo() { var jqXHR = $.ajax({ //... async: false }); return jqXHR.responseText; } </code></pre> If you use any other jQuery Ajax method, such as <code>$.get</code>, <code>$.getJSON</code>, etc., you have to change it to <code>$.ajax</code> (since you can only pass configuration parameters to <code>$.ajax</code>). Heads up! It is not possible to make a synchronous <a href="https://stackoverflow.com/questions/2067472/please-explain-jsonp">JSONP</a> request. JSONP by its very nature is always asynchronous (one more reason to not even consider this option).
Tags
Title
singulars
PostAcceptedAnswerId
1. This table or related slice is empty.
PostParentId
1. POHow do I return the response from an asynchronous call?
 singulars
 PostTypePostTypeId
 PTQuestion
PostTypePostTypeId
1. PTAnswer
UserLastEditorUserId
1. This table or related slice is empty.
UserOwnerUserId
1. USFelix Kling
plurals
PostLinksPostIdRelatedPostId
1. This table or related slice is empty.
PostLinksRelatedPostIdPostId
1. This table or related slice is empty.
PostsAcceptedAnswerId
1. POHow do I return the response from an asynchronous call?
 singulars
 PostTypePostTypeId
 PTQuestion
PostsParentIdCreationDate
1. This table or related slice is empty.
VotesPostIdCreationDate
1. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
2. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
3. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
CommentsPostId

Querying!

Guidance

A row detail

Detail views are divided into sections. All the information in the data section comes from columns in the selected row. The other sections display data from other, related rows.

Related data can be related in a to-one or a to-many fashion. Captions of data related in a to-many fashion link to a list view showing a filtered view of the table.

Try moving around until you find a non-empty to-many entry and click on the label to get to one. You can move back to the root by clicking on the database name in the header.