1. TypeScript 介绍

1.1 TypeScript 是什么

TypeScript（简称：TS）是 JavaScript 的超集（ JS 有的 TS 都有）。

TypeScript = Type + JavaScript（在 JS 基础之上，为 JS 添加了类型支持）。

TypeScript 是微软开发的开源编程语言，可以在任何运行 JavaScript 的地方运行。

1.2 TypeScript 为什么要为 JS 添加类型支持？

背景：JS 的类型系统存在“先天缺陷”，JS 代码中绝大部分错误都是类型错误（Uncaught TypeError）。而这增加了找 Bug、改 Bug 的时间，严重影响开发效率。

从编程语言的动静来区分，TypeScript 属于静态类型的编程语言，JS 属于动态类型的编程语言。

静态类型和动态类型的区别：

• 静态类型：编译期做类型检查
• 动态类型：执行期做类型检查

代码编译和代码执行的顺序：先编译再执行。

对于 JS 来说：需要等到代码真正去执行的时候才能发现错误（发现较晚）。

对于 TS 来说：在代码编译的时候（代码执行前）就可以发现错误（发现较早）。

并且，配合 VSCode 等开发工具，TS 可以提前到在编写代码的同时就发现代码中的错误，减少找 Bug、改 Bug 时间。

1.3 TS 相比 JS 的优势

• 更早（写代码的同时）发现错误，减少找 Bug、改 Bug 时间，提升开发效率

• 程序中任何位置的代码都有代码提示，随时随地的安全感，增强了开发体验

• 强大的类型系统提升了代码的可维护性，使得重构代码更加容易

• 支持最新的 ECMAScript 语法，优先体验最新的语法

• TS 类型推断机制，不需要在代码中的每个地方都显示标注类型，让我们在享受优势的同时，尽量降低了成本

除此之外，Vue3 源码使用 TS 重写、Angular 默认支持 TS、React 与 TS 完美配合，TypeScript 已成为大中型前端项目的首先编程语言。

2. 安装和使用 TS

2.1 安装编译 TS 的工具包

问题：为什么要安装编译 TS 的工具包？

因为 Node.js 和 浏览器，只认识 JS 代码，不认识 TS 代码。需要先将 TS 代码转化为 JS 代码，然后才能运行。

安装命令：

npm i -g typescript

typescript 包的作用是编译 TS 代码的包，提供了 tsc 命令，实现了 TS -> JS 的转化。

验证是否安装成功（查看 TS 的版本）：

tsc –v

2.2 编译并运行 TS 代码

• 先创建 hello.ts 文件（注意：TS 文件的后缀名为 .ts）

  该文件的内容为：

  console.log('hello,TS!')
  

• 将 TS 编译为 JS：在终端中输入命令：

  tsc hello.ts
  

  此时，在同级目录中会出现一个同名的 JS 文件（即：hello.js ）。

• 执行 JS 代码：在终端中输入命令，运行转化后的 js 文件：

  node hello.js
  

注意：

• 所有合法的 JS 代码都是 TS 代码

• 由 TS 编译生成的 JS 文件，代码中没有类型信息了

2.3 简化运行 TS 的步骤

问题描述：每次修改代码后，都要重复执行两个命令，才能运行 TS 代码，太繁琐。

简化方式：使用 ts-node 包，直接在 Node.js 中执行 TS 代码。

安装命令：

npm i -g ts-node

ts-node 包提供了 ts-node 命令，使用方式：

ts-node hello.ts

作用：ts-node 命令在内部偷偷的将 TS -> JS，然后，再运行 JS 代码

注意：ts-node 命令不会将 TS 转化的 JS 文件进行保存

3. TS 常用类型

3.1 概述

TS 是 JS 的超集，TS 提供了 JS 的所有功能，并且额外的增加了：类型系统。

• 所有的 JS 代码都是 TS 代码。

• JS 有类型（比如，number，string 等），但是 JS 不会检查变量的类型是否发生变化，而 TS 会检查。

