第一篇 TypeScript 【typeScript 概述 + typeScript 基础类型】

typeScript 知识体系

1、TypeScript 是什么

2、TypeScript 基础类型

3、TypeScript 断言

4、TypeScript 类型守卫

5、TypeScript 联合类型和类型别名

6、TypeScript 交叉类型

7、TypeScript 函数

8、TypeScript 数组

9、TypeScript 对象

10、TypeScript 接口

11、TypeScript 类

12、TypeScript 泛型

13、TypeScript 装饰器

14、TypeScript 编译上下文

参考学习地址

https://juejin.cn/post/6844904182843965453#heading-0

typeScript 概述

typeScript 是什么

1、TypeScript 是一种由微软开发的自由和开源的编程语言。

2、TypeScript 它是 JavaScript 的一个超集，本质上向这个语言添加了可选的静态类型和基于类的面向对象编程

3、TypeScript 提供最新的和不断发展的 JavaScript 特性，包括那些来自 2015 年的 ECMAScript 和未来的提案中的特性，比如异步功能和 Decorators，以帮助建立健壮的组件

TypeScript 与 JavaScript 的区别

TypeScript	JavaScript
JavaScript 的超集用于解决大型项目的代码复杂性	一种脚本语言，用于创建动态网页
可以在编译期间发现并纠正错误	作为一种解释型语言，只能在运行时发现错误
强类型，支持静态和动态类型	弱类型，没有静态类型选项
最终被编译成 JavaScript 代码，使浏览器可以理解	可以直接在浏览器中使用
支持模块、泛型和接口	不支持模块，泛型或接口
支持 ES3，ES4，ES5 和 ES6 等	不支持编译其他 ES3，ES4，ES5 或 ES6 功能
社区的支持仍在增长，而且还不是很大	大量的社区支持以及大量文档和解决问题的支持

获取 TypeScript

1、安装 TypeScript

   npm install -g typescript
  
2、创建一个 TypeScript config.json 文件

   tsc --init
  
3、新建 TypeScript 文件 编写练习代码

4、编译 TypeScript 文件

   tsc helloworld.ts
   
   -> helloworld.ts => helloworld.js

TypeScript 基础类型 【 11 种 】

Boolean 类型

let isDone: boolean = false;

// ES5：var isDone = false;

Number 类型

let count: number = 10;

// ES5：var count = 10;

String 类型

let name: string = "Semliker";

// ES5：var name = 'Semlinker';

Array 类型

let list: number[] = [1, 2, 3];

// ES5：var list = [1,2,3];

let list: Array<number> = [1, 2, 3];  // Array<number>泛型语法

// ES5：var list = [1,2,3];

Enum 【 枚举 】 类型

1、使用 枚举 可以定义一些带名字的常量

2、使用 枚举 可以清晰地表达意图或创建一组有区别的用例

3、TypeScript 支持 数字 和 基于 字符串 的枚举

   1、数字的枚举
   
   2、字符串的枚举
   
   3、异构枚举

数字枚举

enum Direction {
  NORTH,
  SOUTH,
  EAST,
  WEST,
}

let dir: Direction = Direction.NORTH;

默认情况下，NORTH 的初始值为 0，其余的成员会从 1 开始自动增长
Direction.SOUTH 的值为 1，Direction.EAST 的值为 2，Direction.WEST 的值为 3

上面的枚举示例代码经过编译后会生成以下代码

var Direction;
(function (Direction) {
  Direction[(Direction["NORTH"] = 0)] = "NORTH";
  Direction[(Direction["SOUTH"] = 1)] = "SOUTH";
  Direction[(Direction["EAST"] = 2)] = "EAST";
  Direction[(Direction["WEST"] = 3)] = "WEST";
})(Direction || (Direction = {}));
var dir = Direction.NORTH;

当然我们也可以设置 NORTH 的初始值，比如：

enum Direction {
  NORTH = 3,
  SOUTH,
  EAST,
  WEST,
}

字符串枚举

1、在 TypeScript 2.4 版本，允许我们使用字符串枚举

2、在一个字符串枚举里，每个成员都必须用字符串字面量，或另外一个字符串枚举成员进行初始化

enum Direction {
  NORTH = "NORTH",
  SOUTH = "SOUTH",
  EAST = "EAST",
  WEST = "WEST",
}

以上代码对于的 ES5 代码如下

var Direction;
(function (Direction) {
    Direction["NORTH"] = "NORTH";
    Direction["SOUTH"] = "SOUTH";
    Direction["EAST"] = "EAST";
    Direction["WEST"] = "WEST";
})(Direction || (Direction = {}));

异构枚举

异构枚举 的成员值是 数字 和 字符串 的混合

enum Enum {
  A,
  B,
  C = "C",
  D = "D",
  E = 8,
  F,
}

以上代码对应的 ES5 代码如下

var Enum;
(function (Enum) {
    Enum[Enum["A"] = 0] = "A";
    Enum[Enum["B"] = 1] = "B";
    Enum["C"] = "C";
    Enum["D"] = "D";
    Enum[Enum["E"] = 8] = "E";
    Enum[Enum["F"] = 9] = "F";
})(Enum || (Enum = {}));

通过观察上述生成的 ES5 代码，我们可以发现数字枚举相对字符串枚举多了 “反向映射”

console.log(Enum.A)   //  输出：0
console.log(Enum[0]) // 输出：A

