---
# System prepended metadata

title: Asynchronous JavaScript Comparison Table

---

# Asynchronous JavaScript Comparison Table

I created this comparison table to clarify some useful differences in using the `fetch()` method and the `async/await` syntax in JavaScript. As a beginner myself, I found it valuable to understand these distinctions and make informed decisions when working with asynchronous operations.

This table is intended to serve as a quick reference for beginners, offering insights into the advantages and trade-offs between using `fetch()` with callbacks and the cleaner `async/await` approach. I hope it proves beneficial to others navigating the complexities of asynchronous coding in JavaScript.

Feel free to explore the provided examples and explanations to help you make informed choices in your own projects. Happy coding!

# Comparison Table

| Feature                                     | `fetch()` without `async/await`                           | `async/await` with an `async` function                     |
| ------------------------------------------- | --------------------------------------------------------- | -------------------------------------------------------- |
| **Syntax**                                  | Relies on `.then()` and `.catch()` for handling promises. | Uses `async` function and `await` keyword for more sequential code. |
| **Readability**                             | Can lead to "callback hell" and less readable code, especially with multiple asynchronous operations. | Provides cleaner and more readable code, resembling synchronous style. |
| **Error Handling**                          | Uses `.catch()` for error handling.                        | Utilizes `try/catch` blocks, making error handling more intuitive. |
| **Promise Chain**                           | Uses `.then()` for chaining promises.                      | Allows linear and more intuitive flow without extensive chaining. |
| **Code Structure**                          | The code structure can be less intuitive and may require nesting. | More linear and resembles synchronous code, enhancing readability. |

## Examples

### `fetch()` without `async/await`:

```javascript
// Without async/await
const fetchDataWithCallbacks = () => {
                fetch('https://jsonplaceholder.typicode.com/users/1')
                    .then(response => {
                        if (!response.ok) {
                            throw new Error('Failed to retrieve data from JSONPlaceholder API');
                        }
                        return response.json();
                    })
                    .then(data => {
                        document.getElementById('data-container').innerHTML += `<p>Data from fetch(): ${JSON.stringify(data)}</p>`;
                        return fetch('https://jsonplaceholder.typicode.com/posts/' + data.id);
                    })
                    .then(response => {
                        if (!response.ok) {
                            throw new Error('Failed to fetch second data');
                        }
                        return response.json();
                    })
                    .then(data => {
                        document.getElementById('data-container').innerHTML += `<p>Data from second fetch(): ${JSON.stringify(data)}</p>`;
                        return fetch('https://jsonplaceholder.typicode.com/comments/' + data.userId);
                    })
                    .then(response => {
                        if (!response.ok) {
                            throw new Error('Failed to fetch third data');
                        }
                        return response.json();
                    })
                    .then(data => {
                        document.getElementById('data-container').innerHTML += `<p>Data from third fetch(): ${JSON.stringify(data)}</p>`;
                    })
                    .catch(error => {
                        document.getElementById('data-container').innerHTML += `<p>Error: ${error.message}</p>`;
                    });
            };

            // Call the fetch function
            fetchDataWithCallbacks();
```

### `async/await` with an `async` function:

```javascript
// Using async/await
const fetchDataWithAsyncAwait = async () => {
                try {
                    // Use async/await for cleaner and more readable code

                    // Fetch data from the first endpoint
                    const response1 = await fetch('https://jsonplaceholder.typicode.com/users/1');
                    if (!response1.ok) {
                        throw new Error('Failed to retrieve data from JSONPlaceholder API');
                    }
                    const data1 = await response1.json();
                    document.getElementById('data-container').innerHTML += `<p>Data from fetch(): ${JSON.stringify(data1)}</p>`;

                    // Fetch data from the second endpoint using data from the first response
                    const response2 = await fetch(`https://jsonplaceholder.typicode.com/posts/${data1.id}`);
                    if (!response2.ok) {
                        throw new Error('Failed to fetch second data');
                    }
                    const data2 = await response2.json();
                    document.getElementById('data-container').innerHTML += `<p>Data from second fetch(): ${JSON.stringify(data2)}</p>`;

                    // Fetch data from the third endpoint using data from the second response
                    const response3 = await fetch(`https://jsonplaceholder.typicode.com/comments/${data2.userId}`);
                    if (!response3.ok) {
                        throw new Error('Failed to fetch third data');
                    }
                    const data3 = await response3.json();
                    document.getElementById('data-container').innerHTML += `<p>Data from third fetch(): ${JSON.stringify(data3)}</p>`;

                } catch (error) {
                    // Handle errors
                    document.getElementById('data-container').innerHTML += `<p>Error: ${error.message}</p>`;
                }
            };

            // Call the async/await fetch function
            fetchDataWithAsyncAwait();
```

# Advantages of async/await

Using async/await often results in cleaner and more readable code compared to nested callback functions. In the rewritten code, the logic is organized in a more sequential manner, making it easier to understand. Each asynchronous operation is awaited, reducing the need for indentation levels and improving code clarity.

## Key Advantages:

1. **Sequential Flow:** The code follows a more natural and sequential flow, making it easier to follow the logic.

2. **Error Handling:** Error handling is consolidated in a single `catch` block, improving maintainability and reducing redundancy.

3. **Reduced Callback Hell:** `async/await` helps mitigate the callback hell issue, making the code flatter and more readable.

4. **Simplified Promises:** The use of `await` simplifies the handling of promises and eliminates the need for explicit chaining.

**Overall**, the `async/await` version is often considered cleaner and more maintainable than the nested callback approach.