TS 类型系统的主要优势：可以显示标记出代码中的意外行为，从而降低了发生错误的可能性。

简单概括：容易找 bug，改 bug

3.2 类型注解

示例代码：

let age: number = 10

说明：代码中的 : number 就是类型注解。

作用：为变量添加类型约束。比如，上述代码中，约定变量 age 的类型为 number（数值类型）。

解释：约定了什么类型，就只能给变量赋值该类型的值，否则，就会报错。

let age: number = '10' // 报错

3.3 常用基础类型概述

可以将 TS 中的常用基础类型细分为两类：

• JS 已有类型

  • 原始类型：number，string，boolean，null，undefined，symbol
  • 对象类型：object（包括，数组、对象、函数等对象）

• TS 新增类型

  • 联合类型、自定义类型（类型别名）、接口、元组、字面量类型、枚举、void、any 等

3.4 原始类型

原始类型：number，string，boolean，null，undefined，symbol

特点：简单。这些类型，完全按照 JS 中类型的名称来书写。

let age: number = 10
let str: string = 'zuolun'
let flag: boolean = true
let u: undefined = undefined
let n: null = null
let s: symbol = Symbol()

3.5 对象类型

对象类型：object（包括，数组、对象、函数等对象）

特点：对象类型，在 TS 中更加细化，每个具体的对象都有自己的类型语法。

3.5.1 数组类型

数组类型的两种写法：

// 第一种（更推荐这种写法）
let num: number[] = [1, 2, 3]

// 第二种
let num2: Array<Number> = [4, 5, 6]

需求：数组中既有 number 类型，又有 string 类型，这个数组的类型应该如何写？

let list: (number | string)[] = [1, 2, 3, '4']

解释：

| （竖线） 在 TS 中叫做联合类型（由两个或多个其他类型组成的类型，表示可以是这些类型中的任意一种）。

有无括号的区别：

• 有括号，表示 list 是数组类型，且值为 number 或 string 类型

  let list: (number | string)[] = [1, 2, 3, '4']
  

• 无括号，表示 list 是数字类型或者 string 数组类型

  let list: number | string[] = 1
  

3.5.2 类型别名

类型别名（自定义类型）：为任意类型起别名

使用场景：当同一类型（复杂）被多次使用时，可以通过类型别名，简化该类型的使用

type CustomArray = (number|string)[]
let arr1: CustomArray = [1,2,4,'a']
let arr2: CustomArray = [1,3,3,'b']

解释：

• 使用 type 关键字来创建类型别名

• 类型别名（比如，此处的 CustomArray），可以是任意合法的变量名称

• 创建类型别名后，直接使用该类型别名作为变量的类型注解即可

3.5.3 函数类型

1. 指定类型的两种方式

函数的类型实际上指的是：函数参数和返回值的类型。

为函数指定类型的两种方式：

• 单独指定参数、返回值的类型

  // 直接声明函数
  function add(num1: number, num2: number): number {
      return num1 + num2
  }
  
  // 函数表达式
  const add2 = (num1: number, num2: number): number => {
      return num1 + num2
  }
  

• 同时指定参数、返回值的类型

  类比之前的类型定义：

  const a: number = 4
  

  而函数也可以当成 : 右边的类型，即 number 可以替换为 (num1: number, num2: number) => number

  再类比一般的函数定义：

  const a = (num1, num2) => {
      return num1 + num2
  }
  

  所以类型定义后面的 4 可以替换为函数表达式的值：(num1, num2) => { return num1 + num2 }

  综上，函数定义最后为：

  const a: (num1: number, num2: number) => number = (num1, num2) => {
      return num1 + num2
  }
  

  注意：这种形式只适用于函数表达式

2. void 类型

如果函数没有返回值，那么，函数返回值类型为：void

const sayHello = (uname: string): void => {
    console.log('Hello ' + uname)
}

sayHello('ts')

3. 可选参数

使用函数实现某个功能时，参数可以传也可以不传。这种情况下，在给函数参数指定类型时，就用到可选参数了。

