3.typescript类型的高级用法(下）

1.函数类型

type calcFun = (num1:number1,num2:number) => number
function calc(fun:calcFun){
	console.log(fun(20,30)
}
function sum(num1:number1,num2:number){
	return num1+num2
}
calc(sum)

(num1:number1,num2:number) => numberr，代表的就是一个函数类型
()=>void 代表没有参数没有返回值的函数类型

参数的可选类型

我们可以指定某个参数是可选的：

function foo(x:number,y?:number){
	console.log(x,y)
}

这个时候这个参数y的类型为number | undefined
另外可选类型需要在必传参数后面

默认参数

从es6开始，js是支持默认参数的，ts也是支持

function foo(x:number,y:number = 6){
	console.log(x,y)
}

剩余参数

剩余参数允许我们将一个不定数量的参数放到一个数组中

function sum(...nums:number[]){
	let total = 0
	nums.forEach(item=>{
		total += item
	})
	return total
}
sum(1,2,3)

2.this

确定的this

const info = {
	name:'bai',
	sayHi(){
		console.log(this.name)
	}
}
info.sayHi()

不确定的this

function sayHi(){
	console.log(this.name)
}
const info = {
	name:'bai',
	sayHi
}

ts会报错
这里我们再次强调一下，TypeScript进行类型检测的目的是让我们的代码更加的安全；
所以这里对于 sayHi 的调用来说，我们虽然将其放到了info中，通过info去调用，this依然是指向info对象的；
但是对于TypeScript编译器来说，这个代码是非常不安全的，因为我们也有可能直接调用函数，或者通过别的对象来
调用函数；
这个时候，通常TypeScript会要求我们明确的指定this的类型

type NameType = {
	name: string
}
function sayHi(this:NameType){
	console.log(this.name)
}

3.函数的重载

在TypeScript中，如果我们编写了一个add函数，希望可以对字符串和数字类型进行相加，应该如何编写呢？
我们可能会这样来编写，但是其实是错误的：

function sum(a1:number|string ,a1:number|string): number|string {
	return a1+a2
}

联合类型要类型缩小
联合类型有两个缺点：

• 进行很多的逻辑判断（类型缩小）
• 返回值的类型依然是不能确定

function add(a1:number|string ,a1:number|string) {
	if(typeof a1 === 'number' && typeof a2 === 'number'){
		return a1+a2
	}else if(typeof a1 === 'string' && typeof a2 === 'string'){
		return a1+a2
	}
}
add(10,20)

需要函数的重载,sum函数的重载

function add(a1:number ,a1:number):number;
function add(a1:string ,a1:string):string;
function add(a1:any ,a1:any):any {
	return a1 + a2
}
console.log(sum(20,30))
console.log(sum('aaa','bbb'))

案例：

定义一个函数，可以传入字符串或者数组，获取长度。
这里有两种方案：

//1:联合类型
function getLen(a: string|any[]){
	return a.length
}
//2:函数重载
function getLen(a:string):number;
function getLen(a:any[]):number;
function getLen(a:any){
	return a.length
}

在开发中我们选择使用哪一种呢？
在可能的情况下，尽量选择使用联合类型来实现。