一般类型声明

  1. const a:string = 'string'
  2. const b:number = 123
  3. const c:boolean = true
  5. function sum(a:number,b:number):number{
  6.     console.log(a+b)
  7.     return a+b //声明返回值类型
  8. }
  9. sum(123,321)

使用字面量声明类型

  1. //使用字面量声明类型
  2. let a:10
  3. a=10
  4. a=11 //报错

联合类型

｜表示或

  1. //联合类型
  2. let b : 'male'|'female' //竖线是或的意思
  3. b='male'
  4. b='female'
  5. b='hello' //报错
  7. let c:number|string
  8. c=10
  9. c='hello'
  10. c=true//报错

& 表示且

  1. //&表示且
  2. let k:{name:string}&{age:number}
  3. k={
  4.     name:'zz',
  5.     age:18
  6. }
  7. k={
  8.     name:'zz',
  9. }//报错

类型别名type

用于类型非常长的时候，简化类型使用

  1. //类型别名
  2. type myType = string
  3. let l : myType

any类型

any 表示任意类型，一个变量设置类型为any后相当于该变量关闭了TS的类型检测
使用TS时，不建议使用any类型

  1. //any 表示任意类型，一个变量设置类型为any后相当于该变量关闭了TS的类型检测
  2. //使用TS时，不建议使用any类型
  3. let d:any
  4. //声明变量如果不指定类型，则TS解析器会自动判断变量的类型为any（隐式any）
  5. let s:string
  6. s=d //d的类型是any，他可以复制给任意变量

unknown类型

unknown表示未知类型的值

  1. //unknown表示未知类型的值
  2. let e:unknown
  3. e=10
  4. e='str'
  5. e=true
  6. c=e//报错 不能将unknown类型的值赋值给其他类型
  7. //unknown实际上就是一个类型安全的any

将unknown赋值给其他值的方法

  1. //使用类型检查
  2. if(typeof e === 'string'){
  3.     c=e
  4. }

类型断言,可以用来告诉解析器变量的实际类型

  1. s = e as string
  2. s = <string>e

void类型

void 用来表示空，以函数为例，就表示函数没有返回值

  1. //void 用来表示空，以函数为例，就表示函数没有返回值
  2. function fn():void{
  3.     return 123 //报错
  4. }

never类型

never 表示永远不会返回结果

  1. //never 表示永远不会返回结果
  2. function fn2():never{
  3.     throw new Error('报错')
  4. }

object类型

  1. let a:object
  2. a={}
  3. a=function(){}
  4. a=[]

{}用来指定对象中可以包含哪些属性，值必须要和{}中的属性完全一样
语法：{属性名：属性值，属性名：属性值}
在属性名后面加上？表示属性是可选的

  1. let b:{name:string}
  2. b={} //报错
  3. b={name:'zs'}
  4. b={name:'vs',age:10} //报错
  6. let c:{name:string,age?:number}
  7. c={name:'zz'}
  8. c={name:'cc',age:10}

[propName:string]:any 表示任意类型的属性（propName可以是任意值）

  1. let d:{name:string,[propName:string]:any}
  2. d={name:'cc',age:10,gender:'男'}

设置函数结构的类型声明
语法：（形参：类型，形参：类型，…）=>返回值类型

  1. let e:(a:number,b:number)=>number
  2. e=function(a:number,b:number):number{
  3.     return 10
  4. }
  5. e=function(a:string,b:number):number{
  6.     return 10
  7. } //报错

array类型

数组类型声明：
类型[]
Array<类型>

  1. //string[]表示字符串数组
  2. let f: string[]
  3. f = ['a', 'b', 'c']
  4. f = [1, 2, 3, 'a'] //报错
  5. //number[],Array<number>表示字符串数组
  6. let g: number[]
  7. g = [1, 2, 3]
  8. let h: Array<number>
  9. h = [1, 2, 3]

tuple元组类型

元组，元组就是固定长度的数组

  1. //元组，元组就是固定长度的数组
  2. let i:[string,string]
  3. i=['a','b']
  4. i=['a',123] //报错

enum枚举类

  1. enum Gender{
  2.     Male=0,
  3.     Femal=1
  4. }
  6. let j:{name:string,gender:Gender}
  7. j={
  8.     name:'zz',
  9.     gender:Gender.Male
  10. }
  11. console.log(j.gender === Gender.Male)