Typescript function 基于参数属性的返回类型

Question

How can I create the proper typing for a function such that depending on the properties on its input parameters, I get the correct return type when calling this function?

Here's what I've got at the moment but both calls are giving me the same boolean | boolean[] boolean | boolean[] type when fn({ a: 42 }) should give me boolean and fn({ b: 'hi' }) should give me boolean[] .

type ParamType = { a?: number, b?: string }
type ReturnType<T> =
    T extends 'a' ? boolean :
    T extends 'b' ? boolean[] :
    never[]

function fn<T extends keyof ParamType>(arg: ParamType) {
    if (arg.a) {
        return true as ReturnType<T>;
    }
    else if (arg.b) {
        return [true, false] as ReturnType<T>;
    }
    else return [] as ReturnType<T>;
}

fn({ a: 42 });      //  function fn<"a" | "b">(arg: ParamType ): boolean | boolean[]
fn({ b: 'hi' });    //  function fn<"a" | "b">(arg: ParamType ): boolean | boolean[]

Also I'm not a huge fan of having to define the literal object properties a & b twice in the types, if there is a better way to do this please point me in the right direction.

Answer 1

Your problem is quite unusual but firstly: use in operator to check key existence. Secondly: this has no effect if both a and b are declared, even if optional. Use union. And finally, if you declare type parameter which is not assigned to a parameter, in most cases, it has no effect.

Try this:

type ParamType = {a: number | string;} | {b: number | string;};
type MyReturnType<T> =
    T extends 'a' ? boolean :
    T extends 'b' ? boolean[] :
    never[];

function fn<T extends ParamType>(arg: T) {
    if ("a" in arg) {
        return true as MyReturnType<keyof T>;
    }
    else if ("b" in arg) {
        return [true, false] as MyReturnType<keyof T>;
    }
    else return [] as MyReturnType<keyof T>;
}

fn({a: 42}); 
/*function fn<{
    a: number;
}>(arg: {
    a: number;
}): boolean*/
fn({b: 'hi'});
/*function fn<{
    b: string;
}>(arg: {
    b: string;
}): boolean[]*/

See https://www.typescriptlang.org/docs/handbook/typescript-in-5-minutes-func.html#unions for unions, and https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-7.html#type-guards-inferred-from-in-operator for in type guard.