qq_58167463
qq_58167463 已结题
采纳率100% 2022-12-06

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}
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
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>>
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");
  • 更多

2 条回答 默认 最新

  • qq_58167463
    qq_58167463
    2022-12-06
    专家已采纳 最佳回答
    // 合并两个对象类型
    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}
                  采纳该答案
                  专家已采纳
                 已采纳该答案
    登录 后可回复...
  • ShowMeAI
    ShowMeAI
    2022-12-06
    专家已采纳 最佳回答

    望采纳

    在 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 包含 AB 中所有的属性。可以这样使用类型 C

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

    请注意,如果 AB 中包含了同名的属性,那么合并后的类型 C 中该属性的类型就是 AB 中该属性的类型的联合类型。例如:

    type A = {
      a: string;
    type B = {
      a: number;
    type C = A & B;
    // C.a 的类型为 string | number
                  采纳该答案
                  专家已采纳
                 已采纳该答案
    解决 1 无用
    登录 后可回复...
查看更多回答(1条)

相关推荐 更多相似问题