基本类型约束

TS是一个可选的静态的类型系统

如何进行类型约束

仅需要在变量、函数的参数、函数的返回值位置加上:类型

ts在很多场景中可以完成类型推导

any: 表示任意类型，对该类型，ts不进行类型检查

小技巧，如何区分数字字符串和数字，关键看怎么读？如果按照数字的方式朗读，则为数字；否则，为字符串。

源代码和编译结果的差异

编译结果中没有类型约束信息

基本类型

number：数字

let num: number = 123;

string：字符串

let str: string = '123';

boolean：布尔

function isOdd(n: number): boolean {
   return n % 2 === 0;
}

数组

let nums: number[] = [3, 4, 5]

let nums: Array<number> = [3, 4, 5];

object: 对象

let u: object;
u = {
    name: 'aa',
    age: 16
}

// 函数中对参数约束
function printValues(obj: object) {
    const vals = Object.values(obj)
    vals.forEach(v => console.log(v));
}

null 和 undefined

null和undefined是所有其他类型的子类型，它们可以赋值给其他类型

在tsconfig.json中通过添加strictNullChecks:true，可以获得更严格的空类型检查，null和undefined只能赋值给自身。

其他常用类型

联合类型：多种类型任选其一

let name: string | undefined;

配合类型保护进行判断

类型保护：当对某个变量进行类型判断之后，在判断的语句块中便可以确定它的确切类型，typeof可以触发类型保护。

typeof只能触发简单类型的保护，复杂类型不可以

if(typeof name === 'string'){
    // 触发类型保护
}

void类型：通常用于约束函数的返回值，表示该函数没有任何返回

function printMenu(): void{
    console.log("1. 登录")
    console.log("2. 注册");
}

never类型：通常用于约束函数的返回值，表示该函数永远不可能结束

// 抛出错误消息
function throwError(msg: string): never {
    throw new Error(msg);
    
    console.log('1234'); // 打印是永远不会运行的
}

function alwaysDoSomething(): never {
    while (true) {
        //...
    }
}

字面量类型：使用一个值进行约束

// 对字符串进行字面量约束
let gender: "男" | "女";
gender = "女";
gender = "男";

// 对数组进行字面量约束
let arr: []; // arr永远只能取值为一个空数组

// 对对象进行字面量约束
let user: {
    name:string
    age:number
}
user = {
    name: "123",
    age: 18
}

元祖类型（Tuple）: 一个固定长度的数组，并且数组中每一项的类型确定

// 告诉变量只能有两项，第一项必须为字符串，第二项必须为数字
let arr: [string, number];

any类型: any类型可以绕过类型检查，因此，any类型的数据可以赋值给任意类型

let data:any = "sfdsdf";
let num:number = data;

类型别名

对已知的一些类型定义名称type 类型名 = ...

type Gender = "男" | "女"
type User = {
    name: string
    age: number
    gender: Gender
}

let u:User
u = {
    name: "123",
    gender: "男",
    age: 18
}

function getUsers(g:Gender):User[] {
    return [];
}

函数的相关约束

函数重载：在函数实现之前，对函数调用的多种情况进行声明

// 函数重载，明确告诉TS，使用同一个函数名称对函数进行约束 
function combine(a:string, b:string):string;
function combine(a:number, b:number):number;

// 如果a,b都为数字返回其相乘结果；若a,b为字符串得到a和b拼接的结果
function combine(a: number | string, b: number | string): number | string {
    if (typeof a === "number" && typeof b === "number") {
        return a * b;
    }
    else if (typeof a === "string" && typeof b === "string") {
        return a + b;
    }
    throw new Error("a和b必须是相同的类型");
}


const result = combine('hahah' ,123); // a和b必须是相同的类型
const result = combine("a","b"); // ab
const result = combine(2,3); // 6

可选参数：可以在某些参数名后加上问号，表示该参数可以不用传递。可选参数必须在参数列表的末尾。

function sum(a: number, b: number, c?: number) {
    // 也可触发类型保护
    if (c) {
         return a + b + c;
    }
    else {
         return a + b;
    }
}
const result = sum(1, 2, 3); // 6
const result = sum(1,2); // 3


// 也可使用默认参数(默认参数一定是可选参数)
function sum(a: number, b: number, c: number = 0) {
      return a + b + c;
}

对基本类型的学习后，将完成一个扑克牌小练习：

目标：创建一副扑克牌（不包括大小王），打印该扑克牌

基本类型检查