> ## 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
`void` is a special type in TypeScript representing the absence of a specific type or value. It is the conceptual opposite of `any` and is primarily utilized as the return type for functions that terminate normally but do not explicitly return a value to the caller.
```typescript theme={"dark"}
function executeProcess(): void {
console.log("Processing...");
// Implicitly returns undefined
}
```
## Type Compatibility and Assignment
Variables can be explicitly typed as `void`, though this is uncommon. From a type-checking perspective, a `void` type is only compatible with `undefined`. If the compiler flag `strictNullChecks` is disabled, `void` is also compatible with `null`.
```typescript theme={"dark"}
let uninitialized: void;
uninitialized = undefined; // Valid
uninitialized = null; // Valid ONLY if strictNullChecks is false
uninitialized = "string"; // Error: Type 'string' is not assignable to type 'void'
```
## Contextual Typing Behavior
TypeScript enforces different strictness levels for `void` depending on whether it is used in a literal function declaration or as a contextual type signature.
**1. Literal Function Declarations**
When a function is explicitly declared to return `void`, the TypeScript compiler strictly enforces that the function must not return a value.
```typescript theme={"dark"}
function strictVoid(): void {
return true; // Error: Type 'boolean' is not assignable to type 'void'.
}
```
**2. Contextual Function Types**
When `void` is used in a function type alias or interface, it alters its behavior. A contextual type of `() => void` does not mean the function *cannot* return a value; rather, it indicates that the caller must *ignore* any returned value.
```typescript theme={"dark"}
type VoidCallback = () => void;
// Valid: The implementation returns a number, but the type signature
// guarantees the caller will treat the result as void.
const pushToArray: VoidCallback = () => [1, 2, 3].push(4);
const result = pushToArray();
// 'result' is strictly typed as 'void'.
```
When a variable is typed as `void` (like `result` above), TypeScript restricts operations that depend on the value having a specific type or being tested for truthiness. However, it does not strictly forbid all usage in expressions. A `void` variable can still be passed to functions accepting `any` or `unknown`, evaluated in a `typeof` expression, or assigned to another variable.
## `void` vs. `never`
While both types represent non-values, their control flow implications differ fundamentally:
* **`void`**: The function executes completely and returns control to the caller, either by reaching the end of its block implicitly or by executing an explicit early `return` without a value.
* **`never`**: The function is interrupted and never successfully returns control to the caller (e.g., it throws an exception or enters an infinite loop).
```typescript theme={"dark"}
function returnsVoid(): void {
return; // Control flow returns here explicitly without a value
}
function returnsNever(): never {
throw new Error("Halt"); // Control flow terminates here
}
```
Tired of Poor TypeScript Skills? Fix That With Deep Grasping!
Learn More
