TypeScript（中）+算法（二）
文章目录
- 算法
- 排序
- 冒泡排序
- 选择排序
- TS
- 类型声明
- 类型推断
- 类型总览
- js中的数据类型
- ts中的数据类型
- 原始类型和包装对象
- 原始类型
- 包装对象
- 自动装箱
- 常用类型与语法
- any
- unknown
- never
- void
- void 与 undefined
- 总结
算法
排序
有十种排序算法，分别是：冒泡排序，选择排序，插入排序，希尔排序，归并排序，快速排序，堆排序，基数排序，计数排序，桶排序。今天就先讲一下冒泡和选择
冒泡排序
冒泡排序就是俩个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中的数据类型
- string
- number
- boolean
- null
- undefined
- object
- symbol
- bigint
其中object包含Array,Function，Date,Error等
ts中的数据类型
包括上述js类型之外还有几种新类型
- any
- unknown
- never
- void
- tuple
- enum
还有两个用于自定义类型的方式
- type
- 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 = a
console.log(x)
}
//第⼆种⽅式：加断⾔
x = a as string
//第三种⽅式：加断⾔
x = <string>a
let 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 ，那么：
- 从语法上讲：函数是可以返回 undefined 的，⾄于显式返回，还是隐式返回，这⽆
所谓 - 从语义上讲：函数调⽤者不应关⼼函数返回的值，也不应依赖返回值进⾏任何操作！
即使我们知道它返回了 undefined。