比如，数组的 slice 方法，可以 slice() 也可以 slice(1) 还可以 slice(1, 3)。

可选参数：在可传可不传的参数名称后面添加 ?

const range = (start: number, end?: number): void => {
    console.log(`起始：${start}, 结束：${end}`);
}

range(1, 4) // 起始：1, 结束：4
range(1) // 起始：1, 结束：undefined
range() // 报错

注意：

• 没加 ? 是 必选参数，加 ? 是可选参数
• 可选参数必须在必选参数的后面，即可选参数之后不能出现必选参数
• 可选参数在传参没传递默认是 undefined，必选参数在传参没传递会报错

3.7 对象类型

JS 中的对象是由属性和方法构成的，而 TS 中对象的类型就是在描述对象的结构（有什么类型的属性和方法）。

对象类型的写法：

let obj: { uname: string, uage: number, sayHi(): void } = {
    uname: 'zuolun',
    uage: 18,
    sayHi() {
        console.log('hi')
    }
}

解释：

• 直接使用 {} 来描述对象结构。属性采用 属性名: 类型的形式 ，方法采用 方法名(): 返回值类型 的形式。

• 如果方法有参数，就在方法名后面的小括号中指定参数类型（比如：greet(name: string): void）

• 在一行代码中指定对象的多个属性类型时，使用 ; 或者 , 来分隔

• 如果一行代码只指定一个属性类型（通过换行来分隔多个属性类型），可以去掉 ; 或 ,

  let obj2: { 
      uname: string
      uage: number
      sayHi(): void 
  } = {
      uname: 'zuolun',
      uage: 18,
      sayHi() {
          console.log('hi')
      }
  }
  

• 方法的类型也可以使用箭头函数形式（比如：{ sayHi: () => void }）

• 对象的属性或方法，也可以是可选的，此时就用到可选属性了，可选属性的语法与函数可选参数的语法一致，都使用 ? 来表示

3.6 接口

3.6.1 什么是接口

当一个对象类型被多次使用时，一般会使用接口(interface) 来描述对象的类型，达到复用的目的。

interface IPerson {
    name: string
    age: number
    sayHi(): void
}

let Person: IPerson = {
    name: 'zuolun',
    age: 22,
    sayHi() { }
}

解释：

• 使用 interface 关键字来声明接口。

• 接口名称（比如，此处的 IPerson），可以是任意合法的变量名称

• 声明接口后，直接使用接口名称作为变量的类型

• 因为每一行只有一个属性类型，因此，属性类型后没有 ; 或 ,

3.6.2 接口和 type 的区别

interface(接口) 和 type(类型别名) 的对比：

• 相同点：都可以给对象指定类型

• 不同点：

  • 接口，只能为对象指定类型
  • 类型别名，不仅可以为对象指定类型，实际上可以为任意类型指定别名

3.6.3 接口的继承复用

如果两个接口之间有相同的属性或方法，可以将公共的属性或方法抽离出来，通过继承来实现复用。

比如，这两个接口都有 x、y 两个属性，重复写两次，可以，但很繁琐。

interface Point2D { x: number, y: number }
interface Point3D { x: number, y: number, z: number }

更好的方式：

interface Point2D { x: number, y: number }
interface Point3D extends Point2D { z: number }

解释：

• 使用 extends 实现了接口 Point3D 继承 Point2D。
• 继承后，Point3D 就有了 Point2D 的所有属性和方法（此时，Point3D 同时有 x、y、z 三个属性）。

3.7 元组

场景：在地图中，使用经纬度坐标来标记位置信息

可以使用数组来记录坐标，那么，该数组中只有两个元素，并且这两个元素都是数值类型。

let pos: number[] = [1, 3]

使用 number[] 的缺点：不严谨，因为该类型的数组中可以出现任意多个数字。

更好的方式：元组(Tuple)

元组类型是另一种类型的数组，它确切地知道包含多少个元素，以及特定索引对应的类型。

let pos2:[number,number] = [2,4]

解释：

• 元组类型可以确切地标记出有多少个元素，以及每个元素的类型

