> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # TypeScript Return Statement The `return` statement is a control flow construct that terminates the execution of a function and passes an evaluated expression back to the caller. In TypeScript, the `return` statement is bound to the function's type signature, enforcing strict static type checking between the evaluated expression and the expected return type. ## Syntax ```typescript theme={"dark"} return expression; ``` * **`expression`** (Optional): The value to be returned. If omitted, the function implicitly returns `undefined` at runtime. ## Static Type Enforcement TypeScript evaluates `return` statements using either explicit type annotations or type inference. The rules for assignability depend on the function's execution model. ### Synchronous Functions When a synchronous function signature includes an explicit return type `T`, the compiler verifies that the expression in every `return` statement is assignable to `T`. ```typescript theme={"dark"} function getCount(): number { return 42; // Valid: 42 is assignable to number } function getString(): string { return 42; // TS2322: Type 'number' is not assignable to type 'string'. } ``` ### Asynchronous Functions In an `async` function with a declared return type of `Promise`, the evaluated `return` expression must be assignable to `T` or `Promise`. The compiler does not require the expression to be a `Promise` itself, as the runtime automatically wraps the returned value. ```typescript theme={"dark"} async function fetchId(): Promise { return 42; // Valid: 42 is assignable to T (number) } async function fetchIdAsync(): Promise { return Promise.resolve(42); // Valid: assignable to Promise } ``` ### Generator Functions In a generator function (`function*`) with a declared return type of `Generator`, the expression in the `return` statement must be assignable to the `TReturn` type parameter. ```typescript theme={"dark"} function* processItems(): Generator { yield 1; yield 2; return "Complete"; // Valid: "Complete" is assignable to TReturn (string) } ``` ### Type Inference If no explicit return type is provided, TypeScript infers the function's return type by analyzing the types of the expressions in all `return` statements within the function body. If multiple `return` statements exist, the inferred type becomes a union of all returned types. ```typescript theme={"dark"} function evaluate(flag: boolean) { if (flag) { return "Success"; // Infers string } return 0; // Infers number } // The compiler infers the return type as: string | number ``` ## Special Return Types and Contextual Typing TypeScript utilizes specific types and contextual rules to handle the absence, impossibility, or ignoring of a `return` statement. ### The `void` Type The `void` type indicates that a function does not return a usable value. A function explicitly returning `void` can omit the `return` statement, use an empty `return;`, explicitly `return undefined;`, or return an expression that evaluates to `void`. ```typescript theme={"dark"} function terminateProcess(): void { return; // Valid: Empty return statement } function clearData(): void { return undefined; // Valid: undefined is assignable to void } function logProcess(): void { return console.log("Done"); // Valid: console.log() evaluates to void } ``` ### Contextual Typing with `void` When a function expression is contextually typed with a `void` return type, TypeScript's assignability rules permit its `return` statements to evaluate to *any* type. The compiler allows the return of a value without raising an error, but enforces that the caller cannot use the returned value. ```typescript theme={"dark"} type Callback = () => void; const myCallback: Callback = () => { return true; // Valid: Contextually typed as void, the boolean return is permitted but ignored }; ``` ### The `never` Type The `never` type indicates that a function will never successfully execute a `return` statement to completion. This applies to functions that unconditionally throw exceptions or contain infinite loops. ```typescript theme={"dark"} function throwError(): never { throw new Error("Fatal exception"); // A return statement here is unreachable and violates the 'never' type } ``` ## Control Flow Analysis TypeScript performs strict control flow analysis to ensure that all code paths in a function with a declared, non-`void` return type culminate in a valid `return` statement. ```typescript theme={"dark"} function checkValue(val: number): boolean { if (val > 0) { return true; } // TS2366: Function lacks ending return statement and return type does not include 'undefined'. } ``` If the `strictNullChecks` compiler option is enabled, failing to return a value on all branches results in a compilation error unless the return type explicitly includes `undefined`.

Tired of Poor TypeScript Skills? Fix That With Deep Grasping! Learn More