Parameters în TypeScript

type Parameters<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never;

Ce face Parameters

Parameters<typeof f> dă un tuple cu tipurile parametrilor funcției, în ordine, cu tot cu numele și opționalitatea lor. Parameters<typeof f>[0] este tipul primului parametru.

Este util când scrii o funcție care „îmbracă” alta (logare, cache, reîncercări): cu (...args: Parameters<typeof f>) noua funcție are exact aceiași parametri. Este util și când o bibliotecă nu exportă tipul unui parametru: îl iei direct din funcție.

Pentru constructorii claselor există ConstructorParameters. Rezultatul funcției se ia cu ReturnType.

Parametri

Parametru	Descriere
T	Un tip de funcție.

Ce returnează

Un tuple cu tipurile parametrilor.

Exemple

Exemplul 1: Funcție care îmbracă alta

cuLog acceptă orice funcție și returnează una cu aceiași parametri și același rezultat.

function cuLog<F extends (...args: never[]) => unknown>(nume: string, f: F) {
    return (...args: Parameters<F>): ReturnType<F> => {
        const r = f(...args) as ReturnType<F>;
        console.log(`${nume}(${args.join(", ")}) -> ${r}`);
        return r;
    };
}

function pret(cantitate: number, pretUnitar: number, reducere = 0): number {
    return cantitate * pretUnitar * (1 - reducere);
}

const pretLog = cuLog("pret", pret);
pretLog(3, 12.5);
pretLog(2, 100, 0.1);

Rezultat

pret(3, 12.5) -> 37.5
pret(2, 100, 0.1) -> 180

Exemplul 2: Tipul unui parametru luat din funcție

function inscrie(elev: { nume: string; clasa: string }, optiuni?: { bursa: boolean }) {
    return `${elev.nume} (${elev.clasa})${optiuni?.bursa ? ", bursier" : ""}`;
}

type DateElev = Parameters<typeof inscrie>[0];       // { nume: string; clasa: string }
type Toti = Parameters<typeof inscrie>;              // [elev: {...}, optiuni?: {...}]

const d: DateElev = { nume: "Ana", clasa: "a X-a" };
const args: Toti = [d, { bursa: true }];
console.log(inscrie(...args));

Rezultat

Ana (a X-a), bursier

Exemplul 3: Argument de tip greșit pentru funcția îmbrăcată

function pret(cantitate: number, pretUnitar: number) {
    return cantitate * pretUnitar;
}
const args: Parameters<typeof pret> = [2, "12"];
console.log(pret(...args));

Eroarea afișată de tsc

exemplu.mts(4,43): error TS2322: Type 'string' is not assignable to type 'number'.

Greșeli frecvente

• Folosești Parameters pe o funcție cu overload-uri și te aștepți la toate variantele. Primești doar parametrii ultimei semnături.

Comenzi înrudite

• ReturnType: ReturnType<F> dă tipul rezultatului unei funcții; pentru o funcție concretă scrii ReturnType<typeof f>.
• ConstructorParameters: ConstructorParameters<typeof Clasa> dă tipurile parametrilor constructorului clasei, ca tuple.
• rest parameters: Strâng oricâte argumente într-un tablou: …valori: number[] acceptă f(1), f(1, 2, 3) sau f().
• tuple: Un tablou cu număr fix de elemente, în care fiecare poziție are tipul ei, de exemplu [nume, notă].
• infer: În ramura extends a unui tip condițional, infer X „prinde” o parte din tip și o dă un nume.