• 该示例中，该变量只能有两个元素，每个元素的类型都是 number

3.8 类型推论

在 TS 中，某些没有明确指出类型的地方，TS 的类型推论机制会帮助提供类型。

换句话说：由于类型推论的存在，这些地方，类型注解可以省略不写！

发生类型推论的 2 种常见场景：

• 声明变量并初始化时

  

• 决定函数返回值时

  

注意：这两种情况下，类型注解可以省略不写

推荐：能省略类型注解的地方就省略（偷懒，充分利用 TS 类型推论的能力，提升开发效率）

技巧：如果不知道类型，可以通过鼠标放在变量名称上，利用 VSCode 的提示来查看类型。

3.9 类型断言

有时候我们会比 TS 更加明确一个值的类型，此时，可以使用类型断言来指定更具体的类型。

注意：querySelector 方法返回值的类型是 HTMLElement，该类型只包含所有标签公共的属性或方法，不包含 <a> 标签特有的 href 等属性。

因此，这个类型太宽泛（不具体），无法操作 href 等 <a> 标签特有的属性或方法。

解决方式：这种情况下就需要使用类型断言指定更加具体的类型

使用类型断言：

解释：

• 使用 as 关键字实现类型断言

• 关键字 as 后面的类型是一个更加具体的类型（HTMLAnchorElement 是 HTMLElement 的子类型）

• 通过类型断言，aLink 的类型变得更加具体，这样就可以访问 a 标签特有的属性或方法了

另一种语法，使用 <> 语法，这种语法形式不常用，知道即可：

const aLink = <HTMLAnchorElement>document.querySelector('#baidu')

技巧：在浏览器控制台，通过 console.dir() 打印 DOM 元素，在属性列表的最后面，即可看到该元素的类型。

3.10 字面量类型

思考以下代码，两个变量的类型分别是什么？

let str1 = 'hello TS'
const str2 = 'hello TS'

通过 TS 类型推论机制，可以得到答案：

• 变量 str1 的类型为：string
• 变量 str2 的类型为：'Hello TS'

解释：

• str1 是一个变量（let），它的值可以是任意字符串，所以类型为：string

• str2 是一个常量（const），它的值不能变化只能是 'hello TS'，所以，它的类型为：'hello TS'

注意：此处的 'hello TS'，就是一个字面量类型。也就是说某个特定的字符串也可以作为 TS 中的类型，除字符串外，任意的 JS 字面量（比如，对象、数字等）都可以作为类型使用

使用模式：字面量类型配合联合类型一起使用

使用场景：用来表示一组明确的可选值列表，比如，在贪吃蛇游戏中，游戏的方向的可选值只能是上、下、左、右中的任意一个。

function changeDirection(direction:'up' | 'down' | 'left' | 'right'):void{
    console.log(direction)
}

解释：参数 direction 的值只能是 up，down，left，right 中的任意一个

优势：相比于 string 类型，使用字面量类型更加精确、严谨

3.11 枚举

3.11.1 概述

枚举的功能类似于字面量类型+联合类型组合的功能，也可以表示一组明确的可选值。

枚举：定义一组命名常量。它描述一个值，该值可以是这些命名常量中的一个。

enum Direction {
    up,
    down,
    left,
    right
}

function changeDirection(direction: Direction) {
    console.log(direction)
}

解释：

• 使用 enum 关键字定义枚举

• 约定枚举名称、枚举中的值以大写字母开头

• 枚举中的多个值之间通过 , 分隔

• 定义好枚举后，直接使用枚举名称作为类型注解

• 形参 direction 的类型为枚举 Direction，那么，实参的值就应该是枚举 Direction 成员的任意一个

3.11.2 访问

访问枚举成员类似于 JS 中的对象，直接通过点 . 语法访问枚举的成员：

changeDirection(Direction.up)

3.11.3 实参的值

既然实参的值是 Direction 成员的任意一个，那么他们的值究竟是多少呢？

enum Direction {
    up, // 0
    down, // 1
    left, // 2
    right // 3
}

