第一章 快速入門(mén)

0、TypeScript簡(jiǎn)介

1. TypeScript是JavaScript的超集。
2. 它對(duì)JS進(jìn)行了擴(kuò)展，向JS中引入了類(lèi)型的概念，并添加了許多新的特性。
3. TS代碼需要通過(guò)編譯器編譯為JS，然后再交由JS解析器執(zhí)行。
4. TS完全兼容JS，換言之，任何的JS代碼都可以直接當(dāng)成JS使用。
5. 相較于JS而言，TS擁有了靜態(tài)類(lèi)型，更加嚴(yán)格的語(yǔ)法，更強(qiáng)大的功能；TS可以在代碼執(zhí)行前就完成代碼的檢查，減小了運(yùn)行時(shí)異常的出現(xiàn)的幾率；TS代碼可以編譯為任意版本的JS代碼，可有效解決不同JS運(yùn)行環(huán)境的兼容問(wèn)題；同樣的功能，TS的代碼量要大于JS，但由于TS的代碼結(jié)構(gòu)更加清晰，變量類(lèi)型更加明確，在后期代碼的維護(hù)中TS卻遠(yuǎn)遠(yuǎn)勝于JS。

1、TypeScript 開(kāi)發(fā)環(huán)境搭建

1. 下載Node.js

   • 64位：https://nodejs.org/dist/v14.15.1/node-v14.15.1-x64.msi
   • 32位：https://nodejs.org/dist/v14.15.1/node-v14.15.1-x86.msi

2. 安裝Node.js

3. 使用npm全局安裝typescript

   • 進(jìn)入命令行
   • 輸入：npm i -g typescript

4. 創(chuàng)建一個(gè)ts文件

5. 使用tsc對(duì)ts文件進(jìn)行編譯

   • 進(jìn)入命令行

   • 進(jìn)入ts文件所在目錄

   • 執(zhí)行命令：tsc xxx.ts

2、基本類(lèi)型

• 類(lèi)型聲明

  • 類(lèi)型聲明是TS非常重要的一個(gè)特點(diǎn)

  • 通過(guò)類(lèi)型聲明可以指定TS中變量（參數(shù)、形參）的類(lèi)型

  • 指定類(lèi)型后，當(dāng)為變量賦值時(shí)，TS編譯器會(huì)自動(dòng)檢查值是否符合類(lèi)型聲明，符合則賦值，否則報(bào)錯(cuò)

  • 簡(jiǎn)而言之，類(lèi)型聲明給變量設(shè)置了類(lèi)型，使得變量只能存儲(chǔ)某種類(lèi)型的值

  • 語(yǔ)法：

    • let 變量: 類(lèi)型;
      let a: number;let 變量: 類(lèi)型 = 值;
      let a: number = 10;function fn(參數(shù): 類(lèi)型, 參數(shù): 類(lèi)型): 類(lèi)型{...
      }function sum(a: number, b: number): number {return a + b;
      }
      

• 自動(dòng)類(lèi)型判斷

  • TS擁有自動(dòng)的類(lèi)型判斷機(jī)制
  • 當(dāng)對(duì)變量的聲明和賦值是同時(shí)進(jìn)行的，TS編譯器會(huì)自動(dòng)判斷變量的類(lèi)型
  • 所以如果你的變量的聲明和賦值時(shí)同時(shí)進(jìn)行的，可以省略掉類(lèi)型聲明

• 類(lèi)型：

  類(lèi)型	例子	描述
  number	1, -33, 2.5	任意數(shù)字
  string	‘hi’, “hi”, hi	任意字符串
  boolean	true、false	布爾值true或false
  字面量	其本身	限制變量的值就是該字面量的值
  any	*	任意類(lèi)型
  unknown	*	類(lèi)型安全的any
  void	空值（undefined）	沒(méi)有值（或undefined）
  never	沒(méi)有值	不能是任何值
  object	{name:‘孫悟空’}	任意的JS對(duì)象
  array	[1,2,3]	任意JS數(shù)組
  tuple	[4,5]	元素，TS新增類(lèi)型，固定長(zhǎng)度數(shù)組
  enum	enum{A, B}	枚舉，TS中新增類(lèi)型

