ts type interface 区别_TS: 高级类型|精选博客

TS 文档是有一章叫高级类型，其实并不是真的“高级”，他实际的意思是将普通的类型用“某种方式”组合起来形成一个“组合类型”，这个组合类型叫高级类型。对于这种组合后的类型可以有一些特殊的操作。

交叉类型

交叉类型就是一个高级类型的典型，它表示多种类型取并集组成的一个类型。

interface First {

a: number;

b: number;

}

interface Second {

a: number;

c: number;

}

function mix():First & Second {

const result = {

a: 1,

b: 2,

c: 3

}

return result

}

mix() // {a: 1, b: 2, c: 3}

上面将 First 和 Second 交叉在了一起，相当于对两个 interface 的属性取并集，取完并集的新类型就是交叉类型。

联合类型

联合类型就是多种类型选其一。

function add(a: number|string, b: number|string) {

}

上面函数的参数的类型可以为 number 或者 string，这就比单单一个 string 或者单单一个 number 类型要高级，因为这里可以选呀。

类型保护与区分类型

这个特性就是要怎么判断好一个变量的类型。先来回顾一下 JS 里的 7 种基本类型：number, string, boolean, object, null, undefined, symbol。

typeof 保护

使用 typeof 做类型检测和以前写 JS 一样。以上面的加法函数为例。

function add(a: number|string, b: number|string) {

if (typeof a === 'number' && typeof b === 'number') {

console.log(a + b)

}

if (typeof a === 'string' && typeof b === 'string') {

console.log(parseInt(a) + parseInt(b))

}

}

这里代码是有点啰嗦，主要突出 typeof 的使用。

instanceof 保护

typeof 有个缺点就是不能将 object 细分，比如要 typeof Date 类型和 RegExp 类型，结果总是 'object'，不能再细分了。instanceof 就可以完美解决，它后面跟的是一个构造函数，可以判断当前变量是否属于这个构造函数。

function printDate(a: Date|String) {

if (a instanceof Date) {

console.log(a.toDateString())

}

else if (a instanceof String){

console.log(a.toString())

}

}

printDate(new Date()) // "Thu Mar 14 2019"

printDate(new String("2019/1/2")) // "2019/1/2"

上面是根据传入不同的对象来打印时间的函数。

自定义保护

上面 typeof 和 instanceof 都是 JS 提供判断类型的方法，当然我们也可以自己去实现。

interface Bird {

fly();

}

interface Fish {

swim();

}

function isFish(pet: Fish | Bird): pet is Fish {

return (pet).swim !== undefined;

}

上面就定义了一个函数去判断传入参数是属于 Bird 还是 Fish，这里判断的依据是看变量是否含有 swim 方法。后面写 if-else 语句就可以调用这个函数了。

function doSth(pet: Fish|Bird) {

if (isFish(pet)) {

pet.swim();

}

else {

pet.fly();

}

}

let pet1:Fish = {

swim() {

console.log('Swimming....')

}

}

let pet2:Bird = {

fly() {

console.log('Flying....')

}

}

doSth(pet1) // 'Swimming'

doSth(pet2) // 'Flying'

类型别名

使用 type 关键字可以定义别名。

type RC = React.Component

class A extends React.Component {

}

type Phone = string | number

type Human = {

name: string

age: number

}

它的作用就是可以不需要每次都写那么多的字。由于是“别名”，所以 Phone， Human都是指代等号后面那一堆东西，在引用的时候不要别名看成是一个变量，而是要看成后面那一堆东西。

function setPhone(phone: Phone) {

}

// 要看成是

function setPhone(phone: string|number) {

}

这其实也是 interface 和 type 的一个主要区别，interface 是真实存在的，而 type 只是一个名字。

字符串字面量

这个和枚举差不多，有点像联合类型的用法。

type Dir = 'up' | 'down' | 'left' | 'right'

let d: Dir = 'up2' // 报错

type Dice = 1 | 2 | 3 | 4 | 5 | 6

type dice: Dice = 2

可辨识联合

一句话总结是就是对不同对象的相同属性进行判断，根据判断结果做对应的事。

interface Square {

kind: "square";

size: number;

}

interface Rectangle {

kind: "rectangle";

width: number;

height: number;

}

interface Circle {

kind: "circle";

radius: number;

}

上面先定义了三个不同的 interface，它们都有相同的属性 "kind"。为了方便，再定义一个 type。

type Shape = Square | Rectangle | Circle;

下面就是可辨识联合，就是写判断语句去判断 "kind" 的值来求对应的面积。

function area(s: Shape) {

switch (s.kind) {

case "square": return s.size * s.size;

case "rectangle": return s.height * s.width;

case "circle": return Math.PI * s.radius ** 2;

}

}

完整性检查

有可能程序员偷懒不想全都检查所有 kind 的值，那可以在 default 那里抛出错误，返回值是 never，表示不会存在。

function assertNever(x: never): never {

throw new Error("Unexpected object: " + x);

}

function area(s: Shape) {

switch (s.kind) {

case "square": return s.size * s.size;

case "rectangle": return s.height * s.width;

case "circle": return Math.PI * s.radius ** 2;

default: return assertNever(s); // error here if there are missing cases

}

}

如果传入对象 kind:"triangle" 那么不会得到一个具体的值，同时也会报错来提示传入对象不对。