typescript :在将可选类型与所需类型合并时创建联合而不是交集

当 optional 和 required 属性通过交集合并时， required 获胜

type A = { who: string }
type B = { who?: string }
// $ExpectType {who:string}
type R = A & B

这可能会导致运行时错误，例如，在处理函数中的默认参数模式时

type Params = {
  who: string
  greeting: string
}

const defaults: Params = {
  greeting: 'Hello',
  who: 'Johny 5',
}

function greeting(params: Partial<Params>){
  // $ExpectType Params
  const merged = {...defaults, ...params}

  return `${merged.greeting.toUpperCase()} ${merged.who} !`
}

// @throws - TypeError: Cannot read property 'toUpperCase' of undefined
greeting({greeting:undefined, who: 'Chuck'})

问题:

正如我所描述的是 TS 编译器的行为方式，问题是，如何创建映射类型，这将将该交集解析为联合

所以像:

type SafeMerge<A,B>=....

// $ExpectType {greeting?: string | undefined, who?: string | undefined }
type Result = SafeMerge<Params, Partial<Params>>

混合类型示例:

// $ExpectType {one?: number | undefined, two: string, three: boolean }
type Result = SafeMerge<{one: number, two:string}, {one?: number, three: boolean}>

最佳答案

获得一个合并类型，它是两种类型的合并，每个属性都有一个可能性的联合很简单。我们可以在两种构成类型的键上使用映射类型:

type SafeMerge<T, U> = {
  [P in keyof T |  keyof U] :
    | (T extends Partial<Record<P, any>> ? T[P] : never)
    | (U extends Partial<Record<P, any>> ? U[P] : never)
}
type Result = SafeMerge<{one: number, two:string }, {one?: number, three: boolean }>
// Result:
// type Result = {
//     one: number | undefined;
//     two: string;
//     three: boolean;
// }

Play

上述解决方案的问题在于我们失去了键的可选性(还有只读性，这对于这个用例来说可能不太重要)。同态映射类型保留修饰符，但不幸的是，我们不能在这里使用修饰符，因为我们真的不适契约(Contract)态映射类型的任何模式( { [P in keyof T] : T[P] } 或 {[P in K]: T[P] } ，其中 K 是带有 K extends keyof T 的类型参数，参见 Here 和 Here )。

我们可以提取可选键并使用两种映射类型，一种用于任何可选键(在至少一个组成部分中是可选的键)，另一种用于所需键:

type OptionalPropertyOf<T> = Exclude<{
  [K in keyof T]: T extends Record<K, T[K]>
    ? never
    : K
}[keyof T], undefined>

type SafeMerge<T, U> = {
  [P in OptionalPropertyOf<T> |  OptionalPropertyOf<U>]?:
    | (T extends Partial<Record<P, any>> ? T[P] : never)
    | (U extends Partial<Record<P, any>> ? U[P] : never)
} & {
  [P in Exclude<keyof T | keyof U,  OptionalPropertyOf<T> |  OptionalPropertyOf<U>>]:
    | (T extends Partial<Record<P, any>> ? T[P] : never)
    | (U extends Partial<Record<P, any>> ? U[P] : never)
}

type Result = SafeMerge<{one: number, two:string, three: number}, {one?: number, three: boolean}>
// Result:
// type Result = {
//     one?: number | undefined;
// } & {
//     two: string;
//     three: number | boolean;
// }

type Id<T> = {} & { [P in keyof T]: T[P] }
type FlattenedResult = Id<SafeMerge<{one: number, two:string, three: number }, {one?: number, three: boolean}>>
// type FlattenedResult = {
//     one?: number | undefined;
//     two: string;
//     three: number | boolean;
// }

Play

可选地，我们可以 Id 像我在上面的示例中所做的那样展平交叉点，但这是可选的。

关于 typescript :在将可选类型与所需类型合并时创建联合而不是交集，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/57474241/