Utility Types - Parameters

Basic Parameters

Parameters<T> returns a tuple type containing the types of a function type T's parameters, in the same order they appear in the function's own signature.

It's one of the most common utility types for building wrapper or higher-order functions that mirror an existing signature.

Example: Basic Parameters

function createUser(name: string, age: number) {
  return { name, age };
}
type CreateUserArgs = Parameters<typeof createUser>;
const args: CreateUserArgs = ["Ravi", 25];
console.log(createUser(...args));

Parameters with Arrow Functions

Parameters works with arrow functions in the same way it works with regular function declarations, since both produce the same kind of function type under the hood.

Example: Parameters with Arrow Functions

const add = (a: number, b: number) => a + b;
type AddArgs = Parameters<typeof add>;
const args: AddArgs = [2, 3];
console.log(add(...args));

Parameters with Optional Arguments

Parameters preserves optional parameters in the resulting tuple, marking the corresponding tuple positions as optional just as they were in the original function signature.

Example: Parameters with Optional Arguments

function greet(name: string, greeting?: string) {
  return `${greeting ?? "Hello"}, ${name}`;
}
type GreetArgs = Parameters<typeof greet>;
const args: GreetArgs = ["Ravi"];
console.log(greet(...args));

Parameters with Rest Arguments

Parameters can extract rest parameters as part of the resulting tuple or array structure, reflecting a variadic function's actual calling convention, including any trailing array-typed rest argument.

Example: Parameters with Rest Arguments

function sum(first: number, ...rest: number[]) {
  return first + rest.reduce((a, b) => a + b, 0);
}
type SumArgs = Parameters<typeof sum>;
const args: SumArgs = [1, 2, 3];
console.log(sum(...args));

When to Use Parameters

Use Parameters when a type needs to stay synchronized with an existing function's argument list, such as building a wrapper or mock that must always match the original function's signature.

Example: When to Use Parameters

function original(a: number, b: string) {
  return `${a}-${b}`;
}
function wrapper(...args: Parameters<typeof original>) {
  console.log("Calling with", args);
  return original(...args);
}
console.log(wrapper(1, "x"));