基于ZSkycat的出色回答，您可以创建一个抽象的Override泛型类型，该类型易于使用并清楚地解释了代码的意图。

type Override<T, K extends keyof T, N> =省略<T, K> & {[K中的K1]: N};

地点:

现有类型 K =您希望覆盖的类型的键 N =要覆盖现有类型的键的新类型

使用示例:

type GraphQLCodegenConfig =覆盖<CodegenConfig， 'schema'， DocumentNode>;

不能更改现有属性的类型。

你可以添加一个属性:

interface A {
    newProperty: any;
}

而是改变现有的一种类型:

interface A {
    property: any;
}

导致一个错误:

后续变量声明必须具有相同的类型。变量 'property'必须是'number'类型，但这里有'any'类型

当然，您可以拥有自己的接口来扩展现有的接口。在这种情况下，你可以重写一个类型到一个兼容的类型，例如:

interface A {
    x: string | number;
}

interface B extends A {
    x: number;
}

顺便说一下，你可能应该避免使用Object作为类型，而是使用any类型。

在任何类型的文档中，它声明:

any类型是使用现有JavaScript的强大方式， 允许您在过程中逐渐选择加入或退出类型检查 编译。您可能希望Object扮演类似的角色 在其他语言中是这样。但是Object类型的变量只允许你 要给它们赋值-你不能调用任意的方法 他们，甚至那些真实存在的人:

let notSure: any = 4;
notSure.ifItExists(); // okay, ifItExists might exist at runtime
notSure.toFixed(); // okay, toFixed exists (but the compiler doesn't check)

let prettySure: Object = 4;
prettySure.toFixed(); // Error: Property 'toFixed' doesn't exist on type 'Object'.

对于缩小属性的类型，简单的扩展是完美的，正如Nitzan的回答:

interface A {
    x: string | number;
}

interface B extends A {
    x: number;
}

为了扩大，或通常覆盖类型，你可以做Zskycat的解决方案:

interface A {
    x: string
}

export type B = Omit<A, 'x'> & { x: number };

但是，如果您的接口A扩展了一个通用接口，那么在使用省略时，您将失去A的剩余属性的自定义类型。

e.g.

interface A extends Record<string | number, number | string | boolean> {
    x: string;
    y: boolean;
}

export type B = Omit<A, 'x'> & { x: number };

let b: B = { x: 2, y: "hi" }; // no error on b.y! 

原因是，在内部，省略只在排除<keyof A， 'x'>键，这将是一般字符串|数字在我们的情况下。因此，B将变成{x: number;}并接受数字| string | boolean类型的任何额外属性。

为了解决这个问题，我提出了一个不同的OverrideProps实用程序类型如下:

type OverrideProps<M, N> = { [P in keyof M]: P extends keyof N ? N[P] : M[P] };

例子:

type OverrideProps<M, N> = { [P in keyof M]: P extends keyof N ? N[P] : M[P] };

interface A extends Record<string | number, number | string | boolean> {
    x: string;
    y: boolean;
}

export type B = OverrideProps<A, { x: number }>;

let b: B = { x: 2, y: "hi" }; // error: b.y should be boolean!

日期:19/3/2021。 我认为最新的typescript(4.1.2)版本支持d.ts文件中的接口覆盖。

// in test.d.ts

interface A {
  a: string
}

export interface B extends A {
  a: number
}

// in any ts file
import { B } from 'test.d.ts'

// this will work
const test: B = { a: 3 }

// this will not work
const test1: B = { a: "3" }

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

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

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

您甚至可以为通用参数使用选择默认值，如<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"
    }
}

打印稿操场

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

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