注意:不确定我在这个答案中使用的语法是否可用，当写旧的答案时，但我认为这是解决这个问题中提到的例子的更好方法。

我有一些与这个主题相关的问题(覆盖接口属性)，这是我如何处理它:

首先创建一个泛型接口，其中包含您想要使用的可能类型。

您甚至可以为通用参数使用选择默认值，如<T extends number | SOME_OBJECT = number>中所示

type SOME_OBJECT = { foo: "bar" }

interface INTERFACE_A <T extends number | SOME_OBJECT = number> {
  property: T;
}

然后你可以根据该契约创建新类型，通过将一个值传递给泛型参数(或省略它并使用默认值):

type A_NUMBER = INTERFACE_A;                   // USES THE default = number TYPE. SAME AS INTERFACE_A<number>
type A_SOME_OBJECT = INTERFACE_A<SOME_OBJECT>  // MAKES { property: SOME_OBJECT }

这就是结果:

const aNumber: A_NUMBER = {
    property: 111  // THIS EXPECTS A NUMBER
}

const anObject: A_SOME_OBJECT = {
    property: {   // THIS EXPECTS SOME_OBJECT
        foo: "bar"
    }
}

打印稿操场

覆盖为别名类型

你可以使用这个类型的别名:

type Override<T, K extends { [P in keyof T]: any } | string> =
  K extends string
    ? Omit<T, K>
    : Omit<T, keyof K> & K;

在下面的语法中使用alike:

全球接口

interface IFirst {
    username: string;
}

接口由重写只是名称

interface ISecond extends Override<IFirst, 'username'> {
    username: number;
}

类型别名覆盖

type IThird = Override<IFirst, { username: boolean }>;

编辑:

我试图通过将问题作为建议发送到typescript Repo，将这个别名类型添加为typescript中的内置类型

扩展接口时省略该属性:

interface A {
  a: number;
  b: number;
}

interface B extends Omit<A, 'a'> {
  a: boolean;
}

 type ModifiedType = Modify<OriginalType, {
  a: number;
  b: number;
}>
 
interface ModifiedInterface extends Modify<OriginalType, {
  a: number;
  b: number;
}> {}

受到ZSkycat扩展的省略解决方案的启发，我想出了这个:

type Modify<T, R> =省略<T, R> & R键; //在typescript@3.5之前 type修改<T, R> =选择<T，排除<keyof T, keyof R>> & R

例子:

interface OriginalInterface {
  a: string;
  b: boolean;
  c: number;
}

type ModifiedType  = Modify<OriginalInterface , {
  a: number;
  b: number;
}>

// ModifiedType = { a: number; b: number; c: number; }

一步一步地:

type R0 = Omit<OriginalType, 'a' | 'b'>        // { c: number; }
type R1 = R0 & {a: number, b: number }         // { a: number; b: number; c: number; }

type T0 = Exclude<'a' | 'b' | 'c' , 'a' | 'b'> // 'c'
type T1 = Pick<OriginalType, T0>               // { c: number; }
type T2 = T1 & {a: number, b: number }         // { a: number; b: number; c: number; }

TypeScript实用工具类型

深度修改v3

interface Original {
  a: {
    a: string
    b: { a: string }
    c: string
    d: string         // <- keep this one 
  }
}

interface Overrides {
  a: {
    a: { a: number }  // <- overwrite string with object
    b: number         // <- overwrite object with number
    c: number         // <- overwrite string with number
    e: number         // <- new property
  }
}

type ModifiedType = ModifyDeep<Original, Overrides>
interface ModifiedInterface extends ModifyDeep<Original, Overrides> {}

const example: ModifiedType = {
  a: {
    a: { a: number },
    b: number,
    c: number,
    d: string,
    e: number,
  }
}

在下面找到ModifyDeep。

对于像我这样的懒人来说，简单的答案是:

type Overrided = Omit<YourInterface, 'overrideField'> & { overrideField: <type> }; 

interface Overrided extends Omit<YourInterface, 'overrideField'> {
  overrideField: <type>
}

更好的解决方案是使用以下修改类型(双关语)的这个答案

export type Modify<T, R extends Partial<T>> = Omit<T, keyof R> & R;

这也将检查你覆盖的键是否也存在于原始接口中，从而确保如果原始接口更改了名称，那么你将得到编译时错误，你也必须更改名称。

解释:

举个例子。

interface OriginalInterface {
    id: string
}

修改后的型号如下图所示

interface ModifiedInterface {
    id: number
}

现在，假设在未来，OriginalInterface的id被重命名为uId，然后使用我的类型实用程序，你将得到如下错误

interface ModifiedInterface {
    id: number // Type '{ geo_point1: GeoPoint | null; }' has no properties in common with type 'Partial<Address>'.ts(2559)
}