TypeScript类型声明别名方式（type与interface）

类型声明别名可以理解自定义类型，变量的类型可以包含多个类型

类型声明别名方式有两种

1. **type **

语法：

声明基本类型

type 类型别名 = 类型 | 类型 |类型 ...

声明对象
type 类型别名  = {
  属性:类型
}

//1. 基本类型
//定义数组里元素类型
type ClassType = string | number | undefined | boolean
let arr: ClassType[] = [1, 2, 3, "22"]
// let arr = Array<ClassType> = [1, 2, 3, "22"]

type numType = 1 | 2 | 1 | 3 | 8
let num: numType = 1  //
// let num1:numType = 4 //error

//2. 定义对象类型

type ObjClassType = {
    id: number,
    name: string,
    flag: boolean
}

let obj: ObjClassType = {
    name: '22',
    id: 1,
    flag: true
}

//无法再次定义ObjClassType，报错

//type ObjClassType = {
//   age:number
//}

不能重复声明，会报错。

2. interface (接口)

接口用来定义一个类结构，用来定义一个类中应该包含哪些属性何方法；
同时接口也可以当成对象类型声明去使用，可以重定义的

• 对象类型声明

interface classtype {
    id: number,
    name: string,
    age: number
}

interface classtype {
    flag: boolean
}
let object1: classtype = {
    id: 1,
    name: "sd",
    age: 18,
    flag: true
}

• 定义类的结构
  • 接口中所以的属性都不能有实际的值，只定义类的结构，不考虑实际的值

interface classtype1 {
    id: number;
    name: string;
    age: number;
    sayHi(): void
}
 //implements是对某个接口的实现，必须满足接口的类型规范
class Person implements classtype1 {
    id: number;
    name: string;
    age: number;
    flag: boolean;

    constructor(id: number, name: string, age: number, flag: boolean) {
        this.id = id
        this.name = name
        this.age = age
        this.flag = flag
    }
    sayHi() {
        console.log("Hi");

    }
}

• 定义可选类型以及任意类型

interface classtype {
    id: number,
    name?: string,//可选类型
    [propName: string]: any //任意类型
}
let t: classtype = {
    id: 1, age: 123, name: "222"
}

区别

相同点

• 都可以描述一个对象或者函数
  • interface

//定义对象
interface inType {
    name: string;
    student: boolean;
    age: number;
}
let stu: inType = {
    name: "",
    student: true,
    age: 1
}

//定义函数
interface sayType {
    (flang: boolean, dateTime: string): string
}

let say: sayType = (flang: boolean, dateTime: string):string => {
    return ""
}

• type

//定义对象
type studentType = {
    id: number;
    name: string;
    age: number;
    gender: boolean;
}

let student: studentType = {
    id: 1,
    name: "",
    age: 1,
    gender: true
}

//定义函数
type setStud = (id: number, name: string) => void

let setStu: setStud = (id: number, name: string) => { }

• 都能相互继承（extends）

interface 和 type 都可以拓展（extends），并且两者并不是相互独立的，也就是说 interface 可以 extends type, type 也可以 extends interface 。 虽然效果差不多，但是两者语法不同。
说明：

如果重定义类型声明别名，已继承的类型声明为主

• interface extends type

//定义对象类型声明继承 interface extends type
type studentType = {
    id: number;
    name: string;
    age: number;
    gender: boolean;
}

interface inType extends studentType {
    student: string;
}

let stu:inType = {
    student: "",
    id: 0,
    name: "",
    age: 0,
    gender: false
}

• interface extends interface

//interface extends interface
interface stuClass {
    name: string;
    idCard: number;
}

interface stuType extends stuClass {
    sex: boolean;
    age: number
}

let sdu:stuType ={
    sex: false,
    age: 0,
    name: "",
    idCard: 0
}

• type extends type

//type extends type
type studentType = {
    id: number;
    name: string;
    age: number;
    gender: boolean;
}

type stud = studentType & {
    idCard: number
}

let s: stud = {
    id: 1,
    name: "",
    age: 1,
    gender: false,
    idCard: 1
}

• type extends interface

//type extends interface
interface Name {
    name: string;
}
type User = Name & {
    age: number;
}

let a: User = {
    name: "",
    age: 1
}

• 都可以定义可选类型以及任意类型

//interface
interface classtype {
    id: number,
    name?: string,//可选类型
    [propName: string]: any //任意类型
}
let t: classtype = {
    id: 1, age: 123, name: "222"
}

//type
type a = {
    id: number;
    name?: string;
    [propName: string]: any;
}

let h:a = {
    id:1,
    age:"22"
}

不同点

1. type 可以而 interface 不行

• type 可以声明基本类型别名，联合类型，元组等类型

// 基本类型别名
type Name = string

// 联合类型
interface Dog {
    name:string
}
interface Cat {
    id:number
}

type Pet = Dog | Cat

let h: Pet = {
    id: 1
}

// 具体定义数组每个位置的类型
type PetList = [Dog, Pet]

• type 语句中还可以使用 typeof 获取实例的 类型进行赋值

let a = ""

type h = typeof a

let c:h = "22"

• 其他操作

//或者
type StringOrNumber = string | number;
type Text = string | { text: string }; 
//泛型 
type Callback<T> = (data: T) => void;  
type Pair<T> = [T, T];   
type Tree<T> = T | { left: Tree<T>, right: Tree<T> };

2. interface 可以而 type 不行

• interface 能够声明合并

interface User {
  name: string
  age: number
}

interface User {
  sex: string
}

interface 可以重定义类型声明，而type就不行