关于typescript:TypeScript中的常用的数据类型

常见的三种值类型

数字类型

// 申明一个数字类型的值
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')