> ## 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 Void The `void` operator is a unary JavaScript operator, fully supported in TypeScript, that evaluates its operand expression and explicitly returns the primitive value `undefined`. In the TypeScript type system, applying the `void` operator to any expression forces the resulting type to be `undefined`, effectively discarding the operand's original return type during static analysis. **Syntax** ```typescript theme={"dark"} void expression // or void (expression) ``` **Type System and Runtime Behavior** * **Evaluation:** The operand is fully evaluated at runtime. Any side effects within the expression will execute, but the resulting value is discarded. * **Return Type:** Regardless of the operand's inferred or explicit type, TypeScript types the output of the `void` operator strictly as `undefined`. * **Type Resolution:** It acts as a boundary that prevents the propagation of a return type. At runtime, the expression evaluates to the primitive value `undefined`; at compile time, TypeScript resolves and infers the resulting type strictly as the type `undefined`, discarding the operand's original type `T`. ```typescript theme={"dark"} // Operand is a number; operator evaluates to and is typed as undefined const numericVoid: undefined = void 42; function compute(): string { return "computed string"; } // The 'string' return type is discarded. // TypeScript infers 'result' strictly as 'undefined'. const result = void compute(); ``` **Compiler Emission and `void 0`** The expression `void 0` is historically significant as the standard, safe way to produce the `undefined` value. Because `undefined` is an identifier and not a reserved keyword in JavaScript, it can be locally shadowed by variable declarations in **both** strict and non-strict environments (e.g., `function foo() { "use strict"; let undefined = 1; }` is valid). It is only the global reassignment of `undefined` (e.g., `window.undefined = 1`) that throws an error in strict mode. Evaluating `void 0` guarantees the retrieval of the true `undefined` value regardless of local shadowing. Due to this safety guarantee, the TypeScript compiler frequently emits `void 0` in its compiled JavaScript output. This is especially prominent when the compiler downlevels modern syntax, such as optional chaining (`?.`) or nullish coalescing (`??`), where it must safely inject `undefined` into the generated control flow. **Interaction with Promises and Linters** When applied to an asynchronous function call, the `void` operator discards the returned `Promise` object. The TypeScript compiler does not possess built-in checks for unawaited (floating) promises; this validation is handled exclusively by third-party static analysis tools (such as the `@typescript-eslint/no-floating-promises` linting rule). Prefixing a promise with `void` suppresses this specific linting error by explicitly casting the return value away from a `Promise` type. Crucially, the `void` operator does not alter the runtime behavior of the promise. It does **not** catch or suppress promise rejections. If a promise marked with `void` rejects, the unhandled rejection will still bubble up and can crash the application environment (e.g., Node.js). The operator only suppresses the static linting error, not the actual runtime rejection. ```typescript theme={"dark"} async function backgroundTask(): Promise { throw new Error("Runtime crash"); } // Suppresses the static linter error for floating promises, // but WILL still cause an unhandled promise rejection at runtime. void backgroundTask(); ``` **Operator vs. Type** In TypeScript, `void` exists in two distinct namespaces and behaves differently depending on the context: 1. **Value Space (The Operator):** A runtime mechanism that evaluates an expression and returns the value `undefined`. 2. **Type Space (The Type):** A compile-time type annotation (e.g., `function foo(): void`) indicating that a function's return value should be ignored by the caller. When the `void` operator is used in value space, TypeScript maps its resulting value to the `undefined` type, not the `void` type. ```typescript theme={"dark"} // 'void' as a Type (Type Space) function logMessage(): void { console.log("Hello"); } // 'void' as an Operator (Value Space) // The type of 'x' is 'undefined', not 'void' const x: undefined = void logMessage(); ```

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