• number

  • let decimal: number = 6;
    let hex: number = 0xf00d;
    let binary: number = 0b1010;
    let octal: number = 0o744;
    let big: bigint = 100n;
    

• boolean

  • let isDone: boolean = false;
    

• string

  • let color: string = "blue";
    color = 'red';let fullName: string = `Bob Bobbington`;
    let age: number = 37;
    let sentence: string = `Hello, my name is ${fullName}.I'll be ${age + 1} years old next month.`;
    

• 字面量

  • 也可以使用字面量去指定變量的類(lèi)型，通過(guò)字面量可以確定變量的取值范圍(類(lèi)似于常量，限定值或范圍)

  • let color: 'red' | 'blue' | 'black';
    let num: 1 | 2 | 3 | 4 | 5;
    

• any

  • 相當(dāng)于對(duì)該變量關(guān)閉了TS的類(lèi)型檢測(cè)

  • let d: any = 4;
    d = 'hello';
    d = true;
    //隱式
    let e;
    

• unknown

  • unknown類(lèi)型的變量，不能直接賦值給其他變量

  • let notSure: unknown = 4;
    notSure = 'hello';//類(lèi)型檢查
    let s:string;
    if(typeof e === "string"){s = e;
    }//類(lèi)型斷言
    /*
    語(yǔ)法：
    變量 as 類(lèi)型
    <類(lèi)型>變量
    */
    s = e as string;
    //s = <string>e;
    

• void

  • let unusable: void = undefined;//沒(méi)寫(xiě)void，沒(méi)寫(xiě)return，默認(rèn)為void
    function fn(): void {
    }
    

• never

  • 表示永遠(yuǎn)不會(huì)返回結(jié)果

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

• object（沒(méi)啥用）

  • let obj: object = {};// {} 用來(lái)指定對(duì)象中可以包含哪些屬性
    // 語(yǔ)法：{屬性名:屬性值,屬性名:屬性值}
    // 在屬性名后邊加上?，表示屬性是可選的
    let b: { name: string, age?: number };
    b = { name: '孫悟空', age: 18 };//定義對(duì)象結(jié)構(gòu)
    // [propName: string]: any 表示任意類(lèi)型的屬性
    let c: { name: string, [propName: string]: any };
    c = { name: '豬八戒', age: 18, gender: '男' };//定義函數(shù)結(jié)構(gòu)
    /*設(shè)置函數(shù)結(jié)構(gòu)的類(lèi)型聲明：語(yǔ)法：(形參:類(lèi)型, 形參:類(lèi)型 ...) => 返回值
    */
    let d: (a: number, b: number) => number;
    // d = function (n1: string, n2: string): number{
    //     return 10;
    // }
    

• array

  • //類(lèi)型[]
    let list: number[] = [1, 2, 3];//Array<類(lèi)型>
    let list: Array<number> = [1, 2, 3];
    

• tuple

  • let x: [string, number];
    x = ["hello", 10]; 
    

• enum

  • enum Color {Red,Green,Blue,
    }
    let c: Color = Color.Green;enum Color {Red = 1,Green,Blue,
    }
    let c: Color = Color.Green;enum Color {Red = 1,Green = 2,Blue = 4,
    }
    let c: Color = Color.Green;// &表示同時(shí)
    let j: { name: string } & { age: number };
    // j = {name: '孫悟空', age: 18};// 類(lèi)型的別名
    type myType = 1 | 2 | 3 | 4 | 5;
    let k: myType;
    let l: myType;
    let m: myType;k = 2;
    

• 類(lèi)型斷言

  • 有些情況下，變量的類(lèi)型對(duì)于我們來(lái)說(shuō)是很明確，但是TS編譯器卻并不清楚，此時(shí)，可以通過(guò)類(lèi)型斷言來(lái)告訴編譯器變量的類(lèi)型，斷言有兩種形式：

    • 第一種

      • let someValue: unknown = "this is a string";
        let strLength: number = (someValue as string).length;
        

    • 第二種

      • let someValue: unknown = "this is a string";
        let strLength: number = (<string>someValue).length;
        

3、編譯選項(xiàng)

