Async Method

An asynchronous method in TypeScript is a class or object member declared with the async modifier, which instructs the compiler to implicitly wrap the method’s return value in a Promise. It enables the use of the await keyword within the method’s lexical scope to pause execution until a given Promise settles, allowing asynchronous control flow to be written in a synchronous style.

Syntax and Type Signatures

In TypeScript, the return type of an async method must always be a Promise<T>, where T represents the type of the resolved value. If the method does not return a value, TypeScript’s type inference engine will automatically infer the return type as Promise<void>, though it may still be explicitly typed for strictness or readability.

class DataController {
    // Method returning a resolved value of type 'string'
    public async retrieveRecord(id: number): Promise<string> {
        // Using Promise.resolve to simulate an asynchronous operation
        const recordName = await Promise.resolve(`Record_${id}`);
        return recordName; 
    }

    // Method returning no value; TypeScript infers Promise<void>
    private async executeTask() {
        await this.retrieveRecord(1);
    }
}

Technical Mechanics

• Type Enforcement: TypeScript’s static analyzer enforces that an async method cannot declare a raw return type (e.g., string). Declaring public async getData(): string will result in a compiler error (TS1064: The return type of an async function or method must be the global Promise<T> type).
• Execution Context: When an async method is invoked, it executes synchronously until it encounters the first await expression. At that point, the method yields control back to the calling execution context. The remainder of the method is queued as a microtask to resume once the awaited Promise resolves or rejects.
• Error Propagation: Any exception thrown within the body of an async method—whether synchronous or resulting from a rejected await expression—is automatically caught and returned as a rejected Promise.

Interface Implementation

When defining a TypeScript interface or type alias for a class containing asynchronous methods, the async keyword is omitted. The async modifier is strictly an implementation detail, whereas the interface defines the structural contract (the Promise return type).

// Contract definition
interface IDataController {
    retrieveRecord(id: number): Promise<string>;
}

// Implementation
class PostgresController implements IDataController {
    // The async modifier is applied here, satisfying the Promise<string> contract
    public async retrieveRecord(id: number): Promise<string> {
        return "record_data";
    }
}

Object Literal Methods

The async modifier can also be applied to methods defined within object literals. The type inference and return type rules remain identical to class methods.

const service = {
    status: 'idle',
    
    async initialize(): Promise<boolean> {
        this.status = 'running';
        return true;
    }
};

Master TypeScript with Deep Grasping Methodology!

Learn More