TypeScript Generic Parameter Defaults

Last Updated : 22 Jul, 2024

TypeScript Generic Parameter Defaults allow you to specify default values for generic type parameters. This feature provides a fallback type when no explicit type argument is given, making generic types more flexible and easier to use, particularly when type inference is not straightforward.

Syntax

function myFunction<T = DefaultType>(param: T): void {
// Function implementation
}

Where:

T: This is the generic type parameter that can take any type.
DefaultType: This is the default type that will be used for T if no type argument is provided during function or class instantiation.

A generic parameter default follows the following rules:

When we provide a default parameter in the function, then it becomes optional for us to provide the type of the object
Optional type parameters must not be followed by Required type parameters.
All the constraints must be followed for the type parameter while creating default types for a type parameter.
You are only required to specify type arguments for the type parameters that are required others will be resolved to default.
The default type is inferred when a default type is specified and inference cannot choose a candidate.
If a class or interface has a default value type and it merges with another class or interface then that also has the same default type, Also, it can introduce a new parameter type as long as it specifies a default.

Example 1: Specifying Default Type for a Generic Function

In this example, we specify the default type for a generic parameter when declaring a generic function. If you don't provide a type argument when calling the generic function, TypeScript will use the default type as the inferred type.

JavaScript

function identity<T = string>(value: T): T {
  return value;
}

let result1 = identity(42); // Uses the default type 'string'
let result2 = identity<number>(42); // Uses the explicitly provided type 'number'

console.log(result1); // Output: "42"
console.log(result2); // Output: 42

Output:

42
42

Example 2: Checking for Value and Returning Default

In this example, we check whether a value is given at the time of function invocation. If a value is not provided, the function returns a default value.

JavaScript

function getValue<T = number>(value?: T): T {
  return value !== undefined ? value : (0 as T);
}

let value1 = getValue(100); // Uses the provided value
let value2 = getValue();    // Uses the default value

console.log(value1); // Output: 100
console.log(value2); // Output: 0

Output:

100
0

In this article, we explored TypeScript Generic Parameter Defaults, their syntax, and the rules to follow when using them. This feature allows for optional type parameters with default values, improving code flexibility and readability. By using default types, you can ensure more robust and maintainable TypeScript code, facilitating easier type inference and better code formatting.