• 自動(dòng)編譯文件

  • 編譯文件時(shí)，使用 -w 指令后，TS編譯器會(huì)自動(dòng)監(jiān)視文件的變化，并在文件發(fā)生變化時(shí)對(duì)文件進(jìn)行重新編譯。

  • 示例：

    • tsc xxx.ts -w
      

• 自動(dòng)編譯整個(gè)項(xiàng)目

  • 如果直接使用tsc指令，則可以自動(dòng)將當(dāng)前項(xiàng)目下的所有ts文件編譯為js文件。

  • 但是能直接使用tsc命令的前提時(shí)，要先在項(xiàng)目根目錄下創(chuàng)建一個(gè)ts的配置文件 tsconfig.json(tsc --init)

  • tsconfig.json是一個(gè)JSON文件，添加配置文件后，只需只需 tsc 命令即可完成對(duì)整個(gè)項(xiàng)目的編譯tsc -w自動(dòng)監(jiān)視所有文件

  • 配置選項(xiàng)：

    • include

      • 定義希望被編譯文件所在的目錄

      • 默認(rèn)值：[“**/*”] (** 表示任意目錄 *表示任意文件)

      • 示例：

        • "include":["src/**/*", "tests/**/*"]
          

        • 上述示例中，所有src目錄和tests目錄下的文件都會(huì)被編譯

    • exclude

      • 定義需要排除在外的目錄

      • 默認(rèn)值：[“node_modules”, “bower_components”, “jspm_packages”]

      • 示例：

        • "exclude": ["./src/hello/**/*"]
          

        • 上述示例中，src下hello目錄下的文件都不會(huì)被編譯

    • extends

      • 定義被繼承的配置文件

      • 示例：

        • "extends": "./configs/base"
          

        • 上述示例中，當(dāng)前配置文件中會(huì)自動(dòng)包含config目錄下base.json中的所有配置信息

    • files

      • 指定被編譯文件的列表，只有需要編譯的文件少時(shí)才會(huì)用到

      • 示例：

        • "files": ["core.ts","sys.ts","types.ts","scanner.ts","parser.ts","utilities.ts","binder.ts","checker.ts","tsc.ts"]
          

        • 列表中的文件都會(huì)被TS編譯器所編譯

      • compilerOptions

        • 編譯選項(xiàng)是配置文件中非常重要也比較復(fù)雜的配置選項(xiàng)

        • 在compilerOptions中包含多個(gè)子選項(xiàng)，用來(lái)完成對(duì)編譯的配置

          • 項(xiàng)目選項(xiàng)

            • target

              • 設(shè)置ts代碼編譯的目標(biāo)版本

              • 可選值：

                • ES3（默認(rèn)）、ES5、ES6/ES2015、ES7/ES2016、ES2017、ES2018、ES2019、ES2020、ESNext(ES最新版本)

              • 示例：

                • "compilerOptions": {"target": "ES6"
                  }
                  

                • 如上設(shè)置，我們所編寫(xiě)的ts代碼將會(huì)被編譯為ES6版本的js代碼

            • lib

              • 指定代碼運(yùn)行時(shí)所包含的庫(kù)（宿主環(huán)境）

              • 可選值：

                • ES5、ES6/ES2015、ES7/ES2016、ES2017、ES2018、ES2019、ES2020、ESNext、DOM、WebWorker、ScriptHost …

              • 示例：

                • "compilerOptions": {"target": "ES6","lib": ["ES6", "DOM"],"outDir": "dist","outFile": "dist/aa.js"
                  }
                  

            • module

              • 設(shè)置編譯后代碼使用的模塊化系統(tǒng)

              • 可選值：

                • CommonJS、UMD、AMD、System、ES2020、ESNext、None

              • 示例：

                • "compilerOptions": {"module": "CommonJS"
                  }
                  

            • outDir

              • 編譯后文件的所在目錄

              • 默認(rèn)情況下，編譯后的js文件會(huì)和ts文件位于相同的目錄，設(shè)置outDir后可以改變編譯后文件的位置

              • 示例：

                • "compilerOptions": {"outDir": "dist"
                  }
                  

                • 設(shè)置后編譯后的js文件將會(huì)生成到dist目錄

            • outFile

              • 將所有的文件編譯為一個(gè)js文件

              • 默認(rèn)會(huì)將所有的編寫(xiě)在全局作用域中的代碼合并為一個(gè)js文件，如果module制定了None、System或AMD則會(huì)將模塊一起合并到文件之中

              • 示例：

                • "compilerOptions": {"outFile": "dist/app.js"
                  }
                  

            • rootDir

              • 指定代碼的根目錄，默認(rèn)情況下編譯后文件的目錄結(jié)構(gòu)會(huì)以最長(zhǎng)的公共目錄為根目錄，通過(guò)rootDir可以手動(dòng)指定根目錄

              • 示例：

                • "compilerOptions": {"rootDir": "./src"
                  }
                  

            • allowJs

              • 是否對(duì)js文件編譯

            • checkJs

              • 是否對(duì)js文件進(jìn)行檢查

              • 示例：

                • "compilerOptions": {"allowJs": true,"checkJs": true
                  }
                  

            • removeComments

              • 是否刪除注釋
              • 默認(rèn)值：false

            • noEmit

              • 不對(duì)代碼進(jìn)行編譯
              • 默認(rèn)值：false

            • sourceMap

              • 是否生成sourceMap
              • 默認(rèn)值：false

          • 嚴(yán)格檢查

            • strict
              • 啟用所有的嚴(yán)格檢查，默認(rèn)值為true，設(shè)置后相當(dāng)于開(kāi)啟了所有的嚴(yán)格檢查
            • alwaysStrict
              • 總是以嚴(yán)格模式對(duì)代碼進(jìn)行編譯
            • noImplicitAny
              • 禁止隱式的any類(lèi)型
            • noImplicitThis
              • 禁止類(lèi)型不明確的this
            • strictBindCallApply
              • 嚴(yán)格檢查bind、call和apply的參數(shù)列表
            • strictFunctionTypes
              • 嚴(yán)格檢查函數(shù)的類(lèi)型
            • strictNullChecks
              • 嚴(yán)格的空值檢查
            • strictPropertyInitialization
              • 嚴(yán)格檢查屬性是否初始化

          • 額外檢查

            • noFallthroughCasesInSwitch
              • 檢查switch語(yǔ)句包含正確的break
            • noImplicitReturns
              • 檢查函數(shù)沒(méi)有隱式的返回值
            • noUnusedLocals
              • 檢查未使用的局部變量
            • noUnusedParameters
              • 檢查未使用的參數(shù)

          • 高級(jí)

            • allowUnreachableCode
              • 檢查不可達(dá)代碼
              • 可選值：
                • true，忽略不可達(dá)代碼
                • false，不可達(dá)代碼將引起錯(cuò)誤
            • noEmitOnError
              • 有錯(cuò)誤的情況下不進(jìn)行編譯
              • 默認(rèn)值：false

4、webpack

• 通常情況下，實(shí)際開(kāi)發(fā)中我們都需要使用構(gòu)建工具對(duì)代碼進(jìn)行打包，TS同樣也可以結(jié)合構(gòu)建工具一起使用，下邊以webpack為例介紹一下如何結(jié)合構(gòu)建工具使用TS。

• 步驟：

  1. 初始化項(xiàng)目

     • 進(jìn)入項(xiàng)目根目錄，執(zhí)行命令 npm init -y
       • 主要作用：創(chuàng)建package.json文件

  2. 下載構(gòu)建工具

     • npm i -D webpack webpack-cli webpack-dev-server typescript ts-loader clean-webpack-plugin
       • 共安裝了7個(gè)包
         • webpack
           • 構(gòu)建工具webpack
         • webpack-cli
           • webpack的命令行工具
         • webpack-dev-server
           • webpack的開(kāi)發(fā)服務(wù)器
         • typescript
           • ts編譯器
         • ts-loader
           • ts加載器，用于在webpack中編譯ts文件
         • html-webpack-plugin
           • webpack中html插件，用來(lái)自動(dòng)創(chuàng)建html文件
         • clean-webpack-plugin
           • webpack中的清除插件，每次構(gòu)建都會(huì)先清除目錄

  3. 根目錄下創(chuàng)建webpack的配置文件webpack.config.js

     • const path = require("path");
       const HtmlWebpackPlugin = require("html-webpack-plugin");
       const { CleanWebpackPlugin } = require("clean-webpack-plugin");module.exports = {optimization:{minimize: false // 關(guān)閉代碼壓縮，可選},entry: "./src/index.ts",devtool: "inline-source-map",devServer: {contentBase: './dist'},output: {path: path.resolve(__dirname, "dist"),filename: "bundle.js",environment: {arrowFunction: false // 關(guān)閉webpack的箭頭函數(shù)，可選}},resolve: {extensions: [".ts", ".js"]},module: {rules: [{test: /\.ts$/,use: {loader: "ts-loader"     },exclude: /node_modules/}]},plugins: [new CleanWebpackPlugin(),new HtmlWebpackPlugin({title:'TS測(cè)試'}),]}
       

  4. 根目錄下創(chuàng)建tsconfig.json，配置可以根據(jù)自己需要

     • {"compilerOptions": {"target": "ES2015","module": "ES2015","strict": true}
       }
       

  5. 修改package.json添加如下配置

     • {...略..."scripts": {"test": "echo \"Error: no test specified\" && exit 1","build": "webpack","start": "webpack serve --open chrome.exe"},...略...
       }
       

  6. 在src下創(chuàng)建ts文件，并在并命令行執(zhí)行npm run build對(duì)代碼進(jìn)行編譯，或者執(zhí)行npm start來(lái)啟動(dòng)開(kāi)發(fā)服務(wù)器

5、Babel

• 經(jīng)過(guò)一系列的配置，使得TS和webpack已經(jīng)結(jié)合到了一起，除了webpack，開(kāi)發(fā)中還經(jīng)常需要結(jié)合babel來(lái)對(duì)代碼進(jìn)行轉(zhuǎn)換以使其可以兼容到更多的瀏覽器，在上述步驟的基礎(chǔ)上，通過(guò)以下步驟再將babel引入到項(xiàng)目中。

  1. 安裝依賴包：

     • npm i -D @babel/core @babel/preset-env babel-loader core-js
     • 共安裝了4個(gè)包，分別是：
       • @babel/core
         • babel的核心工具
       • @babel/preset-env
         • babel的預(yù)定義環(huán)境
       • @babel-loader
         • babel在webpack中的加載器
       • core-js
         • core-js用來(lái)使老版本的瀏覽器支持新版ES語(yǔ)法

  2. 修改webpack.config.js配置文件

     • ...略...
       module: {rules: [{test: /\.ts$/,use: [{loader: "babel-loader",options:{presets: [["@babel/preset-env",{"targets":{"chrome": "58","ie": "11"},"corejs":"3","useBuiltIns": "usage"}]]}},{loader: "ts-loader",}],exclude: /node_modules/}]
       }
       ...略...
       

     • 如此一來(lái)，使用ts編譯后的文件將會(huì)再次被babel處理，使得代碼可以在大部分瀏覽器中直接使用，可以在配置選項(xiàng)的targets中指定要兼容的瀏覽器版本。

第二章：面向?qū)ο?/h1>

0、面向?qū)ο蠛?jiǎn)介

