TypeScript

TypeScript

TypeScript

一、TypeScript是什么？

① 以JavaScript为基础构建的语言
② 一个JavaScript的超集
③ 可以在任何支持JavaScript的平台中执行
④ TypeScript扩展了JavaScript，并添加了类型
⑤ TS不能被JS解析器直接执行，需要进行编译才能被JS解析器执行

二、TypeScript增加了什么？

① 类型
② 支持ES的新特性
③ 添加ES不具备的新特性
④ 丰富的配置选项
⑤ 强大的开发工具

三、TypeScript开发环境搭建

1、下载Node.js

2、安装Node.js

3、使用npm全局安装typescript

进行命令行
输入：npm i -g typescript

4、创建一个ts文件

5、使用tsc对ts文件进行编译

进入命令行
进入ts文件所在目录
执行命令：tsc xxx.ts

四、基本类型

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

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

// a 的类型设置为了number，在以后的使用过程中a的值只能是数字
a = 10;
a = 'hello' //报错
```
自动类型判断
- TS拥有自动的类型判断机制
- 当变量的声明和赋值是同时进行的，TS编译器会自动判断变量的类型
- 所以如果你的变量的声明和赋值时同时进行的，可以省略掉类型声明
类型：

类型	例子	描述
number	1，-33,2.5	任意数字
string	‘hi’,”hi”,hi	任意字符串
boolean	true、false	布尔值true或false
字面量	其本身	现状变量的值就是该字面量的值
any	*	任意类型
unknown	*	类型安全的any
void	空值(undefined)	没有值(或undefined)
never	没有值	不能是任何值
object		任意的JS对象
array	[1,2,3]	任意JS数组
tuple	[4,5]	元素，TS新增类型，固定长度数组
enum	enum	枚举，TS中新增类型

//可以直接使用字面量进行类型声明
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;
d = 10;
d = 'hello';
d = true;

// 声明变量如果不指定类型，则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';
s = e; // 报错
// 总结any 和 unknown的区别，any赋值给指定类型不会报错，unknown会报错
// unknown实际上就是一个类型安全的any
// unknown类型的变量，不能直接赋值给其他变量
if(typeof e === "string"){
    s = e; 
}

// 类型断言：可以用来告诉解析器变量的实际类型  告诉编译器这个e就是字符串类型
// 语法： 变量 as 类型   <类型>变量
s = e as string;

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

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

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

// {}用来指定对象中可以包含哪些属性
// 语法：{属性名：属性值，属性名：属性值}
// 在属性名后边加上?表示属性是可选的
let b:{name: string,age:number}
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:number,n2:number):number{
           return n1 + n2;
       }
       
       
 // 数组的类型声明： 类型[]  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 = 0,
     Female = 1
 }
 let i:{name:string,gender:Gender}
  i = {
      name:'孙悟空',
      gender:Gender.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;
 k = 2;

numebr

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'
let age: number = 37;
let sentence: string = 'hello,my name is ${fullName};

字面量
- 也可以使用字面量去指定变量的类型，通过字面量可以确定变量的取值范围
- ```
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 unsable: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',12];

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 string";
  let strLength:number = (someValue as string).length;
```
- 第二种
- ```
let someValue: unknown = "this is string";
let strLength: number = (<string>someValue).length;
```

五、编译选项

自动编译文件
- 编译文件时，使用-w指令后，TS编译器会自动监视文件的变化，并在文件发生时对文件进行重新编译
- 示例：
  - ```
  tsc xxx.ts -w
