How to get argument types from function in Typescript [duplicate]

Question

I may have missed something in the docs, but I can't find any way in typescript to get the types of the parameters in a function. That is, I've got a function

function test(a: string, b: number) {
    console.log(a);
    console.log(b)
}

I want access to the types string and number, likely as a tuple.

I know I can get the type of the function itself, as typeof test, or the return type via ReturnType<test>.

When I tried keyof typeof test, it returned never, which I also couldn't explain.

Other answers like this one point to extends, but I don't really understand how that works and don't give me an easy way to access the set-of-all-params as a type.

Arrangement

I am afraid that I do not quite understand: Do you want to get string from a and number from b? – Karolinekaroly

I want to get [string, number] or similar (a tuple, perhaps) from applying some sort of operation to the function test – Arrangement

Answer 1

Typescript now comes with a predefined Parameters<F> type alias in the standard library which is almost the same as ArgumentTypes<> below, so you can just use that instead of creating your own type alias.

type TestParams = Parameters<(a: string, b: number) => void> // [string, number]

Then to get for example the second parameter's type you can use the numeric indexing operator:

type SecondParam = TestParams[1] // number

Original answer:

---

Yes, now that TypeScript 3.0 has introduced tuples in rest/spread positions, you can create a conditional type to do this:

type ArgumentTypes<F extends Function> = F extends (...args: infer A) => any ? A : never;

Let's see if it works:

type TestArguments = ArgumentTypes<typeof test>; // [string, number]

Looks good. Note that these beefed-up tuples also capture things like optional parameters and rest parameters:

declare function optionalParams(a: string, b?: number, c?: boolean): void;
type OptionalParamsArgs = ArgumentTypes<typeof optionalParams>; 
// [string, (number | undefined)?, (boolean | undefined)?]

declare function restParams(a: string, b: number, ...c: boolean[]): void;
type RestParamsArgs = ArgumentTypes<typeof restParams>;
// [string, number, ...boolean[]]

Forestall

Thanks, @jcalz. It appears this functionality is now available in TypeScript itself as Parameters. – Tartan

what does infer keyword mean? – Fractionize

See Type inference in conditional types – Forestall

is it possible to use parameter types of a function to define parameter types of another function when parameters are unknown (...args: any[])? – Succentor

nevermind, found it. for anyone wondering, you can do like: (...args: Parameters<typeof anotherFunction>) => .... – Succentor

@ErfanAzary that didn't work for me. I did this ts (...[args]: Parameters<typeof anotherFunction>) => .... – Mattah

@Mattah you have extra brackets around args – Succentor

@ErfanAzary that's on purpose – Mattah

@Mattah so what's not working for you exactly? by using ...[args], type of args will be type of first argument of anotherFunction which doesn't seem to be the purpose of naming it args, if you want args to be list (array) of all arguments, then it should be like ...args. Please explain a little more specific when you say not working to see whats the problem – Succentor

What if the function is inside a variable and refers to a method inside an object? – Security

I can't really answer followup questions in comments on answers to old questions, especially not without a minimal reproducible example of the issue. If you can't find an existing answer you might want to post a new question (and then you'll get more eyes on it than just people who follow comments on old questions). – Forestall