常见的三种值类型
数字类型
// 申明一个数字类型的值
let a: number
a = 10
字符串类型
// 申明一个字符串类型的值
let b: string = 'hello'
布尔类型
// 申明一个bool类型的值
let c: boolean = true
PS：类型注释

冒号 + 类型的叫类型注释

即: string这种叫类型注释

其他常见类型
字面量类型
// 字面量进行类型申明(字面量：即就是这个值本身)
let aa: 10
// a修改为其他值就会报错
aa = 11

// 实际开发中很少这么用，但是我们可以这么用
// 申明一个变量等于男或者女
let sex: 'male' | 'female'
// 我们使用的时候就可以赋值其中一个值，赋值其他值就会报错
sex = 'male'
sex = 'female'
sex = 'hello'
联合类型
// | 线可以用来连接多个类型（联合类型）
// 除了用在字面量中，常规的使用当中有的更多
let bb: boolean | number
bb = true
bb = 123
// 赋值字符串，就错了
bb = 'hi'
any类型
// 申明任意类型的数据
// any表示任意类型，一个变量设置为any后相当于对该变量关闭了TS的类型检测
let cc: any
cc = 123
cc = true
cc = 'hi'

// 隐式any，即申明，但是不设置类型，如下
let dd
dd = 123
unknown类型
// unknown 表示未知类型
let ee: unknown
ee = 123
ee = true
ee = 'hi'
any和unknown比较
// 那么any和unknown有什么区别呢？
// any可以赋值给任何变量
let ff: string
ff = cc
// unknown实际上就是一个类型安全的any
// unknown类型的变量不能直接赋值给其他变量
let gg: string
gg = ee
// 如何处理这种报错呢？
// 1.类型判断
if(typeof ee === 'string') {
    gg == ee
}
// 2.类型断言(意思是，ee就是一个string，你就放心用了)
gg = ee as string
gg = <string>ee
PS：类型断言
  • 断言语法
  • 1.变量 as 类型
  • 2.<类型>变量
void类型
// void用来表示空，以函数为例，表示没有返回值的函数
function fn():void {
    console.log(11111)
}
// never表示永远不会返回结果
function fn2(): never {
    throw new Error('出错了')
}
object类型
// object表示一个js对象
let obj: object
obj = {}
obj = function() {

}
// js中对象太多了，一般不像上面这样申明，那么我们在上面时候用这种形式呢？
// 比如我们申明一个变量，但是我们希望变量中包含某个值时
let obj2: {name: string}
// 这样是正确的
obj2 = {name: '景天'}
// 这样就会报错
obj2 = {}
// 写多了也会报错
obj2 = {name: '景天',age:18}

// 那么我们就是要age，而且age也不确定有没有，怎么写呢？
let obj3: {name: string,age?: number}
// 这样都正确
obj3 = {name: '景天'}
obj3 = {name: '景天',age:18}

// 但是实际开发中，我们还会有不确定有多少其他属性值，怎么处理呢？
let obj4: {name: string, [propName:string]:any}
// 这样的话，除了要求的值，其他随便写不写，写什么都无所谓了
obj4 = {
    name: '景天',
    age: 18,
    c: true
}
函数
// 如何设置函数的类型申明呢？
// 这表示函数两个参数，都是number类型，返回值也是number类型
let fn1: (a:number,b:number) => number
fn1 = function(n1,n2) {
    return n1 + n2
}

// 函数中使用另一种类型限制
// ): number是限制返回值的类型的
function add(a: number,b:number): string {
    return String(a + b)
}
数组
/*
    array,两种申明方式（这也是一种泛型的写法）
    1. 类型[]
    2. Array<类型>
*/
// 纯字符串数组
let arr: string[]
arr = ['a','b','c']
// 纯数字数组
let arr2: Array<number>
arr2 = [1,2,3]
元组
// tuple(元组)：固定长度的数组
let yuanzu: [string,number]
yuanzu = ['111',222]
枚举
// enum: 枚举
// 申明一个枚举类
enum Gender {
    male = 1,
    female = 0
}

let hh: {name: string,gender: Gender}
hh = {
    name: '景天',
    gender: Gender.male
}
类型的别名
// 类型的别名
type myType = string
// 这相当于还是string
let ii: myType

// 但是这样的话，通常没什么意义，而我们用字面量类型的时候，有时候可以使用
type jjType = 1 | 2 | 3 | 4 | 5 | 6 
// 这样无论我们多少个地方使用，都可以直接用了
let jj: jjType
let kk: jjType
let ll: jjType

// 任何类型都可以有别名
// 比如object
type obj = {
    x:number,
    y:number
}

// 别名的扩展
// 一个新的obj1在上面的obj的基础上扩展
type obj1 = obj & {
    z: number
}
JS在ES6以后加的两个类型
bigint
  • 意为比较大的整数
  • ES2020以后添加
// 括号里面可以是number 和 string
const bigNumber: bigint = BigInt(123)
const bigNumber2: bigint = 456n

console.log(bigNumber)   // 123n，打印发现是有个n在数字后面，但是我们使用值得时候，是没有n的
console.log(bigNumber2)  // 456n
symbol
  • 意为全局唯一引用
const firstName = Symbol('name')