TS 中的类型

类型的使用

变量类型声明

定义一个数字类型的变量
ts
```
let a : number;
```
1

数据类型不能变更

let a : number;

a = 10;     // 没问题
a = 'hi';   // 报错

直接赋值写法

let a : boolean = true;
// -------- 或 -------- //
let a = true; 	// 若直接赋值，TS 会自动为变量绑定类型

函数中的类型声明

形参类型定义

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

console.log(sum(123, 456));     // 正常
console.log(sum(123, '456'));   // 报错

返回值类型定义

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

类型表

类型	描述	例
number	数字	1，-1
string	字符串	'h'，'hello'
boolean	布尔值	true、false
字面量
any	任意类型	*
unknown	类型安全的 any	*
void	没有值（或 undefined）
never	不能是任何值
object	对象	`{name: '', age: 20}`
array	数组	`[1,2,3,4,5]`
tuple	元素（TS 新增类型，固定长度的数组）	`[4,5]`
enum	枚举（TS 新增类型）	`enum{A,B}`

字面量（用的不多）

let a: 10;
a = 10;     // 没问题
a = 20;     // 报错

// -------- ---------//

let a: 'abc' | 'bcd';	// 这里表示变量 a 可以是 abc 或 bcd 两种类型
a = 'abc';  // 正常
a = 'bcd';  // 正常
a = 'hhh';  // 报错

any 与 unknown

any 表示任意类型，开发中尽可能少用。
unknown 表示未知类型。
若一个变量无法确认类型用 unknown 定义，不要用 any。

为什么不用 any?

let a: string;
let b: any;
b = true;

a = b;  // 不报错，但输出时影响 a 的预期结果

console.log(a);

反观 unknown

let a: unknown;
let b: string;
a = 'hello';
b = a;      // 报错

if (typeof a === 'string') b = a;   // 正常

类型断言
- 可以使用类型断言告诉编译器某个 unknown 定义的变量是什么类型。
- 语法
  ts
```
let a: unknown;
let b: string;

b = a as string;
// -------- 或 -------- //
b = <string> a;
```
  1
  2
  3
  4
  5
  6

void 与 never

void 与 never 一般用于函数的返回值
void 表示返回空或没有返回值（undefined）。
never 就比较牛逼了，虽然用的不多，他表示永远不会返回结果。大多数函数如果你没写 return 且在调用时输出函数返回值时，会打印 undefined，但有一部分函数打印返回值的时候啥也没输出，undifined 都没输出，这种函数返回值类型可以用 never 定义。

对象类型

直接定义
ts
```
let a: object;
let a: Function;
```
1
2

属性类型定义

let a: { name: string, age: number }

使用这种定义方式在赋值时，对象内只能有 name 和 age 两个属性。

let a: { name: string, age: number }

a = { name: 'iGma', age: 20 };      // 正确
a = { name: 'iGma' };               // 报错，没有 age 属性
a = { name: 'iGma', age: '20' };    // 报错，age 类型不匹配
a = { name: 'iGma', age: 20, gender: '男' };      // 报错，gender 属性没定义

可选属性定义

let a: { name: string, age?: number }

赋值时对象内必须有 name 属性，age 可有可无，但是不能有其他属性

let a: { name: string, age?: number }

a = { name: 'iGma' };               // 正确
a = { name: 'iGma', age: 20 };      // 正确
a = { name: 'iGma', age: 20, gender: '男' };      // 报错，gender 属性没定义

任意类型属性定义

let a: { name: string, [key: string]: unknown }

赋值时对象内必须有 name 属性，除此以为可添加任意类型属性

let a: { name: string, [key: string]: unknown }

a = { name: 'iGma' };               // 正确
a = { name: 'iGma', age: 20 };      // 正确
a = { age: 20 };                    // 报错，没有 name 属性

定义函数对象，限制形参类型及返回值类型

let sum: (a: number, b: number) => number;

sum = (a, b) => {
    return a + b;
}

数组类型

方式一：

let a: number[];
a = [1, 2, 3];  // 正确
a = ['a', 'b']; // 报错

方式二：

let a: Array<number>;
a = [1, 2, 3];  // 正确
a = ['a', 'b']; // 报错

元组类型

元组是定长的数组。

元组定义

let a: [number, string];
a = [1, 'a'];   // 正确
a = [1, 1];     // 报错：第二项类型错误
a = [1];        // 报错：缺少第二项
a = [1, 'a', 2];    // 报错：多了一项

枚举类型

枚举一般适用在若干情况的判断中，使用枚举类型分为以下两步：
- 定义枚举类
- 使用枚举

代码

enum State { A = '待支付', B = '支付成功', C = '支付失败' };
let order: { id: number, state: State };
order = { id: 230713, state: State.B };

if (order.state === State.B) {
    console.log('支付成功');
}

类型的逻辑运算

或运算：｜

let a: number | string;		// 此时 a 变量可以是数字类型也可以是字符串类型

与运算：&

let a: { name: string } & { age: number };
a = { name: 'iGma', age: 20 };  // 正确，两者都满足
a = { name: 'iGma' };           // 报错：缺少 age 属性
a = { age: 20 };                // 报错：缺少 name 属性

类型别名

使用 type 关键字可以自定义一个类

代码

type school = {
    name: string,
    address: string
}

type student = {
    id: number,
    phone: number
}

let user: student & school;

user = {
    id: 230713,
    phone: 11223344,
    name: '内蒙古农业大学',
    address: '内蒙古呼和浩特'
}

TS 中的类型

类型的使用 ​

变量类型声明 ​

函数中的类型声明 ​

TS 中的类型 ​

类型表 ​

字面量（用的不多） ​

any 与 unknown ​

void 与 never ​

对象类型 ​

数组类型 ​

元组类型 ​

枚举类型 ​

类型的逻辑运算 ​

类型别名 ​

类型的使用

变量类型声明

函数中的类型声明

TS 中的类型

类型表

字面量（用的不多）

any 与 unknown

void 与 never

对象类型

数组类型

元组类型

枚举类型

类型的逻辑运算

类型别名