打字稿：在将可选类型与所需类型合并时创建联合而不是交集

Question

当 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}>

Answer 1

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

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;
// }

玩

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

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

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;
// }

玩

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