尚硅谷TypeScript教程（李立超老师TS新课）笔记附带源码

于 2023-08-13 13:23:39 发布
阅读量322 收藏 2
点赞数
文章标签： typescript javascript 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46720238/article/details/132258730
版权

 仅供个人学习使用 末尾附B站链接

第一章 快速入门

0、TypeScript简介

  1. TypeScript是JavaScript的超集。
  2. 它对JS进行了扩展，向JS中引入了类型的概念，并添加了许多新的特性。
  3. TS代码需要通过编译器编译为JS，然后再交由JS解析器执行。
  4. TS完全兼容JS，换言之，任何的JS代码都可以直接当成JS使用。
  5. 相较于JS而言，TS拥有了静态类型，更加严格的语法，更强大的功能；TS可以在代码执行前就完成代码的检查，减小了运行时异常的出现的几率；TS代码可以编译为任意版本的JS代码，可有效解决不同JS运行环境的兼容问题；同样的功能，TS的代码量要大于JS，但由于TS的代码结构更加清晰，变量类型更加明确，在后期代码的维护中TS却远远胜于JS。

1、TypeScript 开发环境搭建

  1. 下载Node.js
  1. 安装Node.js
  2. 使用npm全局安装typescript
    • 进入命令行
    • 输入：npm i -g typescript
  1. 创建一个ts文件
  2. 使用tsc对ts文件进行编译
    • 进入命令行
    • 进入ts文件所在目录
    • 执行命令：tsc xxx.ts

1.1、basis

// 声明一个变量a，同时指定它的类型为number
let a: number;

// a 的类型设置为了number，在以后的使用过程中a的值只能是数字
a = 10;
a = 33;
// a = 'hello'; // 此行代码会报错，因为变量a的类型是number，不能赋值字符串
let b: string;
b = 'hello';
// b = 123;

// 声明完变量直接进行赋值
// let c: boolean = false;

// 如果变量的声明和赋值是同时进行的，TS可以自动对变量进行类型检测
let c = false;
c = true;

// JS中的函数是不考虑参数的类型和个数的
// function sum(a, b){
//     return a + b;
// }

// console.log(sum(123, 456)); // 579
// console.log(sum(123, "456")); // "123456"

function sum(a: number, b: number): number{
    return a + b;
}

let result = sum(123, 456);

2、基本类型

  • 类型声明
    • 类型声明是TS非常重要的一个特点
    • 通过类型声明可以指定TS中变量（参数、形参）的类型
    • 指定类型后，当为变量赋值时，TS编译器会自动检查值是否符合类型声明，符合则赋值，否则报错
    • 简而言之，类型声明给变量设置了类型，使得变量只能存储某种类型的值
    • 语法：
let 变量: 类型;

let 变量: 类型 = 值;

function fn(参数: 类型, 参数: 类型): 类型{
  ...
}
  • 自动类型判断
    • TS拥有自动的类型判断机制
    • 当对变量的声明和赋值是同时进行的，TS编译器会自动判断变量的类型
    • 所以如果你的变量的声明和赋值时同时进行的，可以省略掉类型声明
  • 类型：

类型

例子

描述

number

1, -33, 2.5

任意数字

string

'hi', "hi", hi

任意字符串

boolean

true、false

布尔值true或false

字面量

其本身

限制变量的值就是该字面量的值

any

*

任意类型

unknown

*

类型安全的any

void

空值（undefined）

没有值（或undefined）

never

没有值

不能是任何值

object

{name:'孙悟空'}

任意的JS对象

array

[1,2,3]

任意JS数组

tuple

[4,5]

元素，TS新增类型，固定长度数组

enum

enum{A, B}