Any 类型

1、在 TypeScript 中，任何类型都可以被归为 any 类型

2、这让 any 类型成为了类型系统的顶级类型 【 也被称作全局超级类型 】

let notSure: any = 666;
notSure = "Semlinker";
notSure = false;

3、any 类型本质上是类型系统的一个逃逸舱

4、作为开发者，这给了我们很大的自由：TypeScript 允许我们对 any 类型的值执行任何操作，而无需事先执行任何形式的检查。比如：

let value: any;

value.foo.bar; // OK
value.trim(); // OK
value(); // OK
new value(); // OK
value[0][1]; // OK

5、使用 any 类型，可以很容易地编写类型正确但在运行时有问题的代码

6、如果使用 any 类型，就无法使用 TypeScript 提供的大量的保护机制

7、为了解决 any 带来的问题，TypeScript 3.0 引入了 unknown 类型

Unknown 类型

1、就像所有类型都可以赋值给 any，所有类型也都可以赋值给 unknown

2、这使得 unknown 成为 TypeScript 类型系统的另一种顶级类型【 另一种是 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

3、对 value 变量的所有赋值都被认为是类型正确的

4、但是，当我们尝试将类型为 unknown 的值赋值给其他类型的变量时会发生什么 ？

let value: unknown;

let value1: unknown = value; // OK
let value2: any = value; // OK
let value3: boolean = value; // Error
let value4: number = value; // Error
let value5: string = value; // Error
let value6: object = value; // Error
let value7: any[] = value; // Error
let value8: Function = value; // Error

5、unknown 类型只能被赋值给 any 类型和 unknown 类型本身

6、尝试对类型为 unknown 的值执行操作时会发生什么 ？

let value: unknown;

value.foo.bar; // Error
value.trim(); // Error
value(); // Error
new value(); // Error
value[0][1]; // Error

7、将 value 变量类型设置为 unknown 后，这些操作都不再被认为是类型正确的

   通过将 any 类型改变为 unknown 类型，我们已将允许所有更改的默认设置，更改为禁止任何更改

Tuple 【 元组 】 类型

1、数组一般由同种类型的值组成，但有时我们需要在单个变量中存储不同类型的值，这时候我们就可以使用 元组

2、在 JavaScript 中是没有 元组 的，元组是 TypeScript 中特有的类型，其工作方式类似于数组

3、元组可用于定义具有有限数量的未命名属性的类型，每个属性都有一个关联的类型

4、使用 元组 时，必须提供每个属性的值

   1、为了更直观地理解元组的概念，来看一个具体的例子
   
     let tupleType: [string, boolean];
     tupleType = ["Semlinker", true];

   2、与数组一样，我们可以通过下标来访问元组中的元素
   
     console.log(tupleType[0]); // Semlinker
     console.log(tupleType[1]); // true
     
   3、在元组初始化的时候，如果出现类型不匹配的话
   
     tupleType = [true, "Semlinker"];
     
     TypeScript 编译器会提示以下错误信息：
     
      [0]: Type 'true' is not assignable to type 'string'
      [1]: Type 'string' is not assignable to type 'boolean'
      
    4、在元组初始化的时候，我们还必须提供每个属性的值，不然也会出现错误
    
      tupleType = ["Semlinker"];
      
      Property '1' is missing in type '[string]' but required in type '[string, boolean]'.

Void 类型

1、某种程度上来说，void 类型像是与 any 类型相反，它表示没有任何类型

2、当一个函数没有返回值时，你通常会见到其返回值类型是 void

// 声明函数返回值为void
function warnUser(): void {
  console.log("This is my warning message");
}

以上代码编译生成的 ES5 代码如下

function warnUser() {
  console.log("This is my warning message");
}

3、需要注意的是，声明一个 void 类型的变量没有什么作用，因为它的值只能为 undefined 或 null

let unusable: void = undefined

Null 和 Undefined 类型

1、TypeScript 里，undefined 和 null 两者有各自的类型分别为 undefined 和 null

let u: undefined = undefined;
let n: null = null;

2、默认情况下 null 和 undefined 是所有类型的子类型

3、就是说你可以把 null 和 undefined 赋值给 number 类型的变量

4、然而，如果你指定了 --strictNullChecks 标记，null 和 undefined 只能赋值给 void 和它们各自的类型

Never 类型

1、never 类型表示的是那些永不存在的值的类型

2、ever 类型是那些总是会抛出异常或根本就不会有返回值的 函数表达式 或 箭头函数表达式 的返回值类型

3、返回 never 的 函数 必须存在无法达到的终点

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

function infiniteLoop(): never {
  while (true) {}
}

4、在 TypeScript 中，可以利用 never 类型的特性来实现全面性检查，具体示例如下

type Foo = string | number;

function controlFlowAnalysisWithNever(foo: Foo) {
  if (typeof foo === "string") {
    // 这里 foo 被收窄为 string 类型
  } else if (typeof foo === "number") {
    // 这里 foo 被收窄为 number 类型
  } else {
    // foo 在这里是 never
    const check: never = foo;
  }
}

   controlFlowAnalysisWithNever 方法总是穷尽了 Foo 的所有可能类型

   通过这个示例，我们可以得出一个结论
   
   使用 never 避免出现新增了联合类型没有对应的实现，目的就是写出类型绝对安全的代码