ThisParameterType în TypeScript

type ThisParameterType<T> = T extends (this: infer U, ...args: never) => any ? U : unknown;
type OmitThisParameter<T> = /* T fără parametrul this */;

Ce face ThisParameterType

O funcție poate declara pe ce obiect trebuie apelată cu un parametru this fals (vezi this în funcții). ThisParameterType<typeof f> dă tipul acestui parametru. Dacă funcția nu are parametru this, rezultatul este unknown.

OmitThisParameter<typeof f> dă tipul funcției fără parametrul this. Este exact tipul rezultatului lui f.bind(obiect): după legare, this este fixat și funcția poate fi apelată singură. Dacă funcția nu are this, tipul rămâne neschimbat.

Sunt folosite mai ales în cod generic care leagă metode de obiecte sau care verifică obiectul pe care se apelează o funcție.

Parametri

Parametru	Descriere
T	Un tip de funcție, de obicei typeof f.

Ce returnează

ThisParameterType: tipul lui this (sau unknown). OmitThisParameter: tipul funcției fără this.

Exemple

Exemplul 1: Legarea unei funcții de un obiect

interface Elev {
    nume: string;
    note: number[];
}

function medie(this: Elev, zecimale: number): string {
    const m = this.note.reduce((s, n) => s + n, 0) / this.note.length;
    return `${this.nume}: ${m.toFixed(zecimale)}`;
}

type Tinta = ThisParameterType<typeof medie>;           // Elev
type Legata = OmitThisParameter<typeof medie>;          // (zecimale: number) => string

function leaga(obiect: Tinta): Legata {
    return medie.bind(obiect);
}

const f = leaga({ nume: "Ana", note: [9, 10, 10] });
console.log(f(2), "|", f(0));

Rezultat

Ana: 9.67 | Ana: 10

Exemplul 2: Funcție fără this

Pentru o funcție fără parametru this, ThisParameterType dă unknown, iar OmitThisParameter lasă tipul neschimbat.

function dublu(x: number): number {
    return x * 2;
}
type T = ThisParameterType<typeof dublu>;       // unknown
type F = OmitThisParameter<typeof dublu>;       // (x: number) => number

const oriceValoare: T = "orice";
const g: F = dublu;
console.log(oriceValoare, g(21));

Rezultat

orice 42

Exemplul 3: Funcția legată se apelează singură, cea originală nu

interface Elev {
    nume: string;
}
function salut(this: Elev) {
    return `Salut, ${this.nume}`;
}
const legata: OmitThisParameter<typeof salut> = salut.bind({ nume: "Ana" });
console.log(legata());
console.log(salut());

Eroarea afișată de tsc

exemplu.mts(9,13): error TS2684: The 'this' context of type 'void' is not assignable to method's 'this' of type 'Elev'.

Greșeli frecvente

• Te aștepți ca OmitThisParameter să lege funcția. Doar schimbă tipul; legarea se face cu bind.

Comenzi înrudite

• this în funcții: Primul parametru numit this declară pe ce obiect trebuie apelată funcția; tsc verifică apelurile.
• Parameters: Parameters<F> dă tipurile parametrilor unei funcții, ca tuple; Parameters<F>[0] este primul parametru.
• ReturnType: ReturnType<F> dă tipul rezultatului unei funcții; pentru o funcție concretă scrii ReturnType<typeof f>.
• arrow functions cu tipuri: Funcțiile săgeată primesc tipuri ca orice funcție; în callback-uri, tipul parametrilor se deduce din context.