TS学习二 类型声明

TS 中 类型

任何声明的值 设置了 类型(type)，如果重新赋不同类型的值就会报错，虽然会编译，那使用 TS 将没有意义

string 字符串类型

// string 字符串类型
let myname: string = "文本"
console.log(myname)
myname = 123  // 报错 =>  赋值类型 不一样 

 number 数字类型   

// number 数字类型   

function sum1(a1: number, b1: number) {
  return a1 + b1
}
// 返回值也可以设置数字类型
function sum(a: number, b: number): number {
  return a + b
}
const c = sum(1, 3)

boolean 布尔类型

//boolean 布尔类型

let zt: boolean = false
zt = true

// 指定多个类型  用 | (或) 隔开 
let d: boolean | string // 只能是 布尔 或 字符串
let e: boolean | string | number
e= true
e=123
e='456'
e = [1,2,3] // => 报错

any 表示 任意类型

// any 表示 任意类型

// 不建议使用 any  =>  相当于对该变量关闭 TS 的类型检测

// any 可以赋值给任意变量

let f //隐式   等同于=>    let f:any
f = 11
f=[1]
f='123'
f = {obj:{}}

unknown  未知类型()  => 我们不知道它是什么类型

// unknown  未知类型()  => 我们不知道它是什么类型

// unknown 就是类型安全的 any

// unknown 类型的变量，不能直接赋值给其他变量

let weizhi: unknown
weizhi = 10
weizhi = "字符串"
weizhi = true

let zt = true
// zt为boolean类型，weizhi为unknown类型
zt = weizhi // 报错 => (不能将类型“unknown”分配给类型“boolean” )

 void 表示 空 类型

//  void 表示 空 类型

// 以函数为例  没有返回值的函数

function fn(): void {
  // return 123  // 报错=> 返回 其他 类型 就会报错
  return undefined // undefined  没有值  不会报错
}

never 表示 永远不会返回结果

// never 表示 永远不会返回结果

// 没有值

function fn1(): never {
  throw new Error("报错了")
}

object 表示 对象 类型

// object 表示 对象 类型

// {}  用来指定 对象中包含那些属性

// 语法：  {属性名：属性值，属性名：属性值}

let ob: object = {}
let ob1: { name: string }
// ob1 = {}  // 报错 => ob1 对象里面 必须有一个 name 属性，值为字符串
ob1 = { name: "玉皇大帝" }
ob1 = { name: "玉皇大帝1", age: 18 } // => 报错 声明的时候 只设置一个 name属性值为字符串

let ob2: { name: string; age: number }
ob2 = { name: "孙悟空" } // =>报错 声明的时候 必须有两个属性值 一个name为string，一个age为number

// 在属性后面 加一个 ？   表示 这个属性是可选的
let ob3: { name: string; age?: number }
ob3 = { name: "善财童子" }
ob3 = { name: "善财童子", age: 18 }

// [propName:string] => 任意属性名
// any => 任意类型
// [propName:string]:any  =>  任意类型的属性和值  => any 可换成 其他类型 来限制值
// [propName:string]:number => 任意属性 只能 是 number
let ob4: { name: string; [propName: string]: any }
ob4 = { name: "猪八戒", age: 18, show: true }

array 表示 数组 类型

let arr: string[] // => arr 表示 字符串数组

arr = [123, true, "小龙"] // => 报错 =>  arr 是一个数组 里面存放的都是 字符串
arr = ["123", "小龙"]

let arr1: number[] // => arr1 表示 数字数组

arr1 = [1, false, "小龙"] // => 报错 =>  arr 是一个数组 里面存放的都是 数字
arr1 = [1, 2, 3]

 tuple  => 元组  => 就是 固定 长度的 数组 => 固定长度数组

// tuple  => 元组  => 就是 固定 长度的 数组 => 固定长度数组

// 语法： [类型，类型，类型]

let arr2: [string, string]
arr2 = ["hello", "你好", "文本"] // => 报错 => arr2 类型 设置了 只能传 两个 字符串
arr2 = ["你好", "123"]

let arr3: [string, number]
arr3 = ["你好", 123]

 enum 枚举

// enum 枚举 
// male => 女  female => 男

enum Gender {
  male = 0,
  female = 1,
}

let i: { name: string; gender: Gender }
i = { name: "孙悟空", gender: Gender.male }

 & 表示 同时

let j: { name: string } & { age: number }

j = { name: "小三", age: 18 }

类型的别名

ype myType = string // => myType 为 string 的别名  => myType 为自定义的

let g: myType //  g 为 字符串类型

// 例  => 简化 类型的使用

// let k : 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8
// let p : 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8

type kType = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8
let k: kType
let p: kType