Use async and await judiciously

Async functions are a powerful feature in JavaScript and TypeScript, offering a cleaner, more readable alternative to working directly with Promises. However, it’s easy to overuse them or add unnecessary layers of complexity.  By understanding when and how to use async and await effectively, you can write more concise, efficient, and maintainable code.

Let’s explore a common scenario where async and await may be overapplied, and how simplifying the function structure can improve code readability and maintainability without sacrificing intent. Take a look at this function which wraps an async function which deletes an entity form a database:

const deleteEntity = async (id: number) => {
    return await db.entity.delete({ id });
}

You would also await deleteEntity when calling it, resulting in two promises, unnecessarily verbose code and less efficient execution.. Instead of awaiting the promise created in deleteEntity, it can just be returned:

const deleteEntity = async (id: number) => {
    return db.entity.delete({ id });
}

Although async functions can contain zero or more awaits, it doesn’t really make much sense having async if you have zero awaits and it certainly isn’t necessary:

const deleteEntity = (id: number) => {
    return db.entity.delete({ id });
}

async can be a useful indicator that a function should be awaited, all async functions return a promise. However, I prefer to indicate this by specifying the return type:

const deleteEntity = (id: number) : Promise<void> => {
    return db.entity.delete({ id });
}

It may come down to style, but at this point the deleteEntity function body isn’t required either:

const deleteEntity = (id: number) : Promise<void> => db.entity.delete({ id });

This way you can have much simpler code, which can be considered easier to maintain while maintaining the intent and identical functionality.

Async functions are a valuable tool for simplifying asynchronous code in JavaScript and TypeScript, but using them unnecessarily can lead to bloated and inefficient code. A common pitfall is wrapping Promises in extra layers of async and await, resulting in redundant code without added benefit. By simply returning the Promise or specifying the return type, functions can be made more concise and readable without losing clarity or intent. Ultimately, understanding the behavior of async and await allows for better code decisions and improved maintainability.

Read more here.