ThisParameterType and OmitThisParameter in Typescript

Introduction

These utility types help you work with the special this parameter in functions. They let you get or remove the type of this to make your code safer and clearer.

When you want to find out the type of <code>this</code> inside a function type.

When you want to create a new function type without the <code>this</code> parameter.

When you want to call a method but control or remove the <code>this</code> context explicitly.

Syntax

Typescript

type ThisParameterType<T> = T extends (this: infer U, ...args: any[]) => any ? U : unknown;
type OmitThisParameter<T> = T extends (this: any, ...args: infer A) => infer R ? (...args: A) => R : T; // built-in utility type

ThisParameterType extracts the type of this from a function type.

OmitThisParameter creates a new function type without the this parameter.

Examples

Extracts the type of this from the greet function.

Typescript

function greet(this: {name: string}, greeting: string) {
  return `${greeting}, ${this.name}`;
}
type ThisType = ThisParameterType<typeof greet>;
// ThisType is { name: string }

Creates a new function type without the this parameter.

Typescript

type NoThisGreet = OmitThisParameter<typeof greet>;
const greetNoThis: NoThisGreet = (greeting) => `Hello, ${greeting}`;
// greetNoThis does not expect a <code>this</code> parameter

Removes this and binds a new context.

Typescript

const obj = { name: 'Alice', greet };
const greetFn = obj.greet;

// Using OmitThisParameter to call greet without <code>this</code>
const greetWithoutThis: OmitThisParameter<typeof greet> = greetFn.bind({ name: 'Bob' });
console.log(greetWithoutThis('Hi'));

Sample Program

This program shows how to get the this type and create a version of the function without this. It calls the original with this and the new one without.

Typescript

function showAge(this: { age: number }, prefix: string) {
  return `${prefix} ${this.age}`;
}

// Extract the type of this
type AgeThis = ThisParameterType<typeof showAge>;

// Create a function type without this
const showAgeNoThis: OmitThisParameter<typeof showAge> = (prefix) => {
  // We can't use this here, so just return a fixed string
  return `${prefix} unknown`;
};

const person = { age: 30, showAge };

console.log(showAge.call(person, 'Age:'));
console.log(showAgeNoThis('Age:'));

Important Notes

ThisParameterType only works on function types that explicitly declare this.

OmitThisParameter is useful to convert methods into normal functions.

These utilities help avoid errors when this is used incorrectly.

Summary

ThisParameterType extracts the this type from a function.

OmitThisParameter removes the this parameter from a function type.

They help manage this safely in TypeScript functions.