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

Angular 5 is throwing an error stating that it cannot read the property 'text' of undefined

Issue TS2322: The type 'Observable<any>' cannot be matched with type 'NgIterable<any> | null | undefined'

Error 404 when implementing routing in Angular 2 with Auth0

Setting Angular FormControl value to null within a service

The Nestjs ClientMqtt now has the capability to publish both pattern and data to the broker, as opposed to just sending

How can I subtract a value from my array in Angular?

Exploring nested JSON objects within an array using ngFor directive

What is the reason behind VS Code not showing an error when executing the command line tsc shows an error message?

What is the proper way to include type annotation in a destructured object literal when using the rest operator?

What is the best way to display API error messages to the user?

The initial Get request does not receive data upon first attempt

Is there a way to remove an event listener once the associated button has been clicked within the given code?

The absence of a semicolon following the interface declaration is the issue

When employing the pipe function within *ngFor, the webpage's refresh may vary, causing occasional updates

Building state from multiple child components in Next.js/React: Best Practices

Using Angular, a function can be called recursively directly from within the HTML

Tips on preventing image previews from consuming too much text data while updating a database in Angular 12 using Material UI for image uploads within a FormGroup object

Issue with rest operator behavior in TypeScript when targeting es2018

TypeORM - Establishing dual Foreign Keys within a single table that point to the identical Primary Key

Issues arising from an aging Angular project