Suggest an edit

Improve this article

Refine the answer for “What happens if you don't use await?”. Your changes go to moderation before they’re published.

Approval required

Content

What you’re changing

Title (EN)

Short answer (EN)

Shown above the full answer for quick recall.

Answer (EN)

## The key idea

If you don't use `await`, then **instead of the result** you get the `Promise` **itself**,
a promise that will settle eventually, but **hasn't yet**.

> Without `await` you don't "wait" for the result, you just create a promise and move on.

---

## Example 1: without `await`, a promise is returned

```javascript
async function getData() {
  return 'Data';
}

async function main() {
  const result = getData(); // without await
  console.log(result);
}

main();
```

**Output:**

```javascript
Promise { 'Data' }
```

Why:

- `getData()` is an `async` function, so it **always returns a promise**;
- without `await` you get a **Promise object**, not `'Data'`.

---

## Example 2: with `await`

```javascript
async function main() {
  const result = await getData(); // waited for it
  console.log(result);
}

main();
```

**Output:**

```javascript
Data
```

`await` "unwraps" the promise, returning its value.

---

## Example 3: forgot `await`, and the code moved on

```javascript
async function delay() {
  await new Promise(res => setTimeout(res, 2000));
  console.log('Done after 2 sec');
}

async function run() {
  delay(); // not waiting!
  console.log('Moving on');
}

run();
```

**Output:**

```javascript
Moving on
Done after 2 sec
```

Without `await`, execution doesn't pause,
the `delay()` function runs **in the background**, while the program continues.

---

## Example 4: missing `await` gives the wrong result

```javascript
async function fetchUser() {
  return { name: 'Alex' };
}

async function showUser() {
  const user = fetchUser(); // forgot await
  console.log('User name:', user.name);
}

showUser();
```

**Output:**

```javascript
User name: undefined
```

Because `user` is not an object, it's a **Promise**,
which has no `name` field.
That is, this is a logic error, not a syntax error.

---

## Example 5: when you deliberately don't use `await` (parallel tasks)

Sometimes **not using** `await` **is correct**, if you want operations to run in parallel:

```javascript
async function load() {
  const userPromise = fetch('/api/user');
  const postsPromise = fetch('/api/posts');

// wait for both in parallel
  const [user, posts] = await Promise.all([userPromise, postsPromise]);

console.log('Both responses received');
}
```

If you put `await` right after each `fetch`,
they would run **one after another**, not at the same time.

---

## Example 6: `await` on a return

```javascript
async function foo() {
  return await Promise.resolve('OK');
}
```

`await` here is **redundant**, you can just write:

```javascript
async function foo() {
  return Promise.resolve('OK');
}
```

Because an `async` function **wraps the result in a promise anyway**.

---

## Under the hood (what actually happens)

When you call an `async` function:

```javascript
const p = myAsyncFunction();
```

JavaScript **immediately** returns a `Promise` object,
while the code inside starts executing asynchronously.
If you don't use `await`, that promise simply stays "in the air",
and you never use the result of its execution.

---

## Common problems without `await`

| Mistake | What happens |
|---|---|
| Forgetting `await` when calling an async function | The variable ends up with a `Promise`, not the result |
| Returning without `await` inside another async function | May return an "unfinished" promise |
| Inconsistent data | The code moves on while the promise hasn't resolved yet |
| Errors aren't caught | `try...catch` won't catch a `reject` if you didn't `await` it |

---

## A simple analogy

> Imagine `await` is **"waiting for your order"**
>
> - With `await`: you stand at the counter, wait for the coffee, and get the cup.
> - Without `await`: you just place the order and walk away, the coffee gets made, but you never pick it up.

---

## SUMMARY

| Scenario | What happens |
|---|---|
| Didn't use `await` | The function returns a `Promise`, execution continues right away |
| Used `await` | Execution pauses until the promise settles |
| An error without `await` | `try...catch` won't catch it, the promise wasn't "awaited" |
| When to skip `await` | When launching parallel tasks (`Promise.all`) |

Markdown · drag & drop images · ⌘B / ⌘I shortcuts648 words

For the reviewer

Note to the moderator (optional)

Visible only to the moderator. Helps review go faster.