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

引用从类型中排除属性

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 ModifiedType = Modify<OriginalType, {
  a: number;
  b: number;
}>
 
interface ModifiedInterface extends Modify<OriginalType, {
  a: number;
  b: number;
}> {}

受ZSkycat extends Omit解决方案的启发，我想出了这个：

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

// before typescript@3.5
type Modify<T, R> = Pick<T, Exclude<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 实用程序类型

v2.0 深度修改

interface Original {
  a: {
    b: string
    d: {
      e: string // <- will be changed
    }
  }
  f: number
}

interface Overrides {
  a: {
    d: {
      e: number
      f: number // <- new key
    }
  }
  b: {         // <- new key
    c: number
  }
}

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

// ModifiedType =
{
  a: {
    b: string
    d: {
      e: number
      f: number
    }
  }
  b: {
    c: number
  }
  f: number
}

ModifyDeep 在下面找到。

您无法更改现有属性的类型。

您可以添加一个属性：

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它指出：

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'.

稍微扩展@zSkycat 的答案，您可以创建一个泛型，它接受两种对象类型并返回一个合并类型，其中第二个的成员覆盖第一个的成员。

type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>
type Merge<M, N> = Omit<M, Extract<keyof M, keyof N>> & N;

interface A {
    name: string;
    color?: string;
}

// redefine name to be string | number
type B = Merge<A, {
    name: string | number;
    favorite?: boolean;
}>;

let one: A = {
    name: 'asdf',
    color: 'blue'
};

// A can become B because the types are all compatible
let two: B = one;

let three: B = {
    name: 1
};

three.name = 'Bee';
three.favorite = true;
three.color = 'green';

// B cannot become A because the type of name (string | number) isn't compatible
// with A even though the value is a string
// Error: Type {...} is not assignable to type A
let four: A = three;

Omit 扩展接口时的属性：

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

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