扩展了Qwerty的Modify实用程序类型解决方案，将R的键限制为T中出现的键，并添加智能感知

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

对于缩小属性的类型，简单的扩展是完美的，正如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!

我使用一种方法，首先过滤字段，然后组合它们。

从类型中排除属性

interface A {
    x: string
}

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

的接口:

interface A {
    x: string
}

interface B extends Omit<A, 'x'> {
  x: number
}

创建修饰符类型

type Modify<T, R extends {[P in keyof T]:any} > = Omit<T, keyof R> & R;

你可以

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

它会给你一个类型自动完成

覆盖接口的两个或多个属性的解决方案:

接口原始{ 答:字符串; b:字符串; c:字符串; ｝ interface Modified extends省略<Original， 'a' | 'b'> { 一个吗?:字符串;//设置为可选 b:布尔;//设置为布尔值 d:数量;//添加另一个属性 ｝

来自TypeScript文档

我已经创建了这个类型，允许我轻松地覆盖嵌套接口:

export type DeepPartialAny<T> = {
  [P in keyof T]?: T[P] extends Obj ? DeepPartialAny<T[P]> : any;
};

export type Override<A extends Obj, AOverride extends DeepPartialAny<A>> = { [K in keyof A]:
  AOverride[K] extends never
    ? A[K]
    : AOverride[K] extends Obj
    ? Override<A[K], AOverride[K]>
    : AOverride[K]
};

然后你可以这样使用它:

interface Foo {
  Bar: {
    Baz: string;
  };
}
type Foo2 = Override<Foo, { Bar: { Baz: number } }>;

const bar: Foo2['Bar']['Baz'] = 1; // number;