解读Typescript中interface和type的用法及区别

type Options<T> = {
  [K in keyof T]: boolean;
};

interface PersonOptions {
  name: boolean;
  age: boolean;
}

// 使用映射类型
type Result = Options<PersonOptions>;
// Result 的类型为 { name: boolean, age: boolean }

// 不能使用映射类型
// interface ResultInterface extends Options<PersonOptions> {}

type Tuple = [number, string];

type NumberArray = Array<number>;

type Union = number | string;

// 有效的定义
type MyType<T> = { value: T };
type MyType2 = MyType<number>;

// 有效的定义
interface MyInterface<T> {
  value: T;
}
type MyInterface2 = MyInterface<number>;

// 无效的定义
// interface MyInterface<T> {
//   value: T;
// }
// interface MyInterface2 extends MyInterface<number> {}

interface Person {
  name: string;
}

interface ExtendedPerson extends Person {
  age: number;
}

// 使用声明合并进行扩展
const person: ExtendedPerson = {
  name: 'John',
  age: 25,
};

type Person = {
  name: string;
};

type ExtendedPerson = Person & {
  age: number;
};

// 使用交叉类型进行扩展
const person: ExtendedPerson = {
  name: 'John',
  age: 25,
};

interface Greeting {
  (name: string): string;
}

interface Person {
  new (name: string): Person;
  name: string;
  sayHello(): void;
}

// 定义调用签名和构造函数签名
const greeting: Greeting = (name) => `Hello, ${name}!`;

class PersonClass implements Person {
  constructor(public name: string) {}
  sayHello() {
    console.log(`Hello, my name is ${this.name}.`);
  }
}

type Greeting = (name: string) => string;

type Person = {
  new (name: string): Person;
  name: string;
  sayHello(): void;
};

// 使用类型别名
const greeting: Greeting = (name) => `Hello, ${name}!`;

class PersonClass implements Person {
  constructor(public name: string) {}
  sayHello() {
    console.log(`Hello, my name is ${this.name}.`);
  }
}