# 二.基础类型

前言

常见的基础类型总结

# 1.布尔类型

编译前

let isClose: boolean = true

编译后

"use strict";
let isClose = true;

1
2

# 2.数值类型

数值包括 number 类型和 bigInt 类型,它们是不兼容的

# 2.1 Number

编译前
```
let count: number = 10
```
编译后
```
"use strict";
let count = 10;
```
1
2

# 2.2 BigInt

编译前

const num1 = Number.MAX_SAFE_INTEGER + 1
const num2 = Number.MAX_SAFE_INTEGER + 2
console.log(num1 === num2) // true
let max: bigint = BigInt(Number.MAX_SAFE_INTEGER)
console.log(max + BigInt(1) === max + BigInt(2))

1
2
3
4

编译后

"use strict";
const num1 = Number.MAX_SAFE_INTEGER + 1;
const num2 = Number.MAX_SAFE_INTEGER + 2;
console.log(num1 === num2); // true
let max = BigInt(Number.MAX_SAFE_INTEGER);
console.log(max + BigInt(1) === max + BigInt(2));

1
2
3
4
5
6

# 3.字符串类型

编译前
```
let str: string = "hello ts"
```
编译后
```
"use strict";
let str = "hello ts";
```
1
2

# 4.Null

编译前

let currentValue: null | boolean
currentValue = null

编译后

"use strict";
let currentValue;
currentValue = null;

1
2
3

# 5.Undefined

编译前

let currentData: null | boolean
currentData = true

编译后

"use strict";
let currentData;
currentData = true;

1
2
3

# 6.Symbol

编译前

const s1:symbol = Symbol("value1")
const s2:symbol = Symbol("value2")
console.log(s1 === s2)

1
2

编译后

"use strict";
const s1 = Symbol("value1");
const s2 = Symbol("value2");
console.log(s1 === s2);

1
2
3
4

# 7.Any

编译前

// 1.定义
function cloneDeep(data: any) {
    return JSON.parse(JSON.stringify(data))
}
// 2.使用
const cloneObj = cloneDeep({ key: 1, value: [{ id: 4 }] })

const cloneArr = cloneDeep([1, 2, 4, { key: [1, 2, 3] }])

1
2
3
4
5
6
7
8

编译后

"use strict";
// 1.定义
function cloneDeep(data) {
    return JSON.parse(JSON.stringify(data));
}
// 2.使用
const cloneObj = cloneDeep({ key: 1, value: [{ id: 4 }] });
const cloneArr = cloneDeep([1, 2, 4, { key: [1, 2, 3] }]);

1
2
3
4
5
6
7
8

# 8.Unknown

不能访问unknown类型上的属性，不能作为函数、类来使用

编译前

// 1.使用案例
let value: unknown
value = true // OK
value = 42 // OK

// 2.任何类型都可以赋值为`unknown`类型。它是`any`类型对应的安全类型
let unknown: unknown;
unknown = "aaa";
unknown = 11;

// 3.never 是`unknown`的子类型
type isNever = never extends unknown ? true : false;
let currentVal: isNever = true;

// 4.keyof unknown 是 never
type key = keyof unknown;
function getVal(): key {
    while (true) {

    }
}
// 5.unknown 类型不能被遍历
type IMap<T> = {
    [P in keyof T]: number;
};
type t = IMap<unknown>;

// 6.unknown 类型不能和 number 类型进行`+`运算，可以用于等或不等操作

// 7.联合类型中的`unknown`：联合类型与`unknown`都是`unknown`类型
type UnionUnknown = unknown | null | string | number;
let knownVal: UnionUnknown = 'dddd'

// 8.交叉类型中的`unknown`：交叉类型与`unknown`都是其他类型
type inter = unknown & null;
let interVal: inter = null

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

编译后

"use strict";
// 1.使用案例
let value;
value = true; // OK
value = 42; // OK
// 2.任何类型都可以赋值为`unknown`类型。它是`any`类型对应的安全类型
let unknown;
unknown = "aaa";
unknown = 11;
let currentVal = true;
function getVal() {
    while (true) {
    }
}
let knownVal = 'dddd';
let interVal = null;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 9.Void

只能接受 null，undefined。一般用于函数的返回值

编译前

let consoleVal = (val: void): void => {
    console.log(val)
}
consoleVal(undefined)
consoleVal()

1
2
3
4
5

编译后

"use strict";
let consoleVal = (val) => {
    console.log(val);
};
consoleVal(undefined);
consoleVal();

1
2
3
4
5
6

# 10.Never

任何类型的子类型，never 代表不会出现的值。不能把其他类型赋值给 never

编译前