枚举，TS中新增类型

  • 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.`;
  • 字面量
    • 也可以使用字面量去指定变量的类型，通过字面量可以确定变量的取值范围
let color: 'red' | 'blue' | 'black';
let num: 1 | 2 | 3 | 4 | 5;
  • any
let d: any = 4;
d = 'hello';
d = true;
  • unknown
let notSure: unknown = 4;
notSure = 'hello';
  • void
let unusable: void = undefined;
  • never
function error(message: string): never {
  throw new Error(message);
}
  • object（没啥用）
let obj: object = {};
  • array
let list: number[] = [1, 2, 3];
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;
  • 类型断言
    • 有些情况下，变量的类型对于我们来说是很明确，但是TS编译器却并不清楚，此时，可以通过类型断言来告诉编译器变量的类型，断言有两种形式：
      • 第一种
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;

2.1、types

// 也可以直接使用字面量进行类型声明
let a: 10;
a = 10;

// 可以使用 | 来连接多个类型（联合类型）
let b: "male" | "female";
b = "male";
b = "female";
let c: boolean | string;
c = true;
c = 'hello';

// any 表示的是任意类型，一个变量设置类型为any后相当于对该变量关闭了TS的类型检测
// 使用TS时，不建议使用any类型
// let d: any;

// 声明变量如果不指定类型，则TS解析器会自动判断变量的类型为any （隐式的any）
let d;
d = 10;
d = 'hello';
d = true;

// unknown 表示未知类型的值
let e: unknown;
e = 10;
e = "hello";
e = true;

let s:string;

// d的类型是any，它可以赋值给任意变量
// s = d;

e = 'hello';

// unknown 实际上就是一个类型安全的any
// unknown类型的变量，不能直接赋值给其他变量
// s = e;
if(typeof e === "string"){ //只有当e得类型是string的时候 才会被赋值
    s = e;
}

// 类型断言，可以用来告诉解析器变量的实际类型
/*
* 语法：
*   变量 as 类型
*   <类型>变量
*
* */
s = e as string;
s = <string>e;

// void 用来表示空，以函数为例，就表示没有返回值的函数
function fn(): void{
}

// never 表示永远不会返回结果
function fn2(): never{
    throw new Error('报错了！');
}
fn2()

// object表示一个js对象
let a: object;
a = {};
a = function () {
};

// {} 用来指定对象中可以包含哪些属性
// 语法：{属性名:属性值,属性名:属性值}
// 在属性名后边加上?，表示属性是可选的
let b: {name: string, age?: number};
b = {name: '孙悟空'};
b = {name: '孙悟空', age: 18};

// [propName: string]: any ---表示任意类型的属性
let c: {name: string, [propName: string]: any};
c = {name: '猪八戒', age: 18, gender: '男'};

/*
*   设置函数结构的类型声明：
*       语法：(形参:类型, 形参:类型 ...) => 返回值
* */
let d: (a: number ,b: number)=>number;
// d = function (n1: string, n2: string): number{
//     return 10;
// }


/*
*   数组的类型声明：
*       类型[]
*       Array<类型>
* */
// string[] 表示字符串数组
let e: string[];
e = ['a', 'b', 'c'];

// number[] 表示数值数值
let f: number[];

let g: Array<number>;
g = [1, 2, 3];

/*
*   元组，元组就是固定长度的数组
*       语法：[类型, 类型, 类型]
* */
let h: [string, number];
h = ['hello', 123];

/*
* enum 枚举
*
* */
enum Gender{
    Male,
    Female
}

let i: {name: string, gender: Gender};
i = {
    name: '孙悟空',
    gender: Gender.Male // 'male'
}

// console.log(i.gender === Gender.Male);
// &表示同时
let j: { name: string } & { age: number };
// j = {name: '孙悟空', age: 18};


// 类型的别名
type myType = 1 | 2 | 3 | 4 | 5;
let k: myType;
let l: myType;
let m: myType;

k = 2;

3、编译选项

1. 自动编译文件

    • 编译文件时，使用 -w 指令后，TS编译器会自动监视文件的变化，并在文件发生变化时对文件进行重新编译。
    • 示例：
      • tsc xxx.ts -w

2. 自动编译整个项目

    • 如果直接使用tsc指令，则可以自动将当前项目下的所有ts文件编译为js文件。
    • 但是能直接使用tsc命令的前提时，要先在项目根目录下创建一个ts的配置文件 tsconfig.json
    • tsconfig.json是一个JSON文件，添加配置文件后，只需只需 tsc 命令即可完成对整个项目的编译
    • 配置选项：
a. include
        • 定义希望被编译文件所在的目录
        • 默认值：["**/*"]
        • 示例：
          • "include":["src/**/*", "tests/**/*"]
          • 上述示例中，所有src目录和tests目录下的文件都会被编译
b. exclude
        • 定义需要排除在外的目录
        • 默认值：["node_modules", "bower_components", "jspm_packages"]
        • 示例：
          • "exclude": ["./src/hello/**/*"]
          • 上述示例中，src下hello目录下的文件都不会被编译
c. extends
        • 定义被继承的配置文件
        • 示例：
          • "extends": "./configs/base"
          • 上述示例中，当前配置文件中会自动包含config目录下base.json中的所有配置信息
d. files
        • 指定被编译文件的列表，只有需要编译的文件少时才会用到
        • 示例：
"files": [
    "core.ts",
    "sys.ts",
    "types.ts",
    "scanner.ts",
    "parser.ts",
    "utilities.ts",
    "binder.ts",
    "checker.ts",
    "tsc.ts"
  ]
          • 列表中的文件都会被TS编译器所编译
e. compilerOptions
        • 编译选项是配置文件中非常重要也比较复杂的配置选项
        • 在compilerOptions中包含多个子选项，用来完成对编译的配置
ⅰ. 项目选项
1. target
                • 设置ts代码编译的目标版本
                • 可选值：
                  • ES3（默认）、ES5、ES6/ES2015、ES7/ES2016、ES2017、ES2018、ES2019、ES2020、ESNext
                • 示例：
"compilerOptions": {
    "target": "ES6"
}
                  • 如上设置，我们所编写的ts代码将会被编译为ES6版本的js代码
2. lib
                • 指定代码运行时所包含的库（宿主环境）
                • 可选值：
                  • 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"
}
3. module
                • 设置编译后代码使用的模块化系统
                • 可选值：
                  • CommonJS、UMD、AMD、System、ES2020、ESNext、None、es6、es2015
                • 示例：
"compilerOptions": {
    "module": "CommonJS"
}
4. outDir
                • 编译后文件的所在目录
                • 默认情况下，编译后的js文件会和ts文件位于相同的目录，设置outDir后可以改变编译后文件的位置
                • 示例：
"compilerOptions": {
    "outDir": "dist"
}
                  • 设置后编译后的js文件将会生成到dist目录
5. outFile
                • 将所有的文件编译为一个js文件
                • 默认会将所有的编写在全局作用域中的代码合并为一个js文件，如果module制定了None、System或AMD则会将模块一起合并到文件之中
                • 示例：
"compilerOptions": {
    "outFile": "dist/app.js"
}
6. rootDir
                • 指定代码的根目录，默认情况下编译后文件的目录结构会以最长的公共目录为根目录，通过rootDir可以手动指定根目录
                • 示例：
"compilerOptions": {
    "rootDir": "./src"
}
7. allowJs
                • 是否对js文件编译
8. checkJs
                • 是否对js文件进行检查
                • 示例：
"compilerOptions": {
    "allowJs": true,
    "checkJs": true
}
9. removeComments
                • 是否删除注释
                • 默认值：false
10. noEmit
                • 不对代码进行编译
                • 默认值：false
11. sourceMap
                • 是否生成sourceMap
                • 默认值：false
ⅱ. 严格检查
              • strict
                • 启用所有的严格检查，默认值为true，设置后相当于开启了所有的严格检查
              • alwaysStrict
                • 总是以严格模式对代码进行编译
              • noImplicitAny
                • 禁止隐式的any类型
              • noImplicitThis
                • 禁止类型不明确的this
              • strictBindCallApply
                • 严格检查bind、call和apply的参数列表
              • strictFunctionTypes
                • 严格检查函数的类型
              • strictNullChecks
                • 严格的空值检查
              • strictPropertyInitialization
                • 严格检查属性是否初始化
ⅲ. 额外检查
              • noFallthroughCasesInSwitch
                • 检查switch语句包含正确的break
              • noImplicitReturns
                • 检查函数没有隐式的返回值
              • noUnusedLocals
                • 检查未使用的局部变量
              • noUnusedParameters
                • 检查未使用的参数
ⅳ. 高级
              • allowUnreachableCode
                • 检查不可达代码
                • 可选值：
                  • true，忽略不可达代码
                  • false，不可达代码将引起错误
              • noEmitOnError
                • 有错误的情况下不进行编译
                • 默认值：false

3.1、tsconfig.json

{
/*
  tsconfig.json是ts编译器的配置文件，ts编译器可以根据它的信息来对代码进行编译
    "include" 用来指定哪些ts文件需要被编译
      路径：** 表示任意目录
            * 表示任意文件
    "exclude" 不需要被编译的文件目录
        默认值：["node_modules", "bower_components", "jspm_packages"]

*/
  "include": [
    "./src/**/*"
  ],
//  "exclude": [
//    "./src/hello/**/*"
//  ]

  /*
    compilerOptions 编译器的选项
  */
  "compilerOptions": {

    // target 用来指定ts被编译为的ES的版本
    // 'es3', 'es5', 'es6', 'es2015', 'es2016', 'es2017', 'es2018', 'es2019', 'es2020', 'esnext'
    "target": "es2015",
    // module 指定要使用的模块化的规范
    // 'none', 'commonjs', 'amd', 'system', 'umd', 'es6', 'es2015', 'es2020', 'esnext'
    "module": "es2015",
    // lib用来指定项目中要使用的库
    //'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'es
    //2018', 'es2019', 'es2020', 'esnext', 'dom', 'dom.iterable', 'webworker', 'webworker.importscripts', 'webworker.iterable', 'scri
    //pthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.r
    //eflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.st
    //ring', 'es2017.intl', 'es2017.typedarrays', 'es2018.asyncgenerator', 'es2018.asynciterable', 'es2018.intl', 'es2018.promise', '
    //es2018.regexp', 'es2019.array', 'es2019.object', 'es2019.string', 'es2019.symbol', 'es2020.bigint', 'es2020.promise', 'es2020.s
    //haredmemory', 'es2020.string', 'es2020.symbol.wellknown', 'es2020.intl', 'esnext.array', 'esnext.symbol', 'esnext.asynciterable
    //', 'esnext.intl', 'esnext.bigint', 'esnext.string', 'esnext.promise', 'esnext.weakref'
//    "lib": ["es6", "dom"]


    // outDir 用来指定编译后文件所在的目录
    "outDir": "./dist",

    // 将代码合并为一个文件
    // 设置outFile后，所有的全局作用域中的代码会合并到同一个文件中
    //"outFile": "./dist/app.js"

    // 是否对js文件进行编译，默认是false
//    "allowJs": true,
    // 是否检查js代码是否符合语法规范，默认是false
//    "checkJs": true,
    // 是否移除注释
    "removeComments": true,
    // 不生成编译后的文件
    "noEmit": false,


    // 当有错误时不生成编译后的文件
    "noEmitOnError": true,

    // 所有严格检查的总开关
    "strict": true,

    // 用来设置编译后的文件是否使用严格模式，默认false
    "alwaysStrict": true,

    // 不允许隐式的any类型
    "noImplicitAny": true,

    // 不允许不明确类型的this
    "noImplicitThis": true,

    // 严格的检查空值
    "strictNullChecks": true


  }
}

4、webpack

  • 通常情况下，实际开发中我们都需要使用构建工具对代码进行打包，TS同样也可以结合构建工具一起使用，下边以webpack为例介绍一下如何结合构建工具使用TS。
  • 步骤：
    1. 初始化项目
      • 进入项目根目录，执行命令 npm init -y
        • 主要作用：创建package.json文件
    1. 下载构建工具
      • npm i -D webpack webpack-cli webpack-dev-server typescript ts-loader clean-webpack-plugin
        • 共安装了7个包
          • webpack
            • 构建工具webpack
          • webpack-cli
            • webpack的命令行工具
          • webpack-dev-server
            • webpack的开发服务器
          • typescript
            • ts编译器
          • ts-loader
            • ts加载器，用于在webpack中编译ts文件
          • html-webpack-plugin
            • webpack中html插件，用来自动创建html文件
          • clean-webpack-plugin
            • webpack中的清除插件，每次构建都会先清除目录
    1. 根目录下创建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 // 关闭代码压缩，可选
  },

  entry: "./src/index.ts",

  devtool: "inline-source-map",

  devServer: {
    contentBase: './dist'
  },

  output: {
    path: path.resolve(__dirname, "dist"),
    filename: "bundle.js",
    environment: {
      arrowFunction: false // 关闭webpack的箭头函数，可选
    }
  },

  resolve: {
    extensions: [".ts", ".js"]
  },

  module: {
    rules: [
      {
        test: /\.ts$/,
        use: {
          loader: "ts-loader"     
        },
        exclude: /node_modules/
      }
    ]
  },

  plugins: [
    new CleanWebpackPlugin(),
    new HtmlWebpackPlugin({
      title:'TS测试'
    }),
  ]

}
    1. 根目录下创建tsconfig.json，配置可以根据自己需要
{
  "compilerOptions": {
    "target": "ES2015",
      "module": "ES2015",
      "strict": true
  }
}
    1. 修改package.json添加如下配置
{
  ...略...
    "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
      "build": "webpack",
      "start": "webpack serve --open chrome.exe"
  },
    ...略...
    }
    1. 在src下创建ts文件，并在并命令行执行npm run build对代码进行编译，或者执行npm start来启动开发服务器

5、Babel

  • 经过一系列的配置，使得TS和webpack已经结合到了一起，除了webpack，开发中还经常需要结合babel来对代码进行转换以使其可以兼容到更多的浏览器，在上述步骤的基础上，通过以下步骤再将babel引入到项目中。
    1. 安装依赖包：
      • npm i -D @babel/core @babel/preset-env babel-loader core-js
      • 共安装了4个包，分别是：
        • @babel/core
          • babel的核心工具
        • @babel/preset-env
          • babel的预定义环境
        • @babel-loader
          • babel在webpack中的加载器
        • core-js
          • core-js用来使老版本的浏览器支持新版ES语法
    1. 修改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/
      }
    ]
  }
  ...略...
      • 如此一来，使用ts编译后的文件将会再次被babel处理，使得代码可以在大部分浏览器中直接使用，可以在配置选项的targets中指定要兼容的浏览器版本。

第二章：面向对象

面向对象是程序中一个非常重要的思想，它被很多同学理解成了一个比较难，比较深奥的问题，其实不然。面向对象很简单，简而言之就是程序之中所有的操作都需要通过对象来完成。

  • 举例来说：
    • 操作浏览器要使用window对象
    • 操作网页要使用document对象
    • 操作控制台要使用console对象

一切操作都要通过对象，也就是所谓的面向对象，那么对象到底是什么呢？这就要先说到程序是什么，计算机程序的本质就是对现实事物的抽象，抽象的反义词是具体，比如：照片是对一个具体的人的抽象，汽车模型是对具体汽车的抽象等等。程序也是对事物的抽象，在程序中我们可以表示一个人、一条狗、一把枪、一颗子弹等等所有的事物。一个事物到了程序中就变成了一个对象。

在程序中所有的对象都被分成了两个部分数据和功能，以人为例，人的姓名、性别、年龄、身高、体重等属于数据，人可以说话、走路、吃饭、睡觉这些属于人的功能。数据在对象中被成为属性，而功能就被称为方法。所以简而言之，在程序中一切皆是对象。

1、类（class）

要想面向对象，操作对象，首先便要拥有对象，那么下一个问题就是如何创建对象。要创建对象，必须要先定义类，所谓的类可以理解为对象的模型，程序中可以根据类创建指定类型的对象，举例来说：可以通过Person类来创建人的对象，通过Dog类创建狗的对象，通过Car类来创建汽车的对象，不同的类可以用来创建不同的对象。

  • 定义类：
class 类名 {
  属性名: 类型;

  constructor(参数: 类型){
    this.属性名 = 参数;
  }

  方法名(){
    ....
  }

}
  • 示例：
class Person{
  name: string;
  age: number;

  constructor(name: string, age: number){
    this.name = name;
    this.age = age;
  }

  sayHello(){
    console.log(`大家好，我是${this.name}`);
  }
}
  • 使用类：
const p = new Person('孙悟空', 18);
p.sayHello();

类 code

// 使用class关键字来定义一个类
/*
*   对象中主要包含了两个部分：
*       属性
*       方法
* */
class Person{

    /*
    *   直接定义的属性是实例属性，需要通过对象的实例去访问：
    *       const per = new Person();
    *       per.name
    *
    *   使用static开头的属性是静态属性（类属性），可以直接通过类去访问
    *       Person.age
    *
    *   readonly开头的属性表示一个只读的属性无法修改
    * */

    // 定义实例属性
    // readonly name: string = '孙悟空';
    name = '孙悟空';

    // 在属性前使用static关键字可以定义类属性（静态属性）
    // static readonly age: number = 18;
    // age = 18;


    // 定义方法
    /*
    * 如果方法以static开头则方法就是类方法，可以直接通过类去调用
    * */
    // static sayHello(){
    //     console.log('Hello 大家好！');
    // }
    sayHello(){
        console.log('Hello 大家好！');
    }

}

const per = new Person();

// console.log(per); //Person { name: '孙悟空', age: 18 }
// console.log(per.name, per.age); //孙悟空 18

// console.log(Person.age); //18  用static开头的属性是静态属性（类属性），可以直接通过类去访问

// console.log(per.name); //孙悟空
// per.name = 'tom';
// console.log(per.name); //tom

// per.sayHello(); //Hello 大家好！

// Person.sayHello();  //Hello 大家好！ 如果方法以static开头则方法就是类方法，可以直接通过类去调用
per.sayHello(); //Hello 大家好！
class Dog{
    // name: string;
    age: number;

    // constructor 被称为构造函数
    //  构造函数会在对象创建时调用
  // 在构造函数的参数上使用public等同于创建了同名的成员变量
    constructor(public name: string, age: number) {
        // 在实例方法中，this就表示当前当前的实例
        // 在构造函数中当前对象就是当前新建的那个对象
        // 可以通过this向新建的对象中添加属性
        this.name = name;
        this.age = age;
    }

    bark(){
        // alert('汪汪汪！');
        // 在方法中可以通过this来表示当前调用方法的对象
        console.log(this.name);
    }
}

const dog = new Dog('小黑', 4);
const dog2 = new Dog('小白', 2);

console.log(dog); //Dog { name: '小黑', age: 4 }
console.log(dog2); //Dog { name: '小白', age: 2 }

dog2.bark(); //小白

// 立即执行函数是为了 形成一个单独的作用域 防止变量冲突
(function (){
  // 定义一个Animal类
  class Animal{
    name: string;
    age: number;

    constructor(name: string, age: number) {
      this.name = name;
      this.age = age;
    }

    sayHello(){
      console.log('动物在叫~');
    }
  }

  /*
    * Dog extends Animal
    *   - 此时，Animal被称为父类，Dog被称为子类
    *   - 使用继承后，子类将会拥有父类所有的方法和属性
    *   - 通过继承可以将多个类中共有的代码写在一个父类中，
    *       这样只需要写一次即可让所有的子类都同时拥有父类中的属性和方法
    *       如果希望在子类中添加一些父类中没有的属性或方法直接加就行
    *   - 如果在子类中添加了和父类相同的方法，则子类方法会覆盖掉父类的方法
    *       这种子类覆盖掉父类方法的形式，我们称为方法重写
    *
    * */
  // 定义一个表示狗的类
  // 使Dog类继承Animal类
  class Dog extends Animal{

    run(){
      console.log(`${this.name}在跑~~~`);
    }

    sayHello() {
      console.log('汪汪汪汪！');
    }

  }

  // 定义一个表示猫的类
  // 使Cat类继承Animal类
  class Cat extends Animal{
    sayHello() {
      console.log('喵喵喵喵！');
    }
  }

  const dog = new Dog('旺财', 5);
  const cat = new Cat('咪咪', 3);
  console.log(dog);//Dog { name: '旺财', age: 5 }
  dog.sayHello(); //汪汪汪汪！
  dog.run();//旺财在跑~~~
  console.log(cat);//Cat { name: '咪咪', age: 3 }
  cat.sayHello();//喵喵喵喵！


})();
(function () {
  class Animal {
    name: string;

    constructor(name: string) {
      this.name = name;
    }

    sayHello() {
      console.log(`动物在叫~${this.name}`);
    }
  }

  class Dog extends Animal{

    age: number;

    constructor(name: string, age: number) {
      // 如果在子类中写了构造函数，在子类构造函数中必须对父类的构造函数进行调用
      super(name); // 调用父类的构造函数
      this.age = age;
    }

    sayHello() {
      // 在类的方法中 super就表示当前类的父类
      super.sayHello(); //动物在叫~旺财

      // console.log('汪汪汪汪！');
    }

  }

  const dog = new Dog('旺财', 3);
  dog.sayHello();
})();
	(function () {

    /*
    *   以abstract开头的类是抽象类，
    *       抽象类和其他类区别不大，只是不能用来创建对象
    *       抽象类就是专门用来被继承的类
    *
    *       抽象类中可以添加抽象方法
    * */
    abstract class Animal {
        name: string;

        constructor(name: string) {
            this.name = name;
        }

        // 定义一个抽象方法
        // 抽象方法使用 abstract开头，没有方法体
        // 抽象方法只能定义在抽象类中，子类必须对抽象方法进行重写
        abstract sayHello():void;
    }

    class Dog extends Animal{

        sayHello() {
            console.log('汪汪汪汪！');
        }

    }

    class Cat extends Animal{
        sayHello() {
            console.log('喵喵喵喵！');
        }

    }

    const dog = new Dog('旺财');
    const cat = new Cat('旺财');
    dog.sayHello(); //汪汪汪汪！
    cat.sayHello(); //喵喵喵喵！


})();

2、面向对象的特点

  • 封装
    • 对象实质上就是属性和方法的容器，它的主要作用就是存储属性和方法，这就是所谓的封装
    • 默认情况下，对象的属性是可以任意的修改的，为了确保数据的安全性，在TS中可以对属性的权限进行设置
    • 只读属性（readonly）：
      • 如果在声明属性时添加一个readonly，则属性便成了只读属性无法修改
    • TS中属性具有三种修饰符：
      • public（默认值），可以在类、子类和对象中修改
      • protected ，可以在类、子类中修改
      • private ，可以在类中修改
    • 示例：
      • public
class Person{
  public name: string; // 写或什么都不写都是public
  public 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; //子类中可以修改
  }
}

const p = new Person('孙悟空', 18);
p.name = '猪八戒';// 可以通过对象修改
      • 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; //子类中可以修改
  }
}

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; //子类中不能修改
  }
}

const p = new Person('孙悟空', 18);
p.name = '猪八戒';// 不能修改
    • 属性存取器
      • 对于一些不希望被任意修改的属性，可以将其设置为private
      • 直接将其设置为private将导致无法再通过对象修改其中的属性
      • 我们可以在类中定义一组读取、设置属性的方法，这种对属性读取或设置的属性被称为属性的存取器
      • 读取属性的方法叫做setter方法，设置属性的方法叫做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); // 通过getter读取name属性
p1.name = '猪八戒'; // 通过setter修改name属性
    • 静态属性
      • 静态属性（方法），也称为类属性。使用静态属性无需创建实例，通过类即可直接使用
      • 静态属性（方法）使用static开头
      • 示例：
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
      • 在类中，使用this表示当前对象
  • 继承
    • 继承时面向对象中的又一个特性
    • 通过继承可以将其他类中的属性和方法引入到当前类中
      • 示例：
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('旺财', 4);
dog.bark();
    • 通过继承可以在不修改类的情况下完成对类的扩展
    • 重写
      • 发生继承时，如果子类中的方法会替换掉父类中的同名方法，这就称为方法的重写
      • 示例：
class Animal{
  name: string;
  age: number;

  constructor(name: string, age: number){
    this.name = name;
    this.age = age;
  }

  run(){
    console.log(`父类中的run方法！`);
  }
}

class Dog extends Animal{

  bark(){
    console.log(`${this.name}在汪汪叫！`);
  }

  run(){
    console.log(`子类中的run方法，会重写父类中的run方法！`);
  }
}

const dog = new Dog('旺财', 4);
dog.bark();
        • 在子类中可以使用super来完成对父类的引用
    • 抽象类（abstract class）
      • 抽象类是专门用来被其他类所继承的类，它只能被其他类所继承不能用来创建实例
abstract class Animal{
  abstract run(): void;
  bark(){
    console.log('动物在叫~');
  }
}

class Dog extends Animals{
  run(){
    console.log('狗在跑~');
  }
}
      • 使用abstract开头的方法叫做抽象方法，抽象方法没有方法体只能定义在抽象类中，继承抽象类时抽象方法必须要实现

3、接口（Interface）

接口的作用类似于抽象类，不同点在于接口中的所有方法和属性都是没有实值的，换句话说接口中的所有方法都是抽象方法。接口主要负责定义一个类的结构，接口可以去限制一个对象的接口，对象只有包含接口中定义的所有属性和方法时才能匹配接口。同时，可以让一个类去实现接口，实现接口时类中要保护接口中的所有属性。

  • 示例（检查对象类型）：
interface Person{
  name: string;
  sayHello():void;
}

function fn(per: Person){
  per.sayHello();
}

fn({name:'孙悟空', sayHello() {console.log(`Hello, 我是 ${this.name}`)}});
  • 示例（实现）
interface Person{
  name: string;
  sayHello():void;
}

class Student implements Person{
  constructor(public name: string) {
  }

  sayHello() {
    console.log('大家好，我是'+this.name);
  }
}

接口code

(function () {
    // 描述一个对象的类型
    type myType = {
        name: string;
        age: number;
    };
    const obj1: myType = {
        name: "xxx",
        age: 11,
    };

    /*
     *   接口用来定义一个类结构，用来定义一个类中应该包含哪些属性和方法
     *       同时接口也可以当成类型声明去使用
     * */
    interface myInterface {
        name: string;
        age: number;
    }

    interface myInterface {
        gender: string;
    }

    const obj2: myInterface = {
        name: 'sss',
        age: 111,
        gender: '男'
    };

    /*
     * 接口可以在定义类的时候去限制类的结构，
     *   接口中的所有的属性都不能有实际的值
     *   接口只定义对象的结构，而不考虑实际值
     *       在接口中所有的方法都是抽象方法
     *
     * */
    interface myInter {
        name: string;

        sayHello(): void;
    }

    /*
     * 定义类时，可以使类去实现一个接口,
     *   实现接口就是使类满足接口的要求
     * */
    class MyClass implements myInter {
        name: string;

        constructor(name: string) {
            this.name = name;
        }

        sayHello() {
            console.log("大家好~~");
        }
    }
})();

属性封装code

(function () {
    // **************private***************
    // 定义一个表示人的类
    class Person {
        // TS可以在属性前添加属性的修饰符
        /*
        *   public 修饰的属性可以在任意位置访问（修改） 默认值
        *   private 私有属性，私有属性只能在类内部进行访问（修改）
        *       - 通过在类中添加方法使得私有属性可以被外部访问
        *   protected 受包含的属性，只能在当前类和当前类的子类中访问（修改）
        *
        * */
        private _name: string;
        private _age: number;

        constructor(name: string, age: number) {
            this._name = name;
            this._age = age;
        }

        /*
        *   getter方法用来读取属性
        *   setter方法用来设置属性
        *       - 它们被称为属性的存取器
        * */

        // 定义方法，用来获取name属性
        // getName() {
        //     return this._name;
        // }
        //
        // // 定义方法，用来设置name属性
        // setName(value: string){
        //     this._name = value;
        // }
        //
        // getAge(){
        //     return this._age;
        // }
        //
        // setAge(value: number){
        //     // 判断年龄是否合法
        //     if(value >= 0){
        //         this._age = value;
        //     }
        // }

        // TS中设置getter方法的方式
        get name() {
            // console.log('get name()执行了！！');
            return this._name;
        }

        set name(value) {
            this._name = value;
        }

        get age() {
            return this._age;
        }

        set age(value) {
            if (value >= 0) {
                this._age = value
            }
        }
    }

    const per = new Person('孙悟空', 18);

    /*
    * 现在属性是在对象中设置的，属性可以任意的被修改,
    *   属性可以任意被修改将会导致对象中的数据变得非常不安全
    * */

    // per.setName('猪八戒');
    // per.setAge(-33);

    per.name = '猪八戒';
    per.age = -33;

    // console.log(per);

    // ************protected***************
    class A {
        protected num: number;

        constructor(num: number) {
            this.num = num;
        }
    }

    class B extends A {

        test() {
            console.log(this.num);
        }

    }

    const b = new B(123);
    // b.num = 33;

    // *********** constructor(public name: string, public age: number) {}********

    /* class C{
 
         name: string;
         age: number
 
         // 可以直接将属性定义在构造函数中
         constructor(name: string, age: number) {
             this.name = name;
              this.age = age;
         }
 
     }*/

    class C {

        // 可以直接将属性定义在构造函数中
        constructor(public name: string, public age: number) {
        }

    }

    const c = new C('xxx', 111);

    console.log(c);

})();

4、泛型（Generic）

定义一个函数或类时，有些情况下无法确定其中要使用的具体类型（返回值、参数、属性的类型不能确定），此时泛型便能够发挥作用。

  • 举个例子：
function test(arg: any): any{
  return arg;
}
    • 上例中，test函数有一个参数类型不确定，但是能确定的时其返回值的类型和参数的类型是相同的，由于类型不确定所以参数和返回值均使用了any，但是很明显这样做是不合适的，首先使用any会关闭TS的类型检查，其次这样设置也不能体现出参数和返回值是相同的类型
    • 使用泛型：
function test<T>(arg: T): T{
  return arg;
}
    • 这里的<T>就是泛型，T是我们给这个类型起的名字（不一定非叫T），设置泛型后即可在函数中使用T来表示该类型。所以泛型其实很好理解，就表示某个类型。
    • 那么如何使用上边的函数呢？
      • 方式一（直接使用）：
      test(10)
        • 使用时可以直接传递参数使用，类型会由TS自动推断出来，但有时编译器无法自动推断时还需要使用下面的方式
      • 方式二（指定类型）：
      test<number>(10)
        • 也可以在函数后手动指定泛型
    • 可以同时指定多个泛型，泛型间使用逗号隔开：
function test<T, K>(a: T, b: K): K{
  return b;
}

test<number, string>(10, "hello");
      • 使用泛型时，完全可以将泛型当成是一个普通的类去使用
    • 类中同样可以使用泛型：
class MyClass<T>{
  prop: T;

  constructor(prop: T){
    this.prop = prop;
  }
}
    • 除此之外，也可以对泛型的范围进行约束
interface MyInter{
  length: number;
}

function test<T extends MyInter>(arg: T): number{
  return arg.length;
}
      • 使用T extends MyInter表示泛型T必须是MyInter的子类，不一定非要使用接口类和抽象类同样适用。

泛型code

/*
function fn(a: any): any{
    return a;
}*/

/*
*   在定义函数或是类时，如果遇到类型不明确就可以使用泛型
*       <X> X任意字符 参数
* */

function fn<T>(a: T): T {
    return a;
}

// 可以直接调用具有泛型的函数
let result = fn(10); // 不指定泛型，TS可以自动对类型进行推断
let result2 = fn<string>('hello'); // 指定泛型

// 泛型可以同时指定多个
function fn2<T, K>(a: T, b: K): T {
    console.log(b);
    return a;
}
let results3 = fn2<number, string>(123, 'hello');

interface Inter {
    length: number;
}

// T extends Inter 表示泛型T必须时Inter实现类（子类）
function fn3<T extends Inter>(a: T): number {
    return a.length;
}

//类中使用泛型
class MyClass<T>{
    name: T;
    constructor(name: T) {
        this.name = name;
    }
}

const mc = new MyClass<string>('孙悟空');

蜡笔大大新
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
TypeScript快速入门和面向对象
yuan_xiaoxin的博客
07-01 252
快速入门 1. TypeScript简介 TypeScript是JavaScript的超集。 它对JS进行了扩展，向JS中引入了类型的概念，并添加了许多新的特性。 TS代码需要通过编译器编译为JS，然后再交由JS解析器执行。 TS完全兼容JS，换言之，任何的JS代码都可以直接当成JS使用。 相较于JS而言，TS拥有了静态类型，更加严格的语法，更强大的功能；TS可以在代码执行前就完成代码的检查，减小了运行时异常的出现的几率；TS代码可以编译为任意版本的JS代码，可有效解决不同JS运行环境的兼容问题；同样的功
尚硅谷TypeScript教程（李立超老师）学习笔记
qq_48105178的博客
03-18 1354
涵盖了环境搭建、TypeScript中的各种类型（基本类型、数组、对象、元组、枚举、unknown、any、void、never等）、TypeScript的编译选项，以及TypeScript中面向对象的相关知识（类、抽象类和接口）
TypeScript学习笔记-尚硅谷TypeScript教程（李立超老师TS新课）
m0_46549017的博客
05-24 2055
尚硅谷TypeScript教程（李立超老师TS新课） 课程链接
尚硅谷-TypeScript
m0_56079094的博客
05-23 1021
1. TypeScript简介 （1）TypeScript是什么?存在的意义是什么？ 本质：是以js为基础构建的语言。 意义：在js的基础上最大的差别是引入了类型的概念。使js从动态类型的语言变为静态类型的语言。 注意：ts可以在任何支持js的平台中运行，但是ts不可以直接被js解析器执行，所以要将ts编译为js再执行。 ts优势：增添类型，支持es6，增添es不具备的新特性，丰富的配置选项，强大的开发工具。 2 TypeScript的环境搭建 （1）安装ts npm i -g typescript
TypeScript的类型笔记(尚硅谷)
m0_48283799的博客
05-04 792
*当对变量的声明和赋值是同时进行的，TS编译器会自动判断变量的类型 *所以如果你的变量的声明和赋值是同时赋值的，可以省略类型声明 一、JS对象Object {}用来指定对象中可以包含哪些属性 语法：{属性名：属性值，属性名：属性值} 在属性名后面加上?，表示属性是可选的 [xxx: string]: any 表示任意类型的属性 xxx可以是任意名称的字符串 let a: object; a = {}; a = function () {}; let b: { myName: string,
基于TypeScript和Vue的uniapp_V3_TS设计源码
05-28
本uniapp_V3_TS项目基于TypeScript和Vue开发，包含81个文件，其中包括22个TS源文件、22个PNG图像文件、19个Vue组件文件、9个JSON配置文件、2个SCSS样式文件、1个Editorconfig文件、1个CJS文件、1个Gitignore文件、1...
基于TypeScript的依赖注入库ts.di设计源码
05-26
ts.di是一个使用TypeScript编写的依赖注入库，旨在为TypeScript应用程序提供灵活和高效的依赖注入解决方案。该项目包含22个文件，其中包括9个TypeScript源文件、7个JavaScript文件以及相关的配置和文档文件。ts.di的...
基于TypeScript的鸿蒙版概念笔记项目设计源码
最新发布
06-01
本源码是基于TypeScript开发的鸿蒙版概念笔记项目设计，包含75个文件，其中包括22个.ets文件，21个.png文件，10个.json文件，9个.json5文件，4个.ts文件，以及2个.gitignore文件，2个.md文件，1个.License文件和1个....
typeScript学习笔记
04-27
TypeScript学习笔记 TypeScript是一个自由和开源的编程语言，由微软开发。它是JavaScript的一个超集，扩展了JavaScript的语法，解决了JavaScript的“痛点”：弱类型和没有命名空间，导致很难模块化。TypeScript支持...
TypeScript 教程
01-21
TypeScript 教程 TypeScript 是 JavaScript 的一个超集，支持 ECMAScript 6 标准。 TypeScript 由微软开发的自由和开源的编程语言。 TypeScript 设计目标是开发大型应用，它可以编译成纯 JavaScript，编译出来的 ...
尚硅谷（李立超）——HTML5&CSS3笔记总结【持续更新】
01-08
尚硅谷（李立超）——HTML5&CSS3笔记总结【持续更新】 本文适合前端菜鸟食用，小编自己整理的李立超老师视频的笔记，手打不易，那就望您每年快乐吧。逃） 一、进制 1.十进制（日常使用）： 特点：满10进1 计数：0 1 2 3 4 5 6 7 8 9 10 11 12 13 14…19 20 单位数字：10个（0-9） 2.二进制（计算机底层的进制）： 特点：满2进1 计数：0 1 10 11 100 101 110 111 单位数字：2个（0-1） 扩展：所有数据在计算机底层都会以二进制的形式保存。可以将内存想象成一个含有多个小格子的容器，每一个小格子中可以存储一个0或一个1，这一个小格
经典尚硅谷JavaScript视频
06-15
精心收藏 上百本经典前端电子书 总有基本合适你的 节省大家时间
[学习笔记]TypeScript学习笔记
无知的圆的博客
07-01 509
文章目录1 前期准备工作1.1 TypeScript的简介1.2 TypeScript与JavaScript的关系1.3 TypeScript的优点1.4 TypeScript开发环境搭建2 基本类型2.1 类型声明2.2 基本类型种类3 编译选项3.1 自动编译文件3.2 自动编译整个项目4 用webpack配置TS5 Babel6 面向对象6.1 前言6.2 类（class）6.3 面向对象的特点6.4 接口6.5 泛型（Generic）项目实战代码地址参考 1 前期准备工作 1.1 TypeScrip
尚硅谷李立超老师讲解web前端---笔记（持续更新）
m0_63695673的博客
03-17 782
商品来自全球数十万品牌商家，囊括家电、手机、电脑、服装、居家、母婴、美妆、个护、食品、生鲜等丰富品类，满足各种购物需求。比较优先级时，需要将所有的选择器的优先级进行相加计算，最后优先级越高，则越优先显示（分组选择器是单独计算的）浏览器开发者模式按f12，elements是元素的意思，点击以后也可以看见我们正在vscode编写的代码。当我们通过不同的选择器，选择相同的元素，并且为相同的样式设置为不同的值时，此时就发生了冲突。默认样式的存在会影响到页面的布局，通常情况下编写网页时必须要去除浏览器的默认样式（
TypeScript快速上手学习笔记-第一篇——简介
LIMI_伞梦的博客
02-04 382
什么是TypeScript？ TypeScript是一种由微软开发的以javascript为基础的自由和开源的编程语言。它是JavaScript的一个超集，而且本质上向这个语言添加了可选的静态类型和基于类的面向对象编程。 2012年十月份，微软发布了首个公开版本的TypeScript，2013年6月19日，在经历了一个预览版之后微软正式发布了正式版TypeScript 0.9，向未来的TypeScript 1.0版迈进了很大一步。 TypeScript扩展了JavaScript的语法，所以任何现有的Java
尚硅谷李立超老师讲解web前端网课的笔记
m0_62658717的博客
01-17 856
初学 web 前端笔记一 刚刚看完网课，趁着脑子里还有点东西，小彭赶紧来做个笔记~接下来看吧： 一、软件的分类 1．系统软件：（我们买电脑或手机第一件事就是先激活或者安装一个“灵魂”——操作系统) -Windows -Linux -macOS 2．应用软件： -office -qq 3．游戏软件： -绝地求生 -王者荣耀 ps:如果没有软件，你的计算机或者手机是没有正常办法去使用的。作为程序员，或者说是软件工程师来讲，我们的任务就是开发软件。 二、软件的组成通常情况下，现...
1、尚硅谷-JavaScript基础-李立超-基础语法
极客鼠之家
09-01 700
文章目录1、JavaScript简介1.1、什么是语言1.2、起源1.3、简史1.4、时间表1.5、实现1.6、学习内容1.7、特点1.71、解释型语言1.72、类似于c和java语法结构1.73、动态语言1.74、基于原型的面向对象2、JavaScript基本语法2.1、编写位置2.2、严格区分大小写2.3、注释2.4、标识符2.5、关键字和保留字2.6、变量2.7、数据类型2.8、typeof运算符2.9、String2.10、Number2.11、数值的转换2.12、Boolean(布尔类型)2.13
尚硅谷李立超老师的web前端教学课程
weixin_62271271的博客
02-13 156
CSS的学习笔记一：
尚硅谷TypeScript教程
08-20
你好！尚硅谷是一个知名的IT培训机构，他们提供了一门关于TypeScript的教程。这门教程可以帮助你学习和掌握TypeScript的基础知识和高级特性。通过这门教程，你将学习到TypeScript的语法、类型系统、面向对象编程等内容。此外，尚硅谷的教程也会教授如何在实际项目中使用TypeScript进行开发。你可以在尚硅谷的官方网站或者其他在线学习平台上找到相关的教程资料。希望这能帮助到你！如果你有其他问题，请随时提问。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值