Typescript - lägg till ett argument i en funktions parametrar

type SomeFunc = (a:string, b:number, c:someCustomType) => number;

Jag vill skapa en typ som är precis som den ovan, förutom att det finns en enda parameter tillagd i slutet. Låt oss säga, d:number;

type SomeFuncAltered = (a:string, b:number, c:someCustomType, d:number) => number;

Jag vill dock inte skapa hela typen manuellt, jag är ganska säker på att det finns ett smart trick med Parameters<func> som kan användas här.

Svar #1

Eftersom det accepterade svaret här inte verkar fungera för mig (med TS 4), skrev jag min egen typ som lägger till valfritt antal parametrar i slutet av en funktion.

type AddParameters<
  TFunction extends (...args: any) => any,
  TParameters extends [...args: any]
> = (
  ...args: [...Parameters<TFunction>, ...TParameters]
) => ReturnType<TFunction>;

Användning :

type SomeFunc = (a: string, b: number, c: someCustomType) => number;
type SomeFuncAltered = AddParameters<SomeFunc, [d: number]>;
// SomeFuncAltered = (a:string, b:number, c:someCustomType, d:number) => number;

Observera: Denna lösning låter dig också lägga till namngivna parametrar.

Svar #2

Det är möjligt men ganska sofistikerat. Mer information kan hittas i detta svar från @jcalz - Skjut typen till slutet av tuplen med att hoppa över valfri.

I ditt fall kan vi återanvända vissa verktyg från svaret ovan, exakt skulle det vara Cons och Push och genom att använda dem göra den slutliga typen du behöver AddArgument. Tänk på:

type SomeFunc = (a: string, b: number, c: string) => number;

// some utility types for working with tuples
type Cons<H, T extends readonly any[]> =
    ((head: H, ...tail: T) => void) extends ((...cons: infer R) => void) ? R : never;

type Push<T extends readonly any[], V>
    = T extends any ? Cons<void, T> extends infer U ?
    { [K in keyof U]: K extends keyof T ? T[K] : V } : never : never;

// final type you need
type AddArgument<F, Arg> = 
F extends ((...args: infer PrevArgs) => infer R) 
? (...args: Push<PrevArgs, Arg>) => R : never

// function type with added boolean argument at the end
type NewFunction = AddArgument<SomeFunc, boolean>

Relaterade artiklar