面向?qū)ο笫浅绦蛑幸粋€(gè)非常重要的思想，它被很多同學(xué)理解成了一個(gè)比較難，比較深?yuàn)W的問(wèn)題，其實(shí)不然。面向?qū)ο蠛芎?jiǎn)單，簡(jiǎn)而言之就是程序之中所有的操作都需要通過(guò)對(duì)象來(lái)完成。

• 舉例來(lái)說(shuō)：
  • 操作瀏覽器要使用window對(duì)象
  • 操作網(wǎng)頁(yè)要使用document對(duì)象
  • 操作控制臺(tái)要使用console對(duì)象

一切操作都要通過(guò)對(duì)象，也就是所謂的面向?qū)ο?#xff0c;那么對(duì)象到底是什么呢？這就要先說(shuō)到程序是什么，計(jì)算機(jī)程序的本質(zhì)就是對(duì)現(xiàn)實(shí)事物的抽象，抽象的反義詞是具體，比如：照片是對(duì)一個(gè)具體的人的抽象，汽車(chē)模型是對(duì)具體汽車(chē)的抽象等等。程序也是對(duì)事物的抽象，在程序中我們可以表示一個(gè)人、一條狗、一把槍、一顆子彈等等所有的事物。一個(gè)事物到了程序中就變成了一個(gè)對(duì)象。

