"在 TypeScript 中推断接口属性类型"

Question

Say I have this interface and an object that contains that type:

interface IMyData {
    a: TypeA;
    b: TypeB;
    c: boolean;
    d: string;
}

const myObj: { data: IMyData } = {
    data: {
         a: someValueA,
         b: someValueB,
         c: true,
         d: "someValueD"
    }
}

Answer 1

You have to tell the typesystem the exact literal value of field . The easiest way to do that is to use a generic function like this:

interface IMyData {
    c: boolean;
    d: string;
}

const myObj: { data: IMyData } = {
    data: {
         c: true,
         d: "someValueD"
    }
}

function getField<T extends keyof IMyData>(obj: { data: IMyData }, field: T){
    return obj.data[field];
}

const myFieldStr = getField(myObj, "c"); // should infer type boolean
const myFieldBool = getField(myObj, "d"); // should infer type string

Or in the simplest general case:

function pluck<T, K extends keyof T>(obj : T, key : K) {
    return obj[key];
}

const foo = pluck({ bar: "asd", baz: 5 }, "bar"); // infers string

Answer 2

A possible solution to the second (more complex) scenario would be to define a new type which will extract the type from the generic:

type GenericOf<S> = S extends IMyValue<infer T> ? T : never;

Now you "plug-in" that type your function:

function getValue<T extends keyof IMyData2>(field: T, data: IMyData2) {
    // old solution: return data[field] ? data[field]!.value : undefined;
    return data[field]?.value as GenericOf<IMyData2[T]>;
}

This will result the return values of the function to be correctly typed:

const testValue1 = getValue('a', testData); // string | undefined
const testValue2 = getValue('b', testData); // number | undefined
const testValue3 = getValue('c', testData); // boolean | undefined
const testValue4 = getValue('d', testData); // string | undefined

This is not the most elegant solution but it works!