TypeScript 合并两个对象类型

1.TS 不一样的类型怎么合并？

   // 合并两个对象类型
type MergeObject<T extends Record<string, string>, U extends Record<string, string>> = {

}

type MergeObject<{a: string}, {b: number}>;    // =>  {a: string, b: number}

2.

题目：
type formateParams<T>(arg: T) {}

type F= formateParams("a=1&b=2&c=3");    //=> {a:1,b:2, c:3}
答：
type _Split<
  T extends string,
  I extends string
> = T extends `${infer H}${I}${infer Rest}` ? [H, ..._Split<Rest, I>] : [T];

type _Map<T extends string[], U extends any[] = []> = T extends [
  infer H,
  ...infer Rest extends string[]
]
  ? H extends `${infer K}=${infer V}`
    ? _Map<Rest, [...U, { [key in K]: V }]>
    : never
  : U;

type MergeObject<
  T extends Record<string, string>,
  U extends Record<string, string>
> = {
  [K in keyof T | keyof U]: K extends keyof T
    ? K extends keyof U
      ? [T[K], U[K]]
      : T[K]
    : U[K & string];
};

type MergeObjectArray<
  T extends Record<string, string>[],
  U extends {} = {}
> = T extends [
  infer H extends Record<string, string>,
  ...infer Rest extends Record<string, string>[]
]
  ? MergeObjectArray<Rest, MergeObject<U, H>>
  : U;

type FormateParams<T extends string> = MergeObjectArray<_Map<_Split<T, "&">>>;

function _formateParams<T extends string>(querystring: T): FormateParams<T> {
  return querystring
    .split("&")
    .map((item) => item.split("="))
    .reduce((prev, [key, value]) => {
      prev[key] = value;
      return prev;
    }, {} as Record<string, string>) as any;
}

const res = _formateParams("a=1&b=2&c=3&a=5&b=6");

// 合并两个对象类型
type MergeObject<
  T extends Record<string, any>,
  U extends Record<string, any>
> = {
  [K in keyof T | keyof U]: K extends keyof T
    ? K extends keyof U
      ? [T[K], U[K]]
      : T[K]
    : U[K & string];
};

type X = MergeObject<{ a: string }, { b: number }>; 
// {a: string, b: number}

望采纳

在 TypeScript 中，可以使用类型断言或类型转换来合并两个对象类型。举个例子，假设我们有两个对象类型 A 和 B，要将它们合并成一个新的类型 C。我们可以这样做：

type A = {
  a: string;
  b: number;
};

type B = {
  c: boolean;
  d: string;
};

// 使用类型断言
type C = A & B;

// 或者使用类型转换
type C = { [P in keyof (A & B)]: (A & B)[P] };

类型断言和类型转换的结果都是一样的，即新类型 C 包含 A 和 B 中所有的属性。可以这样使用类型 C：

const c: C = {
  a: "hello",
  b: 123,
  c: true,
  d: "world"
};

请注意，如果 A 和 B 中包含了同名的属性，那么合并后的类型 C 中该属性的类型就是 A 和 B 中该属性的类型的联合类型。例如：

type A = {
  a: string;
};

type B = {
  a: number;
};

type C = A & B;

// C.a 的类型为 string | number