在程序中所有的對(duì)象都被分成了兩個(gè)部分?jǐn)?shù)據(jù)和功能，以人為例，人的姓名、性別、年齡、身高、體重等屬于數(shù)據(jù)，人可以說(shuō)話、走路、吃飯、睡覺(jué)這些屬于人的功能。數(shù)據(jù)在對(duì)象中被成為屬性，而功能就被稱為方法。所以簡(jiǎn)而言之，在程序中一切皆是對(duì)象。

1、類(lèi)（class）

要想面向?qū)ο?#xff0c;操作對(duì)象，首先便要擁有對(duì)象，那么下一個(gè)問(wèn)題就是如何創(chuàng)建對(duì)象。要?jiǎng)?chuàng)建對(duì)象，必須要先定義類(lèi)，所謂的類(lèi)可以理解為對(duì)象的模型，程序中可以根據(jù)類(lèi)創(chuàng)建指定類(lèi)型的對(duì)象，舉例來(lái)說(shuō)：可以通過(guò)Person類(lèi)來(lái)創(chuàng)建人的對(duì)象，通過(guò)Dog類(lèi)創(chuàng)建狗的對(duì)象，通過(guò)Car類(lèi)來(lái)創(chuàng)建汽車(chē)的對(duì)象，不同的類(lèi)可以用來(lái)創(chuàng)建不同的對(duì)象。

