主页 / coding / 问题 / 79006599
Accepted
four-eyes
Asked: 2024-09-20 19:44:28 +0800 CST

在 TypeScript 中向派生类型添加另一个值

  • 772

我有这些界面

interface CommonAnimalProps {
    common: {
        size: number, 
        weight: number,
        origin: string,
    }
}

interface DogProps extends CommonAnimalProps {
    name: string
}

interface CatProps extends CommonAnimalProps {
    furious: boolean
}

interface BirdProps extends CommonAnimalProps {
    canFly: boolean
}

export enum AnimalType {
    dog = "dog",
    cat = "cat",
    bird = "bird",
}

export interface AnimalTypeToAnimalPropsMap {
    [AnimalType.dog]: (DogProps)[],
    [AnimalType.cat]: (CatProps)[],
    [AnimalType.bird]: (BirdProps)[]
}

export type AllAnimalValues<T> = T[keyof T]
export type AllAnimalTypesArray = AllAnimalValues<AnimalTypeToAnimalPropsMap>
export type AllAnimalTypes = AllAnimalValues<AnimalTypeToAnimalPropsMap>[0]
export type AllAnimalTypesArrayDiscriminating = AllAnimalTypes[]

这AllAnimalTypesArrayDiscriminating将导致数组看起来像这样

const foo: AllAnimalTypesArrayDiscriminating = [
    {
        name: "Bello",
        common: {
            size: 10,
            weight: 25,
            origin: "Knowhwere"

        },
    },
    {
        furious: true,
        common: {
            size: 3,
            weight: 5,
            origin: "Anywhere"

        },
    },
    {
        canFly: false,
        common: {
            size: 39,
            weight: 50,
            origin: "Somewhere"

        },
    },    
]

是否可以使用AllAnimalTypesArrayDiscriminating并从中创建一个新的类型/接口（AllAnimalTypesArrayDiscriminatingModified），其中结果数组中的每个元素bar都有另一个 prop（color: string）添加，CommonAnimalProps以便结果如下所示

const bar: AllAnimalTypesArrayDiscriminatingModified = [
  {
    name: "Bello",
    common: {
      size: 10,
      weight: 25,
      origin: "Knowhwere",
      color: 'red',

    },
  },
  {
    furious: true,
    common: {
      size: 3,
      weight: 5,
      origin: "Anywhere",
      color: 'brown',

    }
  }, {
    canFly: false,
    common: {
      size: 39,
      weight: 50,
      origin: "Somewhere",
      color: 'white',

    },
  }
];

请注意，我无法修改原始内容CommonAnimalProps以将其添加color为可选参数。我也无法编辑DogProps, CatProps, BirdProps。我正在寻找一种使用AllAnimalTypesArrayDiscriminating（或任何其他我未排除的类型）来添加此属性的方法。有办法做到这一点吗？

typescript

1 个回答

  1. Best Answer

    迄今为止最简单的方法就是使用交集将适当嵌套的成员添加到AllAnimalTypes：

    type AllAnimalTypesModified = AllAnimalTypes & { common: { color: string } };
type AllAnimalTypesArrayDiscriminatingModified = AllAnimalTypesModified[];

    这会在示例中为您提供所需的行为：

    const bar: AllAnimalTypesArrayDiscriminatingModified = [
  {
    name: "Bello",
    common: { size: 10, weight: 25, origin: "Knowhwere", color: 'red' }
  },
  {
    furious: true,
    common: { size: 3, weight: 5, origin: "Anywhere", color: 'brown' }
  },
  {
    canFly: false,
    common: { size: 39, weight: 50, origin: "Somewhere", color: 'white' }
  }
];

    但请注意，这实际上并没有将该成员放入AllAnimalTypes union的每个成员中。它所做的只是说明，除了是一个AllAnimalTypes值之外，它还应该string在其common属性处具有 -valued 属性。

    因此，虽然例如DogProps & { common: { color: string } }或多或少等同于{name: string, common: { size: number, weight: number, origin: string, color: string } }，但它并不是以那种方式表示的，并且根据您执行的操作类型，这种差异可能会很明显。

    如果您确实想计算该类型，以便生成的联合中的每个成员都具有一个嵌套属性，该属性与其他公共属性直接位于同一对象类型中，则需要进行更多类型调整。以下是其中一种方法：

    type AllAnimalTypesModified = AddCommonColor<AllAnimalTypes>;

    AddCommonColor实用程序类型在哪里

    type AddCommonColor<T extends CommonAnimalProps> =
  T extends unknown ? {
    [K in keyof T]: K extends "common" ? T[K] & { color: string } : T[K]
  } : never;

    这是一个分配条件类型。该类型T extends unknown ? ⋯T⋯ : never看起来像是无操作，因为所有类型都T扩展了unknown，但此类型的重点不是执行检查，而是将部分分配⋯T⋯给中的联合T。也就是说，我们希望AddCommonColor<X | Y | Z>评估为AddCommonColor<X> | AddCommonColor<Y> | AddCommonColor<Z>。

    我们为给定联合成员计算的实际类型是{ [K in keyof T]: K extends "common" ? T[K] & { color: string } : T[K] }，这是一种映射类型common，除了与之相交的之外，所有属性均保持不变{color: string}。

    如果我们现在检查，AllAnimalTypesModified我们得到

    type AllAnimalTypesModified = {
  name: string;
  common: {
      size: number;
      weight: number;
      origin: string;
  } & {
      color: string;
  };
} | {
  furious: boolean;
  common: {
      size: number;
      weight: number;
      origin: string;
  } & {
      color: string;
  };
} | {
  canFly: boolean;
  common: {
      size: number;
      weight: number;
      origin: string;
  } & {
      color: string;
  };
}

    财产color位于common每个工会成员的财产中。即使这也不是您想要看到的方式；可以像这样摆脱这种交集：

    type AddCommonColor<T extends CommonAnimalProps> =
  T extends unknown ? {
    [K in keyof T]: K extends "common" ? {
      [P in "color" | keyof T[K]]: P extends keyof T[K] ? T[K][P] : string
    } : T[K]
  } : never;

    产生

    type AllAnimalTypesModified = {
    name: string;
    common: {
        color: string;
        size: number;
        weight: number;
        origin: string;
    };
} | {
    furious: boolean;
    common: {
        color: string;
        size: number;
        weight: number;
        origin: string;
    };
} | {
    canFly: boolean;
    common: {
        color: string;
        size: number;
        weight: number;
        origin: string;
    };
}

    但这对于您的用例来说可能有些过度了。

    游乐场链接到代码

    • 1

相关问题