```
自动编译整个项目
- 如果直接使用tsc指令，则可以自动将当前项目下的所有ts文件编译为js文件
- 但是能直接使用tsc命令的前提时，要先在项目根目录下创建一个ts的配置文件tsconfig.json
- tsconfig.json是一个JSON文件，添加配置文件后，只需tsc命令即可完成对整个项目的编译
- 配置选项：
  - include
    - 定义希望被编译文件所在的目录
    - 默认值：[“* * /*”]
    - 示例：
      - "include":["src/**/*","tests/**/*"] **表示任意目录 *表示任意文件
      - 上述示例中，所有src目录和tests目录下的文件都会被编译
    - exclude
      - 定义需要排除在外的目录
      - 默认值：[“node_modules”,”bower_components”,”jspm_packages”]
      - 示例：
        
        "exclude":["./src/hello/**/*"]
    - extends
      - 定义被继承的配置文件
      - 示例：
        
        "extends":"./configs/base"
        
        上述示例中，当前配置文件中会自动包含config目录下base.json中的所有配置信息
    - files
      - 指定被编译文件的列表，只有需要编译的文件少时才会用到
      - 示例：
        
        "files":[ "core.ts", "sys.ts", "type.ts", "scanner.ts", "parser.ts", "utilities.ts", "binder.ts", "checker.ts", "tsc.ts" ]
        
        列表中的文件都会被TS编辑器所编译
      - compilerOptions（最最重要的一个东西）
        
        编译选项是配置文件中非常重要也比较复杂的配置选项
        
        在compilerOptions中包含多个子选项，用来完成对编译的配置
        
        项目选项
        
        target
        
        设置TS代码编译的目标版本
        
        可选值：
        
        ES3(默认)、ES5、ES6/ES2016、ES2017、ES2018、ES2019、ES2020...
        
        示例：
        
        "compilerOptions":{ "target":"ES6" }
        
        如上设置，我们所编写的TS代码将会被编译为ES6版本的js代码
        
        lib
        
        指定代码运行时所包含的库（宿主环境）
        
        可选值：
        
        ES5、ES6/ES2015、ES7/ES2016、ES2017、ES2018、ES2019、ES2020、ESNext、DOM、WebWorker、ScriptHost……
        
        示例
        
        "compilerOptions":{ "target"："ES6", //用来指定ts被编译为的ES的版本 "module":"ES2015" //指定要使用的模块化的规划 "lib":["ES6","DOM"], // 用来指定项目中要使用的库 "outDir":"./dist", // 用来指定编译后文件所在的目录 "outFile":"dist/aa.js", //将代码合并为一个文件，设置outFile后，所有的全局作用域中的代码会合并到同一个文件中 "allowJs":false, // 是否对js文件进行编译，默认是false "checkJs":false, // 是否检查js代码是否符合语法规范，默认是false "removeComments": false, // 是否移除注释，默认值为false "noEmit":true, // 不生成编译后的文件，默认为false "noEmitOnError": true // 当有错误时不生成编译后的文件 "strict": false, // 所有严格检查的总开关 "alwaysStrict": true, // 用来设置编译后的文件是否使用严格模式，默认false "noImplicitAny": true // 不允许隐式any "noImplicitThis": true // 不允许不明确类型的this "strictNullChecks": true //严格检查空值 }

六、使用webpack打包ts代码

1、安装依赖

npm i -D webpack webpack-cli webpack-dev-server typescript ts-loader clean-webpack-plugin

在终端命令行输入npm init -y 生成一个package.json文件

2、新建一个webpack.config.js文件

//引入一个路径包
const path = require('path');

// webpack中的所有的配置信息都应该写在module.export中
module.export = {
	// 指定路口文件
	entry:"./src/index.ts",
	
	// 指定打包文件所在目录
	output: {
	// 指定打包文件的目录
	path:path.resolve(__dirname,'dist'),
	//打包后文件的文件名
	filename:"bundle.js"
	},
	// 指定webpack打包时要使用模块
	module:{
	// 指定要加载的规则
		rules:[
			{
				// test指定的是规则生效的文件
				test:/\.ts$/,
				// 要使用的loader
				use:'ts-loader'
				// 要排除的文件
				exclude: /node-modules/
			}
		]
	}
}

3、新建一个tsconfig.json文件来对ts文件进行编译

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

4、在package.json文件下scripts中配置打包命令

"build":"webpack"

在终端执行npm run build 执行打包命令

5、打包完有时需要重新引入js文件，这样插件 html-webpack-plugin就体现出来了

npm i -D html-webpack-plugin

//引入一个路径包
const path = require('path');

// 引入html插件
const HTMLWebpackPlugin = require('html-webpack-plugin');

// webpack中的所有的配置信息都应该写在module.export中
module.export = {
	// 指定路口文件
	entry:"./src/index.ts",
	
	// 指定打包文件所在目录
	output: {
	// 指定打包文件的目录
	path:path.resolve(__dirname,'dist'),
	//打包后文件的文件名
	filename:"bundle.js"
	},
	// 指定webpack打包时要使用模块
	module:{
	// 指定要加载的规则
		rules:[
			{
				// test指定的是规则生效的文件
				test:/\.ts$/,
				// 要使用的loader
				use:'ts-loader'
				// 要排除的文件
				exclude: /node-modules/
			}
		]
	},
	// 配置webpack插件
	plugins: [
		// 效果，自动生成html文件，引入相关的资源
		new HTMLWebpackPlugin({
		// 如果不想要自动打包生成的模板，可以自己自定义一个模板
			template:"./src/index.html"
		}),
	]
}

webpack-dev-server——webpack服务器，内置的服务器

可以在package.json下的scripts里面配置

"start":"webpack serve --open chrome.exe"

因为每次编译都会生成编译文件，虽然不会显示，但是还是会一直保存。

这样的话就得用到clean-webpack-plugin这个插件

//引入一个路径包
const path = require('path');

// 引入html插件
const HTMLWebpackPlugin = require('html-webpack-plugin');
// 引入clean插件
const {CleanWebpackPlugin} = require('clean-webpack-plugin');

// webpack中的所有的配置信息都应该写在module.export中
module.export = {
	// 指定路口文件
	entry:"./src/index.ts",
	
	// 指定打包文件所在目录
	output: {
	// 指定打包文件的目录
	path:path.resolve(__dirname,'dist'),
	//打包后文件的文件名
	filename:"bundle.js"
	},
	// 指定webpack打包时要使用模块
	module:{
	// 指定要加载的规则
		rules:[
			{
				// test指定的是规则生效的文件
				test:/\.ts$/,
				// 要使用的loader
				use:'ts-loader'
				// 要排除的文件
				exclude: /node-modules/
			}
		]
	},
	// 配置webpack插件
	plugins: [
		// 效果，自动生成html文件，引入相关的资源
		new HTMLWebpackPlugin({
		// 如果不想要自动打包生成的模板，可以自己自定义一个模板
			template:"./src/index.html"
		}),
		new CleanWebpackPlugin()
	],
	
	// 用来设置引用模块，哪些模块可以引用
	resolve:{
		extensions: ['.ts','.js']
	}
}

6、解决兼容性的问题

安装依赖

npm i -D @babel/core @babel/preset-env babel-loader core-js

//引入一个路径包
const path = require('path');

// 引入html插件
const HTMLWebpackPlugin = require('html-webpack-plugin');
// 引入clean插件
const {CleanWebpackPlugin} = require('clean-webpack-plugin');

// webpack中的所有的配置信息都应该写在module.export中
module.export = {
	// 指定路口文件
	entry:"./src/index.ts",
	
	// 指定打包文件所在目录
	output: {
		// 指定打包文件的目录
		path:path.resolve(__dirname,'dist'),
		//打包后文件的文件名
		filename:"bundle.js"
	
		//如果需要兼容低版本ie浏览器，一般还需要处理ES6的箭头函数
		environment:{
			arrowFunction:false // 告诉webpack不使用箭头函数
		}
	},
	// 指定webpack打包时要使用模块
	module:{
	// 指定要加载的规则
		rules:[
			{
				// test指定的是规则生效的文件
				test:/\.ts$/,
				// 要使用的loader
				use:[
				 //配置babel
				 	{
				 	// 指定加载器
				 	loader:"babel-loader"
				 	// 设置babel——>在哪些浏览器运行
				 	options:{
				 		// 设置预定义环境
				 		presets:[
				 			[
				 				// 指定环境插件
				 				"@babel/preset-env",
				 				// 配置信息
				 				{
				 					// 指定浏览器
				 					targets::{
				 						"chrome":"88" // 谷歌浏览器，版本88
				 						"ie":"11"
				 					},
				 					"corejs":"3"  // 用哪个版本的corejs
				 					"useBuiltIns":"usage"  // 使用corejs方式  usage按需加载
				 				}
				 			]
				 		]
				 	}
				 	},
				 	'ts-loader'
				],
				// 要排除的文件
				exclude: /node-modules/
			}
		]
	},
	// 配置webpack插件
	plugins: [
		// 效果，自动生成html文件，引入相关的资源
		new HTMLWebpackPlugin({
		// 如果不想要自动打包生成的模板，可以自己自定义一个模板
			template:"./src/index.html"
		}),
		new CleanWebpackPlugin()
	],
	
	// 用来设置引用模块，哪些模块可以引用
	resolve:{
		extensions: ['.ts','.js']
	}
}

七、面向对象

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

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

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

1、类(class)

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

定义类

class 类名 {
	属性名：类型;
		constructor(参数：类型){
			this.属性名 = 参数;
		}
		
		方法名() {
			……
		}
}

示例

class Person {
	name:string;
	age:number;
	// constructor被称为构造函数，构造函数会在对象创建时调用	
	constructor(name:string,age:number){
		// this相当于指向的是this——>per,表示当前实例，可以通过this向新建的对象中添加属性
		this.name = name;
		this.age = age;
		}
	sayHello(){
	console.log('HELLO,大家好！')
	}
}
const per = new Person('张三',18);

2、构造函数

可以使用constructor定义一个构造器方法；

注1：在TS中只能有一个构造器方法！

例如：

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) {
    }
}

上面两种定义方法是完全相同的！

注2：子类继承父类时，必须调用父类的构造方法（如果子类中也定义了构造方法）！

例如：

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

class X extends A {
    protected name: string;
    constructor(num: number, name: string) {
        super(num);
        this.name = name;
    }
}

如果在X类中不调用super将会报错！

3、封装

对象实质上就是属性和方法的容器，它的主要作用就是存储属性和方法，这就是所谓的封装

默认情况下，对象的属性是可以任意的修改的，为了确保数据的安全性，在TS中可以对属性的权限进行设置

静态属性（static）：
- 声明为static的属性或方法不再属于实例，而是属于类的属性；
只读属性（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 = '猪八戒';// 不能修改

4、属性存取器

对于一些不希望被任意修改的属性，可以将其设置为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('孙悟空');
// 实际通过调用getter方法读取name属性
console.log(p1.name);
// 实际通过调用setter方法修改name属性 
p1.name = '猪八戒';

5、静态属性

静态属性（方法），也称为类属性。使用静态属性无需创建实例，通过类即可直接使用

静态属性（方法）使用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));

6、this

在类中，使用this表示当前对象

7、继承

继承时面向对象中的又一个特性

通过继承可以将其他类中的属性和方法引入到当前类中

示例：

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();

通过继承可以在不修改类的情况下完成对类的扩展

8、重写

发生继承时，如果子类中的方法会替换掉父类中的同名方法，这就称为方法的重写

示例：

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来完成对父类的引用

9、抽象类（abstract class）

抽象类是专门用来被其他类所继承的类，它只能被其他类所继承不能用来创建实例

abstract class Animal{
  abstract run(): void;
  bark(){
      console.log('动物在叫~');
  }
}

class Dog extends Animals{
  run(){
      console.log('狗在跑~');
  }
}

使用abstract开头的方法叫做抽象方法，抽象方法没有方法体只能定义在抽象类中，继承抽象类时抽象方法必须要实现;

八、接口（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);
   }
}

九、泛型（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的子类，不一定非要使用接口类和抽象类同样适用；

posted on 2023-05-13 00:34 hongk 阅读(31) 评论(0) 编辑收藏举报

刷新页面返回顶部

导航

TypeScript

TypeScript

一、TypeScript是什么？

二、TypeScript增加了什么？

三、TypeScript开发环境搭建

1、下载Node.js

2、安装Node.js

3、使用npm全局安装typescript

4、创建一个ts文件

5、使用tsc对ts文件进行编译

四、基本类型

五、编译选项

六、使用webpack打包ts代码

1、安装依赖

2、新建一个webpack.config.js文件

3、新建一个tsconfig.json文件来对ts文件进行编译

4、在package.json文件下scripts中配置打包命令

5、打包完有时需要重新引入js文件，这样插件 html-webpack-plugin就体现出来了

6、解决兼容性的问题

七、面向对象

1、类(class)

2、构造函数

3、封装

4、属性存取器

5、静态属性

6、this

7、继承

8、重写

9、抽象类（abstract class）

八、接口（Interface）

九、泛型（Generic）

泛型函数

创建泛型函数

使用泛型函数

方式一（直接使用）：

方式二（指定类型）：

函数中声明多个泛型

泛型类

泛型继承