在 Typescript 联合中键入属性的 getter

Question

I have theses Typescript types:

type A = {
  a: string
}

type B = {
  b: number,
}

type C = number;

type U = A | B | C;

I'm trying to write the function that, given a property of one of U types, return the property value or undefined .

In Javascript, it would be something like that:

function getProp(prop: P) {
  return (thing) => {
    if (typeof thing === 'object' && prop in thing) {
      return thing[prop]
    }

    return undefined;
  }  
}

Example:

const u: U = ...;

const a: string | undefined = getProp('a')(u);

I've tried this:

type KeysOfUnion<T> = T extends any ? keyof T : never; // because `keyof U` return `never`

function getProp<P extends KeysOfUnion<U>>(prop: P) {
    return (thing: U): U[P] => { // error: `Type 'P' cannot be used to index type 'U'.`
        if (typeof thing === 'object' && prop in thing) {
          return thing[prop]; // error: Type 'P' cannot be used to index type 'A | B'
        }

        return undefined; // error: Type 'undefined' is not assignable to type 'U[P]'.
    }
}

const a: string | undefined = getProp('a')(u);

But this is not valid. I think I have to find an alternative for U[P] if I want to type this strange function properly but I don't see what. Any idea?

Answer 1

From the caller's side of view, you probably want getProp() to return a function which returns IdxUnion<U, P> , where IdxUnion is defined like this:

type IdxUnion<T, K extends PropertyKey> =
  T extends any ? K extends keyof T ? T[K] : undefined : never;

This will do the lookup for each member of a union T and return either T[K] or undefined depending on whether or not K is a key of that member of T . This should fix things from the call side, mostly:

const a = getProp('a')(u); // string | undefined

I say "mostly" because the function implementation doesn't quite do what you're saying it will do given the signature: if u is a number and not an object, you are always returning undefined at runtime, but number has keys such as toFixed , so you'd expect getProp('toFixed')(123) to be a function. This is mostly not a problem for your particular U , since A and B will give you the undefined that actually comes out, but it's weird. So be careful:

const hmm = getProp('toFixed')(123);
// ((fractionDigits?: number | undefined) => string) | undefined

---

Inside the implemementation of getProp() , things are tougher. The compiler generally has a hard time evaluating the type safety of operations that occur on unspecified generic types, especially conditional types. Your best bet here is probably to use type assertions to tell the compiler that you know what you're doing:

if (typeof thing === "object" && prop in thing) {
  return thing[prop as keyof typeof thing]; // assert
}
return undefined as IdxUnion<U, P>; // assert

---

Anyway, hope that helps; good luck!

Playground link to code