function error(message: string): never {
    throw new Error("err")
  }
  function loop(): never {
    while (true) {}
  }
  function fn(x: number | string) {
    if (typeof x === "number") {
      console.log('number')
    } else if (typeof x === "string") {
      console.log('string')
    } else {
      console.log(x) //never
    }
  }

1
2
3
4
5
6
7
8
9
10
11
12
13
14

编译后

"use strict";
function error(message) {
    throw new Error("err");
}
function loop() {
    while (true) { }
}
function fn(x) {
    if (typeof x === "number") {
        console.log('number');
    }
    else if (typeof x === "string") {
        console.log('string');
    }
    else {
        console.log(x); //never
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# 11.对象类型

type obj = {
  [x: string]: any
}

1
2
3

type obj = Record<string, any>

interface Objs<T> {
    [key: string]:T
}

const objs:Objs<number> = {
    age: 18
}

1
2
3
4
5
6
7

编译前

let obj: { a: number; b: number } = { a: 1, b: 2 }
let create = (obj:object):void =>{}
create(obj)
create({})
create([])
create(function(){})

1
2
3
4
5

编译后

"use strict";
let obj = { a: 1, b: 2 };
let create = (obj) => { };
create(obj);
create({});
create([]);
create(function () { });

1
2
3
4
5
6
7

# 12.数组类型

# 12.1 元组类型(固定长度)

编译前

// 已知元素数量和类型的数组
let tuple: [string, number, boolean] = ["hello", 10, true]
tuple.push("abc") // 在元组中增加数据，只能增加元组中存放的类型

1
2
3

编译后

"use strict";
// 已知元素数量和类型的数组
let tuple = ["hello", 10, true];
tuple.push("abc"); // 在元组中增加数据，只能增加元组中存放的类型

1
2
3
4

# 12.2 不定长度

编译前

// 确定类型1
let arr1: number[] = [1, 2, 3]
let arr2: string[] = ["1", "2", "3"]
let arr3: (number | string)[] = [1, "2", 3]

// 确定类型2
let arr: Array<number> = [1, 2, 3]
let arr4: Array<number | string> = [1, "2", 3]

// 泛型
type ArrType<T> = Array<T>
let arr5: ArrType<number> = [1, 2, 3]
let arr6: Array<number | string> = [1, "2", 3]
interface treeNode {
    id: string;
    children: treeNode[]
}
const treeData: treeNode[] = []

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

编译后

"use strict";
// 确定类型1
let arr1 = [1, 2, 3];
let arr2 = ["1", "2", "3"];
let arr3 = [1, "2", 3];
// 确定类型2
let arr = [1, 2, 3];
let arr4 = [1, "2", 3];
let arr5 = [1, 2, 3];
let arr6 = [1, "2", 3];
const treeData = [];

1
2
3
4
5
6
7
8
9
10
11

# 13.枚举类型

编译前

// 数字枚举:除了⽀持 从成员名称到成员值 的普通映射之外，它还⽀持 从成员值到成员名称 的反向映射
enum USER_ROLE {
  USER, // 默认从0开始
  ADMIN,
  MANAGER,
}
console.log(USER_ROLE[0])
console.log(USER_ROLE.USER)

//异构枚举:异构枚举的成员值是数字和字符串的混合
enum USER_ROLE2 {
  USER = "user",
  ADMIN = 1,
  MANAGER,
}
console.log(USER_ROLE2.USER)

// 常量枚举
const enum USER_ROLE3 {
  USER,
  ADMIN,
  MANAGER,
}
console.log(USER_ROLE3.USER)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

编译后

"use strict";
// 数字枚举:除了⽀持 从成员名称到成员值 的普通映射之外，它还⽀持 从成员值到成员名称 的反向映射
var USER_ROLE;
(function (USER_ROLE) {
    USER_ROLE[USER_ROLE["USER"] = 0] = "USER";
    USER_ROLE[USER_ROLE["ADMIN"] = 1] = "ADMIN";
    USER_ROLE[USER_ROLE["MANAGER"] = 2] = "MANAGER";
})(USER_ROLE || (USER_ROLE = {}));
console.log(USER_ROLE[0]);
console.log(USER_ROLE.USER);
//异构枚举:异构枚举的成员值是数字和字符串的混合
var USER_ROLE2;
(function (USER_ROLE2) {
    USER_ROLE2["USER"] = "user";
    USER_ROLE2[USER_ROLE2["ADMIN"] = 1] = "ADMIN";
    USER_ROLE2[USER_ROLE2["MANAGER"] = 2] = "MANAGER";
})(USER_ROLE2 || (USER_ROLE2 = {}));
console.log(USER_ROLE2.USER);
console.log(0 /* USER_ROLE3.USER */);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

← 一.内置对象三.类型推导 →