TypeScript（中）+算法（二）

算法

排序

有十种排序算法，分别是：冒泡排序，选择排序，插入排序，希尔排序，归并排序，快速排序，堆排序，基数排序，计数排序，桶排序。今天就先讲一下冒泡和选择

冒泡排序

冒泡排序就是俩个for循环。

内嵌的for是用来求出当前数组最大或最小的那个元素

第一层的for是用来循环查找次最大的元素直到全部排序好。

public class HelloWorld {public static void main(String []args) {int[] arr = {1,2,3,4,5,6,7};System.out.println("arr的排序前：\n18  13  50  15  4  17  18 ");int temp  = 0 ;for(int i = 0 ;i< arr.length -1; i++){for(int j = 0; j<arr.length-1-i; j++){if(arr[j]>arr[j+1]){temp = arr[j];arr[j] = arr[j+1];arr[j+1] = temp;}}}System.out.println("arr排序后：");for(int i = 0; i<arr.length; i++){System.out.print(arr[i]+"\t");}	}
}

选择排序

选择排序是一种简单直观的排序算法。它的基本思想是每次从待排序的元素中选择最小（或最大）的元素，放置在已排序的部分的末尾，直到所有元素都排序完成。

public static void sort(int[] arrays) {for(int i = 0; i < arrays.length; i++) {int min = arrays[i];int temp = i;for(int j = arrays.length - 1; j > i; j--) {if(min > arrays[j]) {min = arrays[j];temp = j;}}arrays[temp] = arrays[i];arrays[i] = min;}

TS

类型声明

使⽤ : 来对变量或函数形参，进⾏类型声明：

let a: string //变量a只能存储字符串
let b: number //变量b只能存储数值
let c: boolean //变量c只能存储布尔值
a = 'hello'
a = 100 //警告：不能将类型“number”分配给类型“string”
b = 666
b = '你好'//警告：不能将类型“string”分配给类型“number”
c = true
c = 666 //警告：不能将类型“number”分配给类型“boolean”
// 参数x必须是数字，参数y也必须是数字，函数返回值也必须是数字
function demo(x:number,y:number):number{return x + y
}
demo(100,200)
demo(100,'200') //警告：类型“string”的参数不能赋给类型“number”的参数
demo(100,200,300) //警告：应有 2 个参数，但获得 3 个
demo(100) //警告：应有 2 个参数，但获得 1 个

在 : 后也可以写字⾯量类型，不过实际开发中⽤的不多。

let a: '你好' //a的值只能为字符串“你好”
let b: 100 //b的值只能为数字100
a = '欢迎'//警告：不能将类型“"欢迎"”分配给类型“"你好"”
b = 200 //警告：不能将类型“200”分配给类型“100”

类型推断

TS 会根据我们的代码，进⾏类型推导，例如下⾯代码中的变量 d ，只能存储数字

let d = -99 //TypeScript会推断出变量d的类型是数字
d = false 

类型推断不是万能的，面对复杂类型时容易推断出问题，还是尽量明确的编写类型声明

类型总览

js中的数据类型

1. string
2. number
3. boolean
4. null
5. undefined
6. object
7. symbol
8. bigint

其中object包含Array,Function，Date,Error等

ts中的数据类型

包括上述js类型之外还有几种新类型

1. any
2. unknown
3. never
4. void
5. tuple
6. enum

还有两个用于自定义类型的方式

1. type
2. interface

在js中的这些内置构造函数：Number,String,Boolean,用于创建对应的包装对象，在日常开发时很少使用，ts也是同理，所以在ts中进行类型声明时，通常都是用小写的number,string,boolean

let str1: string
str1 = 'hello'
str1 = new String('hello')let str2: string
str2 = 'haaa'
str2 = new String('haaa')console.log(typeof str1)
console.log(typeof str2)

原始类型和包装对象

原始类型

如number,string,boolean,在js中是简单数据类型，他们在内存中占用空间少，处理速度快

包装对象

如Number对象，String对象，是复杂类型，在内存中占用更多空间，在日常开发时很少由开发人员自己创建包装对象

自动装箱

js在必要时会自动将原始类型包装成对象，以便调用方法或访问属性

//原始类型
let str ='haaa'
let size=(function(){//1.自动装箱:创建一个临时的String对象包装原始字符串let tsObject = new String(str)//访问String对象的length属性let lengthValue = ts.length//销毁临时对象，返回长度值return lengthValue})()
console.log(size)

常用类型与语法

any

任意类型，⼀旦将变量类型限制为 any ，那就意味着放弃了对该变量的类型
检查。

// 明确的表示a的类型是 any —— 【显式的any】
let a: any
// 以下对a的赋值，均⽆警告
a = 100
a = '你好'
a = false
// 没有明确的表示b的类型是any，但TS主动推断出来b是any —— 隐式的any
let b
//以下对b的赋值，均⽆警告
b = 100
b = '你好'
b = false

any 类型的变量，可以赋值给任意类型的变量

unknown

未知类型，适⽤于：起初不确定数据的具体类型，要后期才能确定
也可以理解为一个类型安全的any,unknown 会强制开发者在使⽤之前进⾏类型检查，从⽽提供更强的类型安全性。读取 any 类型数据的任何属性都不会报错，⽽ unknown 正好与之相反。

// 设置a的类型为unknown
let a: unknown
//以下对a的赋值，均符合规范
a = 100
a = false
a = '你好'
// 设置x的数据类型为string
let x: string
x = a //警告：不能将类型“unknown”分配给类型“string”// 设置a的类型为unknown
let a: unknown
a = 'hello'
//第⼀种⽅式：加类型判断
if(typeof a === 'string'){x = aconsole.log(x)
}
//第⼆种⽅式：加断⾔
x = a as string
//第三种⽅式：加断⾔
x = <string>alet str1: string
str1 = 'hello'
str1.toUpperCase() //⽆警告
let str2: any
str2 = 'hello'
str2.toUpperCase() //⽆警告
let str3: unknown
str3 = 'hello';
str3.toUpperCase() //警告：“str3”的类型为“未知”
// 使⽤断⾔强制指定str3的类型为string
(str3 as string).toUpperCase() //⽆警告

never

任何值都不是，即：不能有值，例如 undefined 、 null 、 ‘’ 、 0 都不⾏
⼏乎不⽤ never 去直接限制变量，因为没有意义。
never ⼀般是 TypeScript 主动推断出来的。
never 也可⽤于限制函数的返回值

/* 指定a的类型为never，那就意味着a以后不能存任何的数据了 */
let a: never
// 以下对a的所有赋值都会有警告
a = 1
a = true
a = undefined
a = null指定a的类型为string
let a: string
// 给a设置⼀个值
a = 'hello'
if (typeof a === 'string') {console.log(a.toUpperCase())
} else {console.log(a) // TypeScript会推断出此处的a是never，因为没有任何⼀个值符合此处的
逻辑
}// 限制throwError函数不需要有任何返回值，任何值都不⾏，像undeifned、null都不⾏
function throwError(str: string): never {throw new Error('程序异常退出:' + str)
}

void

void 的含义是空，即：函数不返回任何值，调⽤者也不应依赖其返回值进⾏任何操作
void 通常⽤于函数返回值声明

那限制函数返回值时，是不是 undefined 和 void 就没区别呢？—— 有区别。因为还有
这句话 ：返回值类型为 void 的函数，调⽤者不应依赖其返回值进⾏任何操作,对⽐下
⾯两段代码：

void 与 undefined

void 是⼀个⼴泛的概念，⽤来表达“空”，⽽ undefined 则是这种“空”的具体
实现。
因此可以说 undefined 是 void 能接受的⼀种“空”的状态。
也可以理解为： void 包含 undefined ，但 void 所表达的语义超越了 undefi
ned ， void 是⼀种意图上的约定，⽽不仅仅是特定值的限制。

总结

如果⼀个函数返回类型为 void ，那么：

1. 从语法上讲：函数是可以返回 undefined 的，⾄于显式返回，还是隐式返回，这⽆
   所谓
2. 从语义上讲：函数调⽤者不应关⼼函数返回的值，也不应依赖返回值进⾏任何操作！
   即使我们知道它返回了 undefined。