Skip to main content

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.

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 
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.
// 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. 
async function backgroundTask(): Promise<void> {
    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. 
// '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();
Master TypeScript with Deep Grasping Methodology!Learn More