TypeScript快速上手学习笔记-第四篇——TypeScript类型

类型概览

TS中有如下数据类型：

number——数字类型

let num:number;
num=10;

let num:number=10;
num=20;

let num=10;
num=20;

function fun_num(a:number,b：number):number{
	return a+b;
}

string——字符串类型

let str:string;
str='ts';

let str:string='js';
str='ts';

let str='js';
str='ts';

function fun_str(a:string,b：string):string{
	return a+b;
}

boolean——布尔类型

let bo:boolean;
bo=true;

let bo:boolean=true;
bo=false;

let bo=true;
bo=false;

function fun_bo(a:boolean):boolean{
	return a;
}

字面量——数据本身

设置字面量，变量值只能是设置的字面量的值或者类型

//只能是10
let a:10;
a=10;
a=11;//会报错

//只能是10或者'ts'
let b:10 | 'ts';
b=10;
b='ts';
b='js';//会报错

//只能是数字类型
let c:number;
c=10;
c='js';//会报错

//只能是数字类型或者布尔型
let d:number | boolean;
d=10;
d=true;
c='js';//会报错

any——任意类型

any表示任何类型,一个变量设置了any相当于对该变量关闭了TS类型检测,使用TS不建议使用any

//any表示任何类型,一个变量设置了any相当于对该变量关闭了TS类型检测,使用TS不建议使用any
let e:any;
e=10;
e="ts";
e=true;

需要注意：（隐式any）如果声明变量的时候不指定变量类型，TS解析器会自动判断成any

//如果声明变量的时候不指定变量类型，TS解析器会自动判断成any，这是隐式any
let f;
f=10;
f="ts";
f=true;

unknown——未知类型

表示声明类型未知的变量，效果与any相似，但实际上比any安全，是一个类型安全的any

//表示声明类型未知的变量，效果与any相似，但实际上比any安全，是一个类型安全的any
let g:unknown;
g=10;
g="ts";
g=true;

any与unknown的区别

any可以赋值给任意类型的变量，存在安全隐患

let h:string;
//any可以赋值给任意类型的变量，存在安全隐患
let e:any;
e="ts";
h=e;

unknown因为类型未知无法赋值给固定类型的变量，较为安全

let h:string;
//unknown因为类型未知无法赋值给固定类型的变量，较为安全
let g:unknown;
g="ts";
h=g;//会报错

unknown赋值的解决方法

//解决方法
//类型判断
if(typeof g==='string'){
  h=g;
}

//类型断言，告诉tS解析器变量的实际类型
h=g as string;
h=<string>g;

void——返回空值或者不返回

void 用来表示空，主要运用在函数，表示没有返回值的函数

//void 用来表示空，以函数为例，表示没有返回值的函数
function func_1():void {

}

function func_1():void {
  return;
}

function func_1():void {
  return null;
}

function func_1():void {
  return undefined;
}

never——不能是任何值，不进行返回操作

function fun_2():never {//正确
  throw new Error('报错了');
}

function fun_2():never {//会报错
}

function fun_2():never {//会报错
  console.log("xxx");
}

object——对象类型

object表示一个对象，分为数据对象和函数对象
基本用法如下（不常用）：

//object表示一个对象
let i:object;
i={};
i=function () {
}

object常用语法
1-数据对象
{}用来表示指定对象可以包含哪些属性
语法{属性:属性值，属性:属性类型}
其中属性后加上？表示属性可选

let j:{
  name:string,
  age?:number,//age可选
};
j={
  name:"ts",
  age:10,
};
j={
  name:"ts",
};

思考，如果对象中存在不确定的属性怎么办？

//以下表示对象必须包含name且类型为string,其他属性随意
let k:{
  name:string,
  [propname:string]:unknown,
};
k={
  name:"js",
  age:10,
};
k={
  name:"ts",
  age:10,
  desc:'TypeScript'
};

设置函数对象类型

//语法:(形参：类型,...)=>返回值类型
let fun_k:(a:number,b:number)=>number
fun_k=function (m,n) {
  return m+n;
};

array——对象类型

数组声明表示：1-类型[]，2-Array<类型>

let l:number[];
l=[1,2,3,4,5];
let m:Array<number>;
m=[1,2,3,4,5];

let l:string[];
l=['ts','js'];
let m:Array<string>;
m=['ts','js'];

let l:boolean[];
l=[true,false];
let m:Array<boolean>;
m=[true,false];

tuple——元组类型

元组是一个长度固定的数组，元组语法[类型,类型,类型,…]

//元组是一个长度固定的数组
//语法[类型,类型,类型,..]
let n:[string,number,boolean];
n=['ts',10,true];

enum——枚举类型

枚举类型用于声明一组命名的常数，当一个变量有几种可能的取值时，可以将它定义为枚举类型。TS中需要实现写好一个枚举对象，之后时候，将类型引用为这个枚举对象即可。

//枚举
enum Gender {
  Male,
  Female,
};
let o:{
  name:string,
  gender:Gender,
};
o={
  name:"ts",
  gender:Gender.Male,
};
console.log(o.gender===Gender.Male);

&的使用

&表示同时，常用在对象类型，表示必须同时包含的意思

let p:{name:string}&{age:number};
p={//不包含age，会报错
  name:"ts"
};
p={//不包含name，会报错
  age:10
};
p={//正确
  name:"ts",
  age:10,
};

效果于以下写法一样

let q:{
  name:string,
  age:number,
};
q={
  name:"ts",
};
q={
  age:10,
};
q={
  name:"ts",
  age:10,
};

类型的别名

type mytype=string;
let r:mytype;
r=10;//报错
r='aa';

type mytype=0|1|2|3|4||5;
let r:mytype;
r=10;//报错
r=1;