TypeScript手册给出了答案：

界面的几乎所有功能都是可用的类型。关键区别在于不能重新打开类型以添加新的财产vs始终可扩展的接口。

除了已经提供的出色答案之外，在扩展类型和接口方面还有明显的区别。我最近遇到了一些界面无法完成任务的情况：

无法使用接口扩展联合类型无法扩展通用接口

其他答案很棒！Type可以做但Interface不能做的其他事情很少

可以在类型中使用联合

type Name = string | { FullName: string };

const myName = "Jon"; // works fine

const myFullName: Name = {
  FullName: "Jon Doe", //also works fine
};

在类型中迭代联合财产

type Keys = "firstName" | "lastName";

type Name = {
  [key in Keys]: string;
};

const myName: Name = {
  firstName: "jon",
  lastName: "doe",
};

类型中的交集（但是，在带有扩展的接口中也支持）

type Name = {
  firstName: string;
  lastName: string;
};

type Address = {
  city: string;
};

const person: Name & Address = {
  firstName: "jon",
  lastName: "doe",
  city: "scranton",
};

与接口相比，这种类型也不是后来才引入的，根据最新发布的TS类型，它几乎可以做任何接口可以做的事情，而且更多！

*除了声明合并（个人观点：很好，它在类型中不受支持，因为它可能导致代码不一致）

https://www.typescriptlang.org/docs/handbook/advanced-types.html

一个区别是，接口创建了一个新名称，该名称在任何地方都可以使用。键入别名不会创建新名称-例如，错误消息不会使用别名。

接口与类型

接口和类型用于描述对象和原语的类型。接口和类型通常可以互换使用，并且通常提供类似的功能。通常由程序员选择自己的偏好。

然而，接口只能描述创建这些对象的对象和类。因此，必须使用类型来描述字符串和数字等原语。

下面是接口和类型之间的两个区别的示例：

// 1. Declaration merging (interface only)

// This is an extern dependency which we import an object of
interface externDependency { x: number, y: number; }
// When we import it, we might want to extend the interface, e.g. z:number
// We can use declaration merging to define the interface multiple times
// The declarations will be merged and become a single interface
interface externDependency { z: number; }
const dependency: externDependency = {x:1, y:2, z:3}

// 2. union types with primitives (type only)

type foo = {x:number}
type bar = { y: number }
type baz = string | boolean;

type foobarbaz = foo | bar | baz; // either foo, bar, or baz type

// instances of type foobarbaz can be objects (foo, bar) or primitives (baz)
const instance1: foobarbaz = {y:1} 
const instance2: foobarbaz = {x:1} 
const instance3: foobarbaz = true 

想加上我的2美分；

我曾经是“界面爱好者”（除了联合、交叉等以外，我更喜欢界面而不是类型）。。。直到我开始使用类型“any key value object”，即Record＜string，unknown＞

如果键入“任意键值对象”：

function foo(data: Record<string, unknown>): void {
  for (const [key, value] of Object.entries(data)) {
    // whatever
  }
}

如果你使用接口，你可能会走到死胡同

interface IGoo {
  iam: string;
}

function getGoo(): IGoo {
  return { iam: 'an interface' };
}

const goo = getGoo(); 

foo(goo); // ERROR
// Argument of type 'IGoo' is not assignable to parameter of type 
// 'Record<string, unknown>'.
//  Index signature for type 'string' is missing in type 
// 'IGoo'.ts(2345)

虽然打字就像一个符咒：

type Hoo = {
  iam: string;
};

function getHoo(): Hoo {
  return { iam: 'a type' }; 
}

const hoo = getHoo(); 

foo(hoo); // works

这个特定的用例——IMO——产生了不同。