TS 中补充的六个类型

(1)元祖

元祖可以是看作数组的拓展,他表示已知元素数量和类型的数组。确切的说,是已知数组中每一个位置上的元素的类型

let tuple: [string, number, boolean]
tuple = ['a', 2, false]
tuple = [2, 'a', false] //会报错误类型对不上
tuple = ['a', 2] //会报错误因为少了个元素

上面我们定义了一个元祖 tuple，它包含了三个元素,每个元素都是固定的.当我们为 tuple 赋值的时候,各个位置上的元素类型都要对应,元素个数也要一致

我们还可以给单个元素赋值

tuple[1] = 3

元祖的序号也是从 0 开始的,因为第二个类型是 number,所以我们赋值 3 没有问题

(2) 枚举

enum 枚举类型就是比如我们要定义一组角色，每一个角色用一个数字代表，就可以用枚举类型来定义

enum Roles{
  SUPER_ADMIN,
  ADMIN,
  USER
}

上面定义枚举类型里面有三个值,TypeScript 会为他们的每个值都编号,默认从 0 开始,依次排列，所以它们对应的值是

enum Roles{
  SUPER_ADMIN =0,
  ADMIN=1,
  USER=2
}

当我们使用的时候就可以使用名字而不需要记住数字和名称的对照关系

const superAdmin = Roles.SUPER_ADMIN
console.log(superAdmin) // 0

要是不想从 0 开始也可以从任何数开始

enum Roles{
   SUPER_ADMIN =1,
  ADMIN=3,
  USER=7
}

通过名字 Roles.SUPER_ADMIN 可以获取到它对应的值 1,同时你也可以通过值获取到它的名字,以上面任意数值这个例子

console.log(Roles[3]) //ADMIN

(3) Any

有的时候我们不能清楚的知道数据的类型这个时候就要用到 any 类型，即任何类型

let value: any
value = 123
value = 'abc'
value = false

我们定义变量 value 制定他的类型为 any,接下来赋予任何类型的值

我们还可以在定义数组类型的时候使用 any 来指定数组中任意的值

let arr: any[] = [1, 'a', true]

(4) void

void 和 any 正相反,any 表示任意类型,而 void 表示没有任意类型,就是什么类型都不是.在这里我们定义函数,函数没有返回值的时候会用到

const consoleText = (text: string): void => {
  console.log(text)
}

这个函数没有返回任何的值,所以他的返回类型是 void，现在你只需要知道 void 表达的含义即可

void 类型的变量只能赋值为 undefined 和 null,其他类型不能赋值给 void 类型

(5) never

never 类型指的是那些永不存在的值的类型,它是那些会抛出异常或根本不会有返回值的函数表达式的返回值类型,当变量被永不为真的类型保护所约束,该变量是 never 类型

例如

const errorFunc = (message: string): never => {
  throw new Error(message)
}

这个 errorFunc 函数总是会抛出异常,所以他的返回值类型是 never,用来表明他的返回值是永远不存在

const infiniteFunc = (): never => {
  while (true) {}
}

infiniteFunc 也是根本不会有返回值的函数,它和之前讲 void 类型的 consoleText 函数不同,consoleText 函数没有返回值,是我们在定义函数的时候没有给他返回值,而 infiniteFunc 是死循环根本不会有返回值。所以二者还是有区别的

never 可以赋值给任何类型。但是任何类型不能赋值给 never

let neverVariable = (() => {
  while (true) {}
})()
neverVariable = 123 // error 不能将类型"number"分配给类型"never"

(6) unknow 类型表示未知类型

从结果上看 unknow 和 any 类型差不多。但是 unknow 类型的值是不可以随便操作的.

拓展

(1) 交叉类型

交叉类型就是取多个类型的并集,并用&符号定义,被&符连接的多个类型构成一个交叉类型.表示这个类型同时具备这几个链接起来的类型的特点(类似与)


const merge = <T, U>(arg1: T, arg2: U): T & U => {
  let res = <T & U>{};
  // 这里指定返回值的类型兼备T和U两个类型变量代表的类型的特点
  res = Object.assign(arg1, arg2);
  // 这里使用Object.assign方法，返回一个合并后的对象
  return res;
};
const info1 = {
  name: "lison"
};
const info2 = {
  age: 18
};
const lisonInfo = merge(info1, info2);

console.log(lisonInfo.address); // error 类型“{ name: string; } & { age: number; }”上不存在属性“address”

可以看到传入的两个参数分别带有 name 和 age 的两个对象,所以它俩的交叉类型要求返回的对象既有 name 属性也得有 age 属性

(2) 联合类型

联合类型的要求只要符合联合类型中任意一种类型即可，他用| 来定义.当我们的程序具有多样性，元素类型不唯一的时候,使用联合类型(类似或)

const getLength = (content: string | number): number => {
  if (typeof content === 'string') return content.length
  else return content.toString().length
}
console.log(getLength('abc')) // 3
console.log(getLength(123)) // 3