【TypeScript】TS类型声明（二）_ts数组声明

专栏介绍

TypeScript从入门到实践专栏是博主在学习和工作过程中的总结实用性非常强欢迎订阅哦学会TS不迷路。

TS系列	标题
基础篇	TS入门一
基础篇	TS类型声明二
基础篇	TS接口类型三
基础篇	TS交叉类型&联合类型四
基础篇	TS类型断言五
基础篇	TS类型守卫六
进阶篇	TS函数重载七
进阶篇	TS泛型八
进阶篇	TS装饰器九

前言

本文主要讲解TypeScript的基本数据结构主要包括JS基本数据类型以及TS特有的数据类型。

• JS基本数据类型 string、number、null、undefined、boolean、array
• TS特有的数据类型tuple元祖、enum枚举、any、unknow、never

注意 node 不能直接执行ts文件需要先将ts编译成js然后再执行js

一、 string、number、null、undefined、boolean类型声明

• JS普通写法如下

 let myName = "zhangsan";
 let count = 1;
 let a = null;
 let b = undefined;
 let visiable = false;

• TS写法如下
  不能更改它们的变量类型否则会直接报错

let myName: String = "zhangsan";
let count: Number = 1;
let a: null = null;
let b: undefined = undefined;
let visiable: boolean = false;

• 编译成TS后如下

var myName = "zhangsan";
var count = 1;
var a = null;
var b = undefined;
var visiable = false;

• 编译后为什么let会变成var呢
  es6是规范 但是还有很多浏览器不支持 所以编译完之后都是转义成es5 es5没有let。并且需要在tsconfig.json中配置如下

{
  "compilerOptions": {
    "target": "ES5",  
   }
}   

在这里插入代码片- 错误示范

let myName: String = "zhangsan";
myName = true;//Error:Type 'true' is not assignable to type 'String'.

二、 array、tuple元组

JS数组和TS数组之间的区别

JS中的数组可以是字符串、数字等其他类型的数据而TS中的数组是纯数字类型(number)的集合如果在TS中定义包含多个类型的数组那就是元组。

JS写法如下

 let arr = ['语文','数学']

TS声明数组有多种方式具体如下

1数组的数据类型一致

• Array<>声明一个数组数组类型为<>中定义的类型比如Array<string>

//声明一个数组并且数组中的数据类型都是字符串
let arr:Array<string> = ['语文','数学']  
let arrA:string[] =  ['语文','数学']  
//注意数组这样写会报错
let arr:Array= ['语文','数学']  //error

• string[]声明一个数组数组类型为[]前定义的类型比如number[]

let arr:string[] = ['a']

2数组的数据类型不一致

• 联合数据声明比如(string|number)[]声明一个数组数组类型为字符串、数字。数组中数据的类型可以不随定义的类型位置的限定。

let arr:(string|number)[] = ['a',1]
let arrB:(string|number)[] = ['a',11'b']
let arrC:(string|number)[] = [11'b','c']
let arrC:(string|number)[] = [11]
//或者这样声明
let arrD: Array<string | number> = [1, 12, 'a']

3数组的数据类型任意

let arr:any[] = ['a',1,true,null]
//或者这样声明
let arrE:Array<any> = ['a',1,true,null]

4限制类型和长度的元祖数组

tuple元祖是固定数量的不同类型的元素的组合比如[number, string]。数组中数据的位置、类型以及个数必须要和声明的类型、声明类型的位置、声明类型的个数保持一致否则就会报错。

let tupleArr: [number, string] = [1, '数学']
let tupleArrA: [number, string] = [1, '数学',1]//error
let tupleArrA: [number, string] = ['数学',1]//error

三、enum枚举

枚举主要分为数字类型枚举、字符串类型枚举、异构。
语法enum + 变量名意思是定义了一个叫做“变量名”的枚举类型
优点定义一些常量可以清晰地表达意图或创建一组有区别的用例。

1数字型枚举

• 含义枚举成员都是number类型如果没有对枚举对象中的枚举成员赋值那么会默认从枚举对象中的第一个枚举成员的值是0并依次递增。
• 具有以下特点
  • 反向映射
  • 枚举成员的值可以不用初始化