将鼠标放在变量上，可发现他们的值从上到下，分别为：0，1，2，3

注意：

• 枚举成员是有值的，默认为：从 0 开始自增的数值

• 枚举成员的值为数字的枚举，称为：数字枚举

当然，我们也可以给枚举中的成员初始化值：

enum Direction {
    up = 11, // 11
    down, // 12
    left = 20, // 20
    right  // 21
}

有值赋初值，无值自增，最上面无值就为 0 。

3.11.4 字符串枚举

字符串枚举：枚举成员的值是字符串。

enum Direction2 {
    up = 'up',
    down = 'down',
    left = 'left',
    right = 'right'
}

注意：字符串枚举没有自增长行为，因此，字符串枚举的每个成员必须有初始值。但是，如果前面传字符串，中间传数字，那么该数字之后，仍然保持自增行为，即不传也没事。

3.11.5 枚举编译

枚举是 TS 为数不多的非 JS 类型级扩展（不仅仅是类型）的特性之一。

因为：其他类型仅仅被当做类型，而枚举不仅用作类型，还提供值（枚举成员都是有值的），也就是说，其他的类型会在编译为 JS 代码时自动移除。但是，枚举类型会被编译为 JS 代码！

编译前：

enum Direction2 {
    up = 'up',
    down = 'down',
    left = 'left',
    right = 'right'
}

编译后：

(function (Direction2) {
    Direction2["up"] = "up";
    Direction2["down"] = "down";
    Direction2["left"] = "left";
    Direction2["right"] = "right";
})(Direction2 || (Direction2 = {}));

说明：枚举与前面讲到的字面量类型+联合类型组合的功能类似，都用来表示一组明确的可选值列表。

一般情况下，推荐使用字面量类型+联合类型组合的方式，因为相比枚举，这种方式更加直观、简洁、高效。

3.12 any 类型

原则：不推荐使用 any！这会让 TypeScript 变为 AnyScript（失去 TS 类型保护的优势）。

因为当值的类型为 any 时，可以对该值进行任意操作，并且不会有代码提示。

let obj: any = { x: 10 }
obj.age
obj()
const num: number = obj
//以上操作都不会有任何类型错误提示，即使可能存在错误！

尽可能的避免使用 any 类型，除非临时使用 any 来“避免”书写很长、很复杂的类型！

其他隐式具有 any 类型的情况：

• 声明变量不提供类型也不提供默认值

  let num // 此时类型默认为 any
  

• 函数参数不加类型

  function add(num1,num2){ // 此时 num1 和 num2 类型和返回值都默认为 any
      return num1 + num2
  }
  

注意：因为不推荐使用 any，所以，这两种情况下都应该提供类型！

3.13 typeof

众所周知，JS 中提供了 typeof 操作符，用来在 JS 中获取数据的类型。

实际上，TS 也提供了 typeof 操作符：可以在类型上下文中引用变量或属性的类型（类型查询）。

使用场景：根据已有变量的值，获取该值的类型，来简化类型书写。

未使用 typeof：

let p = { x: 1, y: 2 }
function formatPoint(Point: { x: number, y: number }) {
    console.log(Point.x)
    console.log(Point.y)
}
formatPoint(p)

使用 typeof：

let p = { x: 1, y: 2 }
function formatPoint(Point: typeof p) {
    console.log(Point.x)
    console.log(Point.y)
}
formatPoint(p)

解释：

• 使用 typeof 操作符来获取变量 p 的类型，结果与第一种对象字面量形式的类型相同

• typeof 出现在类型注解的位置（参数名称的冒号后面）所处的环境就在类型上下文（区别于 JS 代码）

注意：typeof 只能用来查询变量或属性的类型，无法查询其他形式的类型（比如，函数调用的类型）

function add(num1: number, num2: number) {
    return num1 + num2
}

let x: typeof add(1, 2) // 报错

本文主要学习 ******************************************

如有错误，敬请指正，欢迎交流🤝，谢谢♪(･ω･)ﾉ