Is your async function lacking a return statement?

Question

Is your async function lacking a return statement?

After completing the development of a new method for a bug I encountered, I noticed something interesting. Despite the fact that there is a potential scenario where the function may not return anything, the compiler did not flag any errors. It got me thinking - why does the compiler stay silent in this case, but raises an issue when using if (false)?

I'm particularly curious about what happens if the condition

if (data && data.json().length)

evaluates to false. Does the function still return a value under such circumstances?

private async getData(items: any[]): Promise<number> {
    for(const item of items) {
        let data = await item.promise;
        if (data && data.json().length) {
            return data.json().findIndex(d => d.fqdn);
        }
    }
}

Your insights would be greatly appreciated.

typescript async-await

Answer 1

Answer №1

The TypeScript spec Section 6.3 provides insight into this topic (emphasis added):

An explicitly typed function with a return type that isn't Void, Any, or a union type containing Void or Any must have at least one reachable return statement in its body. An exception is made if the function consists of only a 'throw' statement.

Your function meets this requirement by having a reachable return statement. Placing the return inside an if (false) clause makes it unreachable and doesn't count towards this rule.

If the function exits without a clear return, it implicitly returns a promise for undefined, which is acceptable for Promise<number> when strictNullChecks is off.

This is separate from using async. The following scenarios will compile without errors:

function getData(): number { 
    if (1 + 1 === 3) {
        return 7;
    }
}

As well as:

function getData(): number { 
    if (1 + 1 === 3) {
        return undefined;
    }
}

What occurs if if (data && data.json().length) is false? Does the function return anything?

In such cases, the function returns a promise resolving to undefined since it's flagged as async, leading to promises being returned instead.

Note that when strictNullChecks is enabled, both your function and those mentioned may throw compiler errors due to the invalid use of undefined with number.

Answer 2

The TypeScript spec Section 6.3 provides insight into this topic (emphasis added):

An explicitly typed function with a return type that isn't Void, Any, or a union type containing Void or Any must have at least one reachable return statement in its body. An exception is made if the function consists of only a 'throw' statement.

Your function meets this requirement by having a reachable return statement. Placing the return inside an if (false) clause makes it unreachable and doesn't count towards this rule.

If the function exits without a clear return, it implicitly returns a promise for undefined, which is acceptable for Promise<number> when strictNullChecks is off.

This is separate from using async. The following scenarios will compile without errors:

function getData(): number { 
    if (1 + 1 === 3) {
        return 7;
    }
}

As well as:

function getData(): number { 
    if (1 + 1 === 3) {
        return undefined;
    }
}

What occurs if if (data && data.json().length) is false? Does the function return anything?

In such cases, the function returns a promise resolving to undefined since it's flagged as async, leading to promises being returned instead.

Note that when strictNullChecks is enabled, both your function and those mentioned may throw compiler errors due to the invalid use of undefined with number.

Answer 3

Answer №2

Asynchronous functions always result in a promise being returned. If the TypeScript compiler encounters an if (false) statement, it will raise an error because the following return statement is unreachable. In such cases, the function will return a promise containing undefined. A similar issue arises if

data && data.json().length

evaluates to false, but the compiler does not catch this problem.

If a function lacks a default value to return, there is no need for an explicit return statement at the end of the function. However, the function should be appropriately typed:

private async fetchData(results: any[]): Promise<number|void> {
    for(const result of results) {
        let data = await result.promise;
        if (data && data.json().length) {
            return data.json().findIndex(d => d.fqdn);
        }
    }
}

Answer 4

Asynchronous functions always result in a promise being returned. If the TypeScript compiler encounters an if (false) statement, it will raise an error because the following return statement is unreachable. In such cases, the function will return a promise containing undefined. A similar issue arises if

data && data.json().length

evaluates to false, but the compiler does not catch this problem.

If a function lacks a default value to return, there is no need for an explicit return statement at the end of the function. However, the function should be appropriately typed:

private async fetchData(results: any[]): Promise<number|void> {
    for(const result of results) {
        let data = await result.promise;
        if (data && data.json().length) {
            return data.json().findIndex(d => d.fqdn);
        }
    }
}

Answer 5

Answer №3

Every time the function is called, it will consistently output a Promise. If the function happens to return implicitly, the Promise will resolve to undefined.

If you have strictNullChecks turned on, this situation should trigger a compiler error.

To observe this, check out the TypeScript playground (and experiment with enabling/disabling strictNullChecks):

async function a(i: boolean): Promise<number> {
    if (i) return 5;
}

If you remove the async keyword and change the return type to number, you'll notice that the behavior remains the same.

Answer 6

Every time the function is called, it will consistently output a Promise. If the function happens to return implicitly, the Promise will resolve to undefined.

If you have strictNullChecks turned on, this situation should trigger a compiler error.

To observe this, check out the TypeScript playground (and experiment with enabling/disabling strictNullChecks):

async function a(i: boolean): Promise<number> {
    if (i) return 5;
}

If you remove the async keyword and change the return type to number, you'll notice that the behavior remains the same.

Is your async function lacking a return statement?

Answer №1

Answer №2

Answer №3

Similar questions

Crafting Functions That Can Be Typed from Factory Function

Enigmatic Cartography Classification

Simple method for adapting async/await function to function smoothly with observables

The guard check may not be enough to prevent the object from being null

Encountering ng build --prod errors following Angular2 to Angular4 upgrade

Kendo checkbox toggle issue with switching between true and false states is not functioning correctly

Can TypeScript Implement a Dictionary Feature Similar to C#?

The Firebase EmailPasswordAuthProvider is not a valid type on the Auth object

Error: In Angular Firebase, the type 'string' cannot be assigned to the type 'Date'

Validation of object with incorrect child fields using Typeguard

What is the best way to implement an onClick event listener in a TypeScript React application?

Using Vue js and Typescript to automatically scroll to the bottom of a div whenever there are changes in

Leveraging the power of react-hook-form in combination with the latest version 6 of @mui

How can a child component trigger an event in its parent component?

How can you limit a type reference to a specific file in TypeScript?

The placement of the FirebaseAuth.onAuthStateChanged call in an Angular application is a common concern for developers

Passing asynchronous data from method1 to method2 without impacting the functionality of the script responsible for fetching the asynchronous data in method1

Unexpected issue encountered during the Angular 9 compilation process

I wonder what the response would be to this particular inquiry

Issue with Angular2: The [routerLinkActive] directive does not update when using _router.navigate