基本类型约束

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

如何进行类型约束

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

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

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

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

源代码和编译结果的差异

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

基本类型

number：数字
string：字符串
boolean：布尔
数组
object: 对象
null 和 undefined

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

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

其他常用类型

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

配合类型保护进行判断

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

void类型：通常用于约束函数的返回值，表示该函数没有任何返回
never类型：通常用于约束函数的返回值，表示该函数永远不可能结束
字面量类型：使用一个值进行约束
元祖类型（Tuple）: 一个固定长度的数组，并且数组中每一项的类型确定
any类型: any类型可以绕过类型检查，因此，any类型的数据可以赋值给任意类型

类型别名

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

type 类型名 = ...

函数的相关约束

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

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

案例

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

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

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

function printValues(obj: object) {
    const vals = Object.values(obj)
    vals.forEach(v => console.log(v));
}

printValues({
    name:"afd",
    age:33
})

let n:string = undefined;

n.toUpperCase();

let name: string | undefined;

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

function throwError(msg: string): never {
    throw new Error(msg);
}

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

let gender: "男" | "女";

gender = "女";

gender = "男";

let arr: []; //arr永远只能取值为一个空数组

let user: {
    name:string
    age:number
}

user = {
    name:"34",
    age:33
}

let tu: [string, number];

tu = ["3", 4];

let data:any = "sfdsdf";

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

let u:User

u = {
    name:"sdfd",
    gender:"男",
    age:34
}

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

// /**
//  * 得到a*b的结果
//  * @param a 
//  * @param b 
//  */
function combine(a:number, b:number):number;
// /**
//  * 得到a和b拼接的结果
//  * @param a 
//  * @param b 
//  */
function combine(a:string, b:string):string;
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("a","b")

function sum(a: number, b: number, c: number) {
    if (c) {
        return a + b + c;
    }
    else {
        return a + b;
    }
}

sum(3, 4);

sum(3, 4, 5);

学习整理,侵权联系删除,感谢阅读,希望对大家有帮助!

TypeScript基本类型约束 看这一篇就够了