enum Value {
	A,
	B,
	C,
	D,
	E,
	F
}

let value: Value = Value['A']
let valueName = Value[0]
console.log(value)//0
console.log(valueName)//A

以上可知我们既可以取到枚举成员的属性名也能取到枚举成员的属性值它们之间是相互映射的。

• 修改枚举成员的默认值

enum Value {
	A,
	B,
	C=8,
	D,
	E,
	F
}

let value: Value = Value['E']
let valueNameA = Value[8]
let valueNameB = Value[9]
console.log(value)//10
console.log(valueNameA)//C
console.log(valueNameB)//D

我们可以看到我们改变枚举成员的默认值的时候后面枚举成员的默认值也随着前面的改变而改变。我们来看一下上面编译成JS后的样子具体如下所示

var Valuedemo;
(function (Valuedemo) {
    Valuedemo[Valuedemo["A"] = 0] = "A";
    Valuedemo[Valuedemo["B"] = 1] = "B";
    Valuedemo[Valuedemo["C"] = 8] = "C";
    Valuedemo[Valuedemo["D"] = 9] = "D";
    Valuedemo[Valuedemo["E"] = 10] = "E";
    Valuedemo[Valuedemo["F"] = 11] = "F";
})(Valuedemo || (Valuedemo = {}));
var valueA = Valuedemo['A'];
var valueNameA = Valuedemo[8];
console.log(valueA);
console.log(valueNameA);

2字符串类型枚举

含义枚举成员类型都是字符串
需要注意以下几个方面

• 字符串枚举没有反向映射如果进行反向映射的话取得的值时undefined
• 字符串枚举没有递增需要对每一个字符串枚举类型成员进行赋值即必须具有初始化表达式

enum StringValue {
	A = 'A',
	B = 'B',
	C = 'C',
	D = 'D',
	E = 'E',
	F = 'f'
}

let stringValueVal = StringValue['A']
console.log(stringValueVal)//A

以下是错误示范不能对字符串类型枚举进行反向映射

let stringValueNameA = StringValue['f']
let stringValueNameB = StringValue[0]
console.log(stringValueNameA)//undefined
console.log(stringValueNameB)//undefined

3异构

含义枚举类型包括字符串类型和数字类型
注意含有字符串值成员的枚举中不允许使用计算值具体意思就是当枚举对象中存在有value是字符串的枚举成员的时候不能将其他枚举成员的value设置为计算值。

enum Enum {
	A,
	B,
	C = 'C',
	D = 'd',
	E = 9,
	F
}
console.log(Enum['10'])//F
console.log(Enum['C'])//C
console.log(Enum['A'])//o
console.log(Enum['d'])//undefined
console.log(Enum['D'])//d
console.log(Enum[9])//E
console.log(Enum[0])//A

上面的TS编译成JS后的样子如下所示

var Enum;
(function (Enum) {
    Enum[Enum["A"] = 0] = "A";
    Enum[Enum["B"] = 1] = "B";
    Enum["C"] = "C";
    Enum["D"] = "d";
    Enum[Enum["E"] = 9] = "E";
    Enum[Enum["F"] = 10] = "F";
})(Enum || (Enum = {}));

我们用普通方法来实现异构枚举demo如下所示

enum Enum {
	A,
	B,
	C = 'C',
	D = 'D',
	E = 9,
	F
}

怎么实现以上的枚举呢具体如下

let Enum;
(function (Enum) {
	Enum[0] = 'A';
	Enum[1] = 'B';
	Enum[9] = 'E';
	Enum[10] = 'F';
	Enum['A'] = 0;
	Enum['B'] = 1;
	Enum['C'] = 'C';
	Enum['D'] = 'D';
	Enum['E'] = 9;
	Enum['F'] = 10;
})(Enum || (Enum = {}))

以上我们看出依然是数字类型的枚举成员可以进行反向映射字符串类型的枚举成员不能反向映射。

注意以下是错误用法因为含有字符串值成员的枚举中不允许使用计算值

enum Enum {
	A,
	B = 3*6,
	C = 'C',
	D = 'd',
	E = 9,
	F
}

