typescript数据类型（学习笔记）

找了网上很多文章对于ts数据类型的概括感觉都有些不太全面，不是少这就是少那，这里根据自己的相关查询整理一份ts的数据类型的学习笔记，若有错请指正：

typescript包含es6 中所有数据类型： Boolean 、 Number 、 String 、 Array、Function、Object、Symbol、undefined、null

typescript中新增的数据类型：void(空值)、any(任意值类型)、unknown(未知类型,ts3.0 中新增)、never、元组、枚举、联合类型

TS 中数据类型定义示例：

1、Boolean

let isDone: boolean = false;

2、Number

let height: number = 180;

3、String

let usreName: string = "admin";

4、Array

let list: number[] = [1, 2, 3]  // 或   let list2: Array<number> = [1, 2, 3];

5、Function

let crateUser = (name: string, age: number): void => {
    console.log(name, age);
};

6、Object

let obj: object = { prop: 0 };

7、Symbol

let smb: symbol = Symbol(1)

8、undefined

let count: number = undefined;

9、null

let somthing: string = null;

10、void（用来描述没有返回值的函数）

function sayHellow(): void {
    console.log("Hellow world");
}

11、any(任意值类型)

let casual: any = 4;

let casual: any = 'hellow world';

let casualList: any[] = [1, true, "free"];

12、unknown （未知类型,后面总结any与unknown的区别）

let value: unknown;
 
value = true;                 // OK
value = 42;                   // OK
value = "Hello World";        // OK
value = [];                   // OK
value = {};                   // OK
value = Math.random;          // OK
value = null;                 // OK
value = undefined;            // OK
value = new TypeError();      // OK
value = Symbol("type");       // OK

13、never （never类型表示的是永不存在的值的类型）

function error(message: string): number {
    throw new Error(message);
}

// 推断的返回值类型为never
function fail() {
    return error("Something failed");
}

// 返回never的函数必须存在无法达到的终点
function infiniteLoop(): never {
    while (true) {}
}

14、元组（已知元素数量和类型的数组，各类型可不相同）

let list: [string, number, object] = ["张三", 18, {}];

15、枚举

enum Color {
    red,
    Blue,
    Green,
}
let c: Color = Color.Blue; // 返回对应的index
let colorName: string = Color[1]; // 返回对应的枚举项

16、联合类型

let arr_union: (string | number)[] = [1, 2, 'zx'];

总结：

1、any 与 unknown 的区别是什么？

any：所有类型都是any类型的子类型，any类型也是所有类型的子类型（任何类型都可以赋值给 any类型的变量，any类型也可赋值给任意类型的变量）；any类型会跳过ts编译阶段的类型检查，相对来说是不安全的；

let tset1: string = "string";
let test2: any = [1, "str", {}];
let taet3: unknown = Symbol(1);

let str1: any = tset1; // ok（满足任意类型可赋值给any类型） 
let str2: number = test2; // ok （满足any类型可赋值给任意类型）
let str3: any = taet3; // ok（满足任意类型可赋值给any类型） 


// 下面这段代码，调用了dog上不存在hello方法，由于dog是any类型，所以在编译阶段不会提示错误，但是在代码运行时会出现错误，所以使用any类型是不太安全的。

const dog: any = {

name: "Fluffy",

sayHello: () => "woof woof",

};

dog.hello();

unknown：任何类型都是unknown类型的子类型（任意类型都可赋值给unknown类型的变量）， unknown 类型的变量只能赋值给 any 和 unknown；

let tset1: string = "string";
let test2: any = [1, "str", {}];
let taet3: unknown = Symbol(1);

let str1: unknown = tset1; // ok（满足任意类型可赋值给unknown类型）
let str2: unknown = test2; // ok （满足任意类型可赋值给unknown类型）
let str3: unknown = taet3; // ok（满足任意类型可赋值给unknown类型）

// 面这段代码，调用了dog上不存在hello方法，由于dog是unknown类型，所以在编译阶段就会提示错误，所以unknown相对于any来说更安全，因为它迫使我们需要执行额外的类型检查来对变量执行后续操作。

　const dog: unknown = {

name: "Fluffy",

sayHello: () => "woof woof",

};

dog.hello(); // Error 类型“unknown”上不存在属性“hello”。

　dog.sayHello() // Error 类型“unknown”上不存在属性“sayHello”

// 要对未知类型的属性执行某些操作，首先需要使用类型断言来缩小范围

(dog as { sayHello:()=>{} }).sayHello() // ok 将dog断言为带有sayHello属性的对象（强制TypeScript编译器相信我们知道自己在做什么）

(dog as { name:string }).name // ok  将dog断言为带有name属性的对象

2、ts数据类型之间的关系

null和undefined 是任何类型的子类型；never 永远不是任何类型的子类型；所有类型都是any类型的子类型，any类型也是所有类型的子类型；任何类型都是unknown类型的子类型；（既：子类型可赋值给父类型，父类型不可赋值给子类型）