• 定義類(lèi)：

  • class 類(lèi)名 {屬性名: 類(lèi)型;constructor(參數(shù): 類(lèi)型){this.屬性名 = 參數(shù);}方法名(){....}}
    

• 示例：

  • class Person{name: string;age: number;constructor(name: string, age: number){this.name = name;this.age = age;}sayHello(){console.log(`大家好，我是${this.name}`);}
    }
    

• 使用類(lèi)：

  • const p = new Person('孫悟空', 18);
    p.sayHello();
    

• 直接定義的屬性是實(shí)例屬性，需要通過(guò)對(duì)象的實(shí)例去訪問(wèn)；使用static開(kāi)頭的屬性是靜態(tài)屬性（類(lèi)屬性），可以直接通過(guò)類(lèi)去訪問(wèn)static readonly age: number = 18;；readonly開(kāi)頭的屬性表示一個(gè)只讀的屬性無(wú)法修改readonly name: string = '孫悟空';

2、面向?qū)ο蟮奶攸c(diǎn)

• 封裝

  • 對(duì)象實(shí)質(zhì)上就是屬性和方法的容器，它的主要作用就是存儲(chǔ)屬性和方法，這就是所謂的封裝

  • 默認(rèn)情況下，對(duì)象的屬性是可以任意的修改的，為了確保數(shù)據(jù)的安全性，在TS中可以對(duì)屬性的權(quán)限進(jìn)行設(shè)置

  • 只讀屬性（readonly）：

    • 如果在聲明屬性時(shí)添加一個(gè)readonly，則屬性便成了只讀屬性無(wú)法修改

  • TS中屬性具有三種修飾符：

    • public（默認(rèn)值），可以在類(lèi)、子類(lèi)和對(duì)象中修改
    • protected ，可以在類(lèi)、子類(lèi)中修改
    • private ，可以在類(lèi)中修改

  • 示例：

    • public

      • class Person{public name: string; // 寫(xiě)或什么都不寫(xiě)都是publicpublic age: number;constructor(name: string, age: number){this.name = name; // 可以在類(lèi)中修改this.age = age;}sayHello(){console.log(`大家好，我是${this.name}`);}
        }class Employee extends Person{constructor(name: string, age: number){super(name, age);this.name = name; //子類(lèi)中可以修改}
        }const p = new Person('孫悟空', 18);
        p.name = '豬八戒';// 可以通過(guò)對(duì)象修改
        

    • protected

      • class Person{protected name: string;protected age: number;constructor(name: string, age: number){this.name = name; // 可以修改this.age = age;}sayHello(){console.log(`大家好，我是${this.name}`);}
        }class Employee extends Person{constructor(name: string, age: number){super(name, age);this.name = name; //子類(lèi)中可以修改}
        }const p = new Person('孫悟空', 18);
        p.name = '豬八戒';// 不能修改
        

    • private

      • class Person{private name: string;private age: number;constructor(name: string, age: number){this.name = name; // 可以修改this.age = age;}sayHello(){console.log(`大家好，我是${this.name}`);}
        }class Employee extends Person{constructor(name: string, age: number){super(name, age);this.name = name; //子類(lèi)中不能修改}
        }const p = new Person('孫悟空', 18);
        p.name = '豬八戒';// 不能修改
        

  • 屬性存取器

    • 對(duì)于一些不希望被任意修改的屬性，可以將其設(shè)置為private

    • 直接將其設(shè)置為private將導(dǎo)致無(wú)法再通過(guò)對(duì)象修改其中的屬性

    • 我們可以在類(lèi)中定義一組讀取、設(shè)置屬性的方法，這種對(duì)屬性讀取或設(shè)置的屬性被稱為屬性的存取器

    • 讀取屬性的方法叫做setter方法，設(shè)置屬性的方法叫做getter方法

    • 示例：

      • class Person{private _name: string;constructor(name: string){this._name = name;}get name(){return this._name;}set name(name: string){this._name = name;}}const p1 = new Person('孫悟空');
        console.log(p1.name); // 通過(guò)getter讀取name屬性
        p1.name = '豬八戒'; // 通過(guò)setter修改name屬性
        

  • 靜態(tài)屬性

    • 靜態(tài)屬性（方法），也稱為類(lèi)屬性。使用靜態(tài)屬性無(wú)需創(chuàng)建實(shí)例，通過(guò)類(lèi)即可直接使用

    • 靜態(tài)屬性（方法）使用static開(kāi)頭

    • 示例：

      • class Tools{static PI = 3.1415926;static sum(num1: number, num2: number){return num1 + num2}
        }console.log(Tools.PI);
        console.log(Tools.sum(123, 456));
        

  • this

    • 在類(lèi)中，使用this表示當(dāng)前對(duì)象

• 繼承

  • 繼承時(shí)面向?qū)ο笾械挠忠粋€(gè)特性

  • 通過(guò)繼承可以將其他類(lèi)中的屬性和方法引入到當(dāng)前類(lèi)中

    • 示例：

      • class Animal{name: string;age: number;constructor(name: string, age: number){this.name = name;this.age = age;}
        }class Dog extends Animal{bark(){console.log(`${this.name}在汪汪叫！`);}
        }const dog = new Dog('旺財(cái)', 4);
        dog.bark();
        

  • 通過(guò)繼承可以在不修改類(lèi)的情況下完成對(duì)類(lèi)的擴(kuò)展

  • 重寫(xiě)

    • 發(fā)生繼承時(shí)，如果子類(lèi)中的方法會(huì)替換掉父類(lèi)中的同名方法，這就稱為方法的重寫(xiě)

    • 示例：

      • class Animal{name: string;age: number;constructor(name: string, age: number){this.name = name;this.age = age;}run(){console.log(`父類(lèi)中的run方法！`);}
        }class Dog extends Animal{bark(){console.log(`${this.name}在汪汪叫！`);}run(){console.log(`子類(lèi)中的run方法，會(huì)重寫(xiě)父類(lèi)中的run方法！`);}
        }const dog = new Dog('旺財(cái)', 4);
        dog.bark();
        

      • 在子類(lèi)中可以使用super來(lái)完成對(duì)父類(lèi)的引用(構(gòu)造函數(shù))

  • 抽象類(lèi)（abstract class）

    • 抽象類(lèi)是專門(mén)用來(lái)被其他類(lèi)所繼承的類(lèi)，它只能被其他類(lèi)所繼承不能用來(lái)創(chuàng)建實(shí)例

    • abstract class Animal{abstract run(): void;bark(){console.log('動(dòng)物在叫~');}
      }class Dog extends Animals{run(){console.log('狗在跑~');}
      }
      

    • 使用abstract開(kāi)頭的方法叫做抽象方法，抽象方法沒(méi)有方法體只能定義在抽象類(lèi)中，繼承抽象類(lèi)時(shí)抽象方法必須要實(shí)現(xiàn)

3、接口（Interface）

接口的作用類(lèi)似于抽象類(lèi)，不同點(diǎn)在于接口中的所有方法和屬性都是沒(méi)有實(shí)值的，換句話說(shuō)接口中的所有方法都是抽象方法。接口主要負(fù)責(zé)定義一個(gè)類(lèi)的結(jié)構(gòu)，接口可以去限制一個(gè)對(duì)象的接口，對(duì)象只有包含接口中定義的所有屬性和方法時(shí)才能匹配接口。同時(shí)，可以讓一個(gè)類(lèi)去實(shí)現(xiàn)接口，實(shí)現(xiàn)接口時(shí)類(lèi)中要保護(hù)接口中的所有屬性。

• 示例（檢查對(duì)象類(lèi)型）：

  • interface Person{name: string;sayHello():void;
    }function fn(per: Person){per.sayHello();
    }fn({name:'孫悟空', sayHello() {console.log(`Hello, 我是 ${this.name}`)}});

• 示例（實(shí)現(xiàn)）

  • interface Person{name: string;sayHello():void;
    }class Student implements Person{constructor(public name: string) {}sayHello() {console.log('大家好，我是'+this.name);}
    }
    

4、泛型（Generic）

定義一個(gè)函數(shù)或類(lèi)時(shí)，有些情況下無(wú)法確定其中要使用的具體類(lèi)型（返回值、參數(shù)、屬性的類(lèi)型不能確定），此時(shí)泛型便能夠發(fā)揮作用。

• 舉個(gè)例子：

  • function test(arg: any): any{return arg;
    }
    

  • 上例中，test函數(shù)有一個(gè)參數(shù)類(lèi)型不確定，但是能確定的時(shí)其返回值的類(lèi)型和參數(shù)的類(lèi)型是相同的，由于類(lèi)型不確定所以參數(shù)和返回值均使用了any，但是很明顯這樣做是不合適的，首先使用any會(huì)關(guān)閉TS的類(lèi)型檢查，其次這樣設(shè)置也不能體現(xiàn)出參數(shù)和返回值是相同的類(lèi)型

  • 使用泛型：

  • function test<T>(arg: T): T{return arg;
    }
    

  • 這里的<T>就是泛型，T是我們給這個(gè)類(lèi)型起的名字（不一定非叫T），設(shè)置泛型后即可在函數(shù)中使用T來(lái)表示該類(lèi)型。所以泛型其實(shí)很好理解，就表示某個(gè)類(lèi)型。

  • 那么如何使用上邊的函數(shù)呢？

    • 方式一（直接使用）：

      • test(10)
        

      • 使用時(shí)可以直接傳遞參數(shù)使用，類(lèi)型會(huì)由TS自動(dòng)推斷出來(lái)，但有時(shí)編譯器無(wú)法自動(dòng)推斷時(shí)還需要使用下面的方式

    • 方式二（指定類(lèi)型）：

      • test<number>(10)
        

      • 也可以在函數(shù)后手動(dòng)指定泛型

  • 可以同時(shí)指定多個(gè)泛型，泛型間使用逗號(hào)隔開(kāi)：

    • function test<T, K>(a: T, b: K): K{return b;
      }test<number, string>(10, "hello");
      

    • 使用泛型時(shí)，完全可以將泛型當(dāng)成是一個(gè)普通的類(lèi)去使用

  • 類(lèi)中同樣可以使用泛型：

    • class MyClass<T>{prop: T;constructor(prop: T){this.prop = prop;}
      }
      

  • 除此之外，也可以對(duì)泛型的范圍進(jìn)行約束

    • interface MyInter{length: number;
      }function test<T extends MyInter>(arg: T): number{return arg.length;
      }
      

    • 使用T extends MyInter表示泛型T必須是MyInter的子類(lèi)，不一定非要使用接口類(lèi)和抽象類(lèi)同樣適用。