- [Async/Await](#async)

This is the old-fashioned classical approach to asynchronous programming. You provide a function as an argument to another function that executes an asynchronous task. When the asynchronous task completes, the executing function calls your callback function.

well as global variables.

The disadvantage of using callback occurs when you have multiple chained async tasks, which requires you to define callback inside callback, inside callback and that result in **callback hell**

Promises have been introduced in ES6 (2015) to allow for more readable asynchronous code than is possible with callbacks.

The main difference between callbacks and promises is that with callbacks you tell the executing function

what to do when the asynchronous task completes, whereas with promises the executing function returns a special

object to you (the promise) and then you tell the promise what to do when the asynchronous task completes.

```javascript

let promise = new Promise(function(resolve, reject) {

resolve(1);

});

promise.then(data=> console.log(data));

<a name=“async”/>

Async/await has been introduced in ES8 (2017). This technique should really be listed under promises, because it is just syntactic sugar for working with promises. However, it is a syntactic sugar that is really worth looking at.

async function f() {

try {

let response = await fetch('https://jsonplaceholder.typicode.com/posts');

let user = await response.json();

console.log(user);

} catch(err) {

// catches errors both in fetch and response.json

alert(err);

}

}

f();