4枚举成员的值的两种形式-计算值和常量

枚举对象中成员的value有两种形式计算值或者常量怎么区分是计算值和常量呢我们可以通过枚举成员表达式来判断只要是枚举成员是表达式则为常量。枚举成员表达式的判断条件如下

• 枚举表达式字面量主要是字符串字面量或数字字面量
• 对之前定义的常量枚举成员的引用
• 带括号的常量枚举表达式
• 一元运算符 ++、 –
• 常量枚举表达式是二元运算符 + 、-、*、/、%、<<、>>、&、｜、^的操作对象。注意如果求值后值为NaN或Infinity那么会在编译阶段报错。

常量demo如下

enum constantEnum{
  num, //枚举表达式字面量
  age = num, //引用常量枚举成员
  count = 2 << 1, //枚举表达式字面量参与二元运算符
  numB = 30 | 2,
  numA = 10 + 29
}

计算值demo如下所示

let name = 'zhsngasn'
enum calculationEnum{
  nameLen = name.length, 
  num = Math.random() * 10
}

四、any任意类型

声明变量类型为any时

• 编译时会绕过所有类型的检测直接通过编译阶段的检查
• 可以任意访问属性的方法和属性
• any类型可以赋值给任意类型
• 如果变量初始没有定义类型默认为any经过赋值后TS会根据赋值类型来标识变量的类型

let anyValue: any = 1;
//修改变量类型
anyValue = true;
//赋值给任意类型比如boolean
let booleanValue: boolean = anyValue;
console.log(booleanValue)//true

any在使用过程中就像一个潘多拉魔盒即使使用了断言也丧失了在静态类型检查阶段发现错误的可能性。

五、unknow未知类型

声明变量类型为unknow时

• 安全性更高
• 它用于描述类型不确定的变量,这与any类型相似但更安全因为对未知值做任何事情都是不合法的
• unknown类型只能赋值给any和unknown类型any类型可以赋值给任意类型
• unknownnever 都不允许执行变量的方法以及访问内部属性
• 在unknown没有被断言或细化到一个确切类型之前unknown不可以赋值给其它类型除了它自己和any外当然也都是不允许在其上进行任何操作的。

let unknownValue: unknown;
//对变量进行任意赋值
unknownValue = true;
unknownValue = 'sss';
unknownValue = 1;
//赋值给unknown类型的变量
let testValue1: unknown = unknownValue;
//赋值给any类型的变量
let testValue2: any = unknownValue;

错误示范

//赋值给boolean类型的变量报错因为unknown类型只能赋值给unknown、any
let testValue3: boolean = unknownValue;//报错

虽然可以对unknown类型的变量进行任意赋值但是却不能执行任何操作如何解决这个问题呢可以缩小unknown类型。具体如下所示

type func = ()=> unknow
let test = func();
if(test instanceof func){
//执行逻辑
}

我们可以用断言缩小未知范围或者可以用instanceof来缩小变量的类型强制让ts编译器相信我们在做什么操作

六、void空类型

声明对象类型为void时

• 返回为空值

function func(): void { }

声明一个变量为void 时

• 只能将它赋值为 undefined 和 null因此在定义函数的返回值为void时也可return undefined/null

let voidValue1: void = undefined;
let voidValue2: void = null;

七、never不存在的值类型

never类型表示永不存在的值的类型。具有以下特点

• never类型是所有类型的子类型即never类型可以赋值给任何类型。
• 其他任何类型均不是never类型的子类型即其他类型均不可赋值给never类型除了never本身。即使any类型也不可以赋值给never类型。
• 返回类型为never的函数中其终点必须是不可执行的例如函数过程中抛出了错误或者存在死循环。
• 变量也可以声明为never类型但其不能被赋值

设置变量类型为never表示永远不能执行完或者永远Error具体示例如下

• 函数中出现了死循环永远不能执行完因此其函数类型为() => never

function infiniteLoop(): never {
	while (true) { }
	return 'over'
}

• 函数中出现报错不会执行到return over因此其函数类型为() => never

function errFunc(): never {
	throw new Error()
	return 'over'
}