Question

type DnsRecords = {
  [key: string]: {
    component: FC<A>
    toInlineValue: (data: A) => string
    fromInlineValue: (record: string) => A
  }
}

但是对于每个子对象，A可以不同。

例如：

type DnsRecords = {
  a: {
    component: FC<{ a: number }>
    toInlineValue: (data: { a: number }) => string
    fromInlineValue: (record: string) => { a: number }
  }
  b: {
    component: FC<string | number>
    toInlineValue: (data: string | number) => string
    fromInlineValue: (record: string) => string | number
  }
}

Answer 1

无法直接执行此操作。您需要为DnsRecords添加一个额外的通用类型，以包含每个属性的类型：

type DnsRecords<T> = {
    [P in keyof T]: {
        component: FC<T[P]>
        toInlineValue: (data: T[P]) => string
        fromInlineValue: (record: string) => T[P]
}
}
type V = DnsRecords<{
    a: { foo: string },
    b: { bar: string }
}>

您可以创建一个有助于推断T的函数，但是如果您使用其他值，则编译器将推断属性的并集：

function createDns<T>(dns: DnsRecords<T>) {
    return dns;
}

type A = { x: string }
type B = { x2: string }

let o = createDns({ // T is { a: A | B; }
    a: {
        component: (p: A) => { },
        toInlineValue: (data: B) => "",
        fromInlineValue: (r) => ({ x: r })
    }
})

如何创建“内部通用”类型？

1 个答案: