2021-08-23

Typescript学习记录

Typescript为JS添加了类型系统

打开vscode终端
输入npm i -g typescript 回车
typescript：就是用来解析TS的工具包，提供了tsc命令，实现TS到JS的转化
npm：用来安装前端开发中用到的包，是安装Node.js时自动安装的
i（install）：表示安装
-g（–global）：全局标识，可以在任意目录中使用该工具

TS转化为JS：tsc hello.ts 回车
执行JS文件中的代码：node hello.js

简化执行TS的步骤
使用ts-node包，可以“直接”在node.js中执行TS代码
全局安装ts-node包：
npm i -g ts-node

ts-node包 内部 将TS转化为了JS，然后执行JS代码
ts-node包提供了命令ts-node，用来执行TS代码

使用方式：ts-node hello.ts
ts文件

注释：
注释的内容不会执行
单行注释// 快捷键Ctrl+/ 只能注释这一行的内容

多行注释/* */ 快捷键shift+Alt+a

输出语句
作用：在终端中打印信息
node.js会执行我们写的代码，为了知道代码执行的结果，就需要使用输出语句，将结果打印出来

代码：console.log(‘你好TS’)
console表示控制台，在node.js中，指的是终端，log表示日志
小括号中的内容，表示要打印的信息

JavaScript的两个运行环境是：浏览器、Node.js
Typescript不能直接在浏览器中运行，需要将TS转化为JS
TS转化为JS tsc ts文件 如：tsc hello.ts
简化执行ts代码：ts-node ts文件
在控制台打印信息的代码：输出语句console.log()

变量是存储数据的容器

变量的使用分为两步：
1.声明变量并指定类型
let age:number;
2.给变量赋值，使用等号（=）来给变量赋值
age = 18

let age:number;

let是ts的关键字，用来声明变量
age是程序员自己定义的变量名称

:number用来指定变量age为数值类型 是类型注解
类型注解是一种为变量添加类型约束的方式
约定了什么类型，就只能给变量赋什么类型的值

;可省略

简化形式
声明变量的同时赋值
let age: number = 21

声明变量的时候要指定变量的类型

cls 实现终端内容的清除
终端快捷操作（上下键）

vscode中代码下方的红色波浪线表示代码报错

变量的命名规则：
变量名称只能出现：字母、数字、下划线、美元符号，并且不能以数字开头
变量名称区分大小写

变量的命名规范：变量名称要有意义，顾名思义。
使用驼峰命名法：首字母小写，后面每个单词首字母大写

区分文字、图片、音乐、视频等数据类型
typescript中的数据类型分为两大类：
1.原始类型（基本数据类型）
2.对象类型（复杂数据类型）
常用的基本数据类型有：number/string/boolean/undefined/null
数字类型/字符串类型/布尔值类型
let age: number = 21 number（数字类型）
console.log(‘你好TS’) ‘你好TS’（字符串类型） 字符串单独使用没有作为变量时不需要加类型注解

数字类型包含整数值和浮点型（小数）值
也可以包含：正数和负数
不能缺少类型注解: number 类型注解是给变量加的

字符串：由零个或多个字符串联而成的，用来表示文本信息
console.log(‘你好TS’)
console.log(’’) //空字符串

字符串可以使用单引号’或双引号",推荐使用单引号

字符串类型的类型注解为：string，声明变量时要添加类型注解

布尔类型用来表示真或假
只有两个值，分别是：true（真）和false（假）
布尔类型的类型注解为boolean

undefined和null只有一个值，值为类型本身
undefined类型的值和类型注解为：undefined
null类型的值和类型注解为：null
let u: undefined = undefined
let n: null = null

undefined表示声明但未赋值的变量值（找不到值）
let u: undefined
console.log(u) //变量u的值为undefined

null表示声明了变量并已赋值，值为null（能找到，值就是null）

运算符也称为操作符，用来实现赋值（=）、算数运算、比较等功能的符号

算数运算符：加（+）、减（-）、乘（*）、除（/）
算数运算符：进行算术运算时使用的符号，用于两个数值之间的计算

+号，不仅可以用于加法计算，还能实现字符串拼接
加号两边只要有一边是字符串，就执行字符串拼接
加法两边都为数值类型才执行加法计算

console.log(2-‘5’)
console.log(‘5’-3) //报错 算数运算符的左右侧必须是数字类型

除加号外，其他算术运算符只应该跟数字类型一起使用

其他方式：将字符串类型转换为数字类型
在字符串前面添加+号，可以将字符串类型（string）转化为数字类型（number），字符串内容为数字时才有意义

赋值运算符：将等号右边的值赋值给它左边的变量

let age: number = 18
将18赋值给左侧的变量age

age = age + 1
先执行等号右边的代码，将计算结果赋值给等号左边的变量

除了等号（=）外，还包括加等（+=）、减等（-=）、乘等（*=）、除等（/=）

age = age + 1 等效于 age += 1

自增和自减运算符
自增（++）运算符是+= 1的简化形式，自减（–）运算符是-= 1的简化形式
age++会让变量age的值加1

自增（++）运算符用来实现变量的值加1；自减（–）运算符实现变量的值减1

注意：++或–，只能让变量的值增加或减少1

比较运算符：用于比较两个数据的值，并返回比较的结果，结果为布尔类型（true或false）

比较运算符包含6个：
大于（>）
大于等于（>=）
小于（<）
小于等于（<=）
等于（=）
不等于（!）

比较运算符的作用是比较两个数据的值
比较结果是布尔类型
比较运算符常用于数字类型的比较

逻辑运算符
与 并且（两个条件同时满足）
或 或者（只要某一个条件满足）
非 不是（取反）

逻辑运算符通常用于布尔类型的计算，并且结果也是布尔类型 比较运算符的结果也是布尔值

与（逻辑与），用&&符号表示。当&&两边的值同时为true，结果才为true，否则，为false
console.log(2 > 1 && 2 >= 2) //结果为true

或（逻辑或），用||符号表示。当||两边的值只要有一个为true，结果就为true，否则，为false
console.log(3 < 2 || 1 <= 2) //结果为true

非（逻辑非），符号为!，表示取反。即!true结果为false，!false结果为true
console.log(!false || false) //结果为true

两个条件同时满足时再执行操作，用逻辑于&&
只要有一个条件满足就执行操作，用逻辑或||
逻辑非表示 取反!

/* //算术运算符
//加
console.log(2 + 3)
//减
console.log(2 - 3)
//乘
console.log(2 * 3)
//除
console.log(4 / 2) */

/* //字符串拼接
console.log(‘泰勒’ + ‘斯威夫特’)

console.log(1 + ‘2’)
console.log(‘1’ + 2) */

/* //报错 算数运算符的左右侧必须是数字类型
console.log(2 - ‘5’)
console.log(‘5’ - 3) */

/* //将字符串类型转换为数字类型
console.log(2 - +‘5’)

let age: number = +‘18’ */

/* //赋值 将等号右边的值赋值给它左边的变量
let age: number = 18
//age = age + 1
//简化形式
age += 1

console.log(age) */

/* // 自增和自减运算符
let age: number = 18
//加等 age += 1
//更简化的形式自加++
// age++
//自减
age–

console.log(age) */

/* //比较运算符
//大于
console.log(3 > 5)
//大于等于
console.log(5 >= 3)
//小于
console.log(1 < 3)
//小于等于
console.log(3 <= 2)

//相等 错误 3和4没有重叠 3永远不等于4 返回false
// console.log(3 === 4)
//将其改成变量可验证其是否相等
let num1: number = 3
let num2: number = 4
console.log(num1 === num2)

//不相等 错误 3和4没有重叠 3永远不等于4 返回true
// console.log(3 !== 4)
//将其改成变量可验证其是否相等
let num1: number = 3
let num2: number = 4
console.log(num1 !== num2) */

//逻辑运算符

//与
console.log(true && false)
//比较运算符的结果也是布尔值
console.log(2 > 1 && 2 >= 2)

//或
console.log(true || false)
console.log(3 < 2 || 1 <= 2)

//非
console.log(!true)
console.log(!false || false)

语句
条件语句：根据判断条件的结果（真或假），来执行不同的代码，从而实现不同的功能

条件执行时，首先判断条件是否满足。
如果条件满足，就做某件事情
如果条件不满足，就做另一件事情

条件语句也叫分支语句，不同的情况就是不同的分支

if语句
在Typescript中if语句就是实现条件判断的

if语句的语法：
if （判断条件）{
条件满足时，要做的事情
}

判断条件：布尔类型（true或false）
如果判断条件为真，就执行要做的事情
否则，如果判断条件为假，则不执行{}中的代码

语句是一个完整的句子，用来使某件事情发生（或实现某个功能）

else语句
在Typescript中else语句不能单独使用，必须配合if语句来使用
else语句表示：条件不满足，要做的事情（if语句的对立面）

if （判断条件）{
条件满足时，要做的事情
}else{
条件不满足，要做的事情
}

如果判断条件为假，就执行条件不满足时要做的事情

三元运算符
作用：根据判断条件的真假，得到不同的结果

语法：
结果 = 判断条件 ? 值1 : 值2

如果判断条件为真，结果为值1
否则，如果判断条件为假，结果为值2

得到结果的类型由值1和值2的类型决定（一般值1和值2的类型相同）

循环语句
在Typescript中，要实现重复做某件事情，就需要用到循环语句，来减少重复劳动提升效率

在Typescript中，for循环就是实现重复做某件事情的循环语句

for循环的组成：
1.初始化语句（默认值）：声明计数器变量用来记录循环次数（执行一次）。不能放在循环中重复执行
2.判断条件：判断循环次数是否达到目标次数
3.计数器更新：完成一次循环让计数器数量加1
4.循环体：循环的代码，也就是要重复做的事情

语法：
for (初始化语句;判断条件;计数器更新) {
循环体
}

初始化语句：声明计数器变量，记录循环次数
判断条件：判断循环次数是否达到目标次数
计数器更新：计数器数量加1
循环体：重复执行的代码，也就是要重复做的事情

//打印3遍
for (let i: number = 1; i <= 3; i++) {
console.log(‘落霞与孤鹜齐飞，秋水共长天一色。’)
}

for循环的执行过程
1.初始化语句：只会执行一次
2.重复执行的部分：判断条件、循环的代码、计数器更新

断点调试
断点（Breakpoint）：程序暂停的位置（调试时，程序运行到此处，就会暂停）

VSCode断点调试配置
配置步骤：
第一步：准备要调试的ts文件
第二步：添加调试配置
1.打开调试窗口：点击左侧活动栏（Debug）按钮
2.生成默认配置：点击DEBUG后面的下拉框，选择添加配置
3.修改配置内容如下
{
// 使用 IntelliSense 了解相关属性。
// 悬停以查看现有属性的描述。
// 欲了解更多信息，请访问: https://go.microsoft.com/fwlink/?linkid=830387
“version”: “0.2.0”,
“configurations”: [
{
“type”: “node”,
“request”: “launch”,
“name”: “调试TS代码”,
//ts-node命令：“直接”运行ts代码
//作用：调试时加载ts-node包（在调试时“直接”运行ts代码）
“runtimeArgs”: [
“-r”,
“ts-node/register”
],
//a.ts表示要调试的TS文件（可修改为其他 要调试的ts文件 ）
“args”: [
“${workspaceFolder}/a.ts”
]
}
]
}
第三步：安装调试用到的包
1.在当前目录中打开终端窗口
2.在终端中输入以下命令
npm i ts-node typescript

调试技巧：
调试控制台中查看console.log输出
监视变量的值（1.鼠标移入变量 2.将变量添加到左侧监视窗口，回车）

for循环执行的特点是：连续且不间断
break和continue常用在循环语句中，用来改变循环的执行过程，让循环提前结束

break能够让循环提前结束（终止循环）

例：吃到第3个（没吃），剩下的就不吃了
for (let i: number = 1; i <= 5; i++) {
if (i === 3) {
break
}
console.log(‘正在吃第’ + i + ‘个包子’)
}

continue能够让循环间断执行，常用于循环语句中（跳过本次循环，继续下一次循环）

语句示例代码：
/* //变量isVip表示：是(true)否(false)为会员
let isVip: boolean = false

//需求：
//1.如果是会员，就打印’看完整电源’
//2.如果不是会员，就打印’试看5分钟
if (isVip) {
console.log(‘看完整电源’)
}
else {
console.log(‘试看5分钟’)
} */

/* if else 语句练习

根据年龄做出判断：
1.如果年龄小于18岁，就打印：‘未成年’
2.否则，就打印：‘成年’ */

/* //使用变量age来作为年龄
let age: number = 17

//if else语句使用的重点：找出判断条件

//判断条件：年龄是否小于18岁
//age<18 是布尔类型
if (age < 18) {
console.log(‘未成年’)
}
else {
console.log(‘成年’)
} */

/* //三元运算符
//判断5大于3吗？
//如果大于，就得到：‘大于’；否则，得到：‘小于’
//变量的类型为值1和值2的类型
// let result: string = 5 < 3 ? ‘大于’ : ‘小于’
// console.log(result)

let age: number = 17
let result: string = age < 18 ? ‘未成年’ : ‘成年’
console.log(result) */

/* //循环语句
//在ts中，打印3遍内容

for (let i: number = 1; i <= 3; i++) {
console.log(‘落霞与孤鹜齐飞，秋水共长天一色。’)
} */

/* //断点调试

console.log(‘1 准备开始执行 for 循环’)

for (let i: number = 1; i <= 3; i++) {
console.log(‘落霞与孤鹜齐飞，秋水共长天一色。’)
}

console.log(‘2 for 循环执行结束’) */

/* // for循环练习

// 1.在终端中打印出1-5
for (let i: number = 1; i <= 5; i++) {
console.log(i)
}

// 2.买了5个包子，吃包子
// 要求：打印出’正在吃第n个包子’
for (let i: number = 1; i <= 5; i++) {
console.log(‘正在吃第’ + i + ‘个包子’) //字符串拼接
//console.log(‘i’) //字符串i
//console.log(i) //计数器变量i
}

// 3.计算1-100之间所有整数的和
let sum: number = 0 //声明变量
for (let i: number = 1; i <= 100; i++) {
//sum = sum + i //计算1-n整数的和 sum = sum +n
sum += i //简化
}
console.log(sum) */

// break 终止循环
//吃到（没吃）第3个，剩下的就不吃了
for (let i: number = 1; i <= 5; i++) {
if (i === 3) {
break
}
console.log(‘正在吃第’ + i + ‘个包子’)
}

//continue 间断执行(跳过本次)
//吃到第3个有虫，这个就不再吃了（跳过第3个），但没吃饱，继续吃下一个
for (let i: number = 1; i <= 5; i++) {
if (i === 3) {
continue
}
console.log(‘正在吃第’ + i + ‘个包子’)
}

数组：
数组是用于存放多个数据的集合
只需要使用一个数组（[]），就可以存储任意多个数据

数组中，通常是相同类型的数据

创建数组:
方式1：
[]表示数组，如果数组中没有内容，就是一个空数组

let names: string[] = [] //表示字符串类型的数组，此数组中只能出现字符串类型
数组的类型注解由两部分组成：类型+[]
let names: string[] = [‘川崎’, ‘雅马哈’, ‘2’]

数组多个元素之间用逗号（,）隔开
数组中的每一项内容称为：元素

方式2：
创建空数组：
let names: string[] = new Array()
等效于
let names: string[] = []

创建有数据数组：

let names: string[] = new Array(‘川崎’, ‘雅马哈’, ‘2’)
等效于
let names: string[] = [‘川崎’, ‘雅马哈’, ‘2’]

数组示例代码：
//创建数组
//let names: string[] = [‘川崎’, ‘雅马哈’, ‘2’] //将数组存储到names变量中 此表示字符串类型的数组，此数组中只能出现字符串类型
//console.log(names)

//方式2
//创建空数组
//let names: string[] = new Array()
//console.log(names)
//创建有数据数组
let names: string[] = new Array(‘川崎’, ‘雅马哈’, ‘2’)
console.log(names)

//数组有长度也有顺序，并且数组中的每个元素也有序号
//数组长度：表示数组中元素的个数，通过数组的length属性获取
let cars: string[] = [‘川崎’, ‘雅马哈’, ‘本田’, ‘宝马’]
//获取数组长度 数组.length
console.log(cars.length)

//数组索引 数组中的每个元素都有自己的序号
//我们把数组中元素的序号，称为索引（下标），数组中的元素与索引一一对应
//数组索引是从0开始的
//let cars: string[] = [‘川崎’,‘雅马哈’,‘本田’,‘宝马’]
//数组的索引号分别为 0 1 2 3
//此数组长度为4 最大索引号为3
//最大索引为：数组长度（length）-1

//取值：从数组中获取到某一个元素的值，就是从数组中取值
//数组中的元素与索引是一一对应的，通过索引获取到某一个元素的值
//语法：数组名称[索引号]
console.log(cars[1])

//存值：如果要修改数组中某个元素的值，就要使用数组存值
//技巧：先 获取 到要修改的元素，然后再 存值
//语法： 数组名称[索引号] = 新值
cars[0] = ‘Kawasaki’
cars[1] = ‘Yamaha’
console.log(cars)

//添加元素
//存值的语法是：数组名称[索引] = 新值
//根据索引是否存在，有两种功能：1.修改元素 2.添加元素
//如果索引存在，就表示：修改元素
//如果索引不存在，就表示：添加元素
cars[4] = ‘铃木’
//注意：给数组添加一个元素之后，数组长度也会加1
console.log(cars.length)
//或通过 数组名.length 添加新的元素
cars[cars.length] = ‘杜卡迪’
cars[cars.length] = ‘KTM’
console.log(cars)

//遍历数组：也就是把数组中的所有元素挨个获取一次 如计算数组中所有数字的和
let sums: number[] = [10, 20, 30, 60]
//重复取值 使用for循环在数组中重复取值
//重复取值的规律：索引号自增（每次加1），而for循环的计数器i也是自增的

// for循环遍历数组
//注意1：因为数组索引是从0开始的，所以计数器i的默认值为0
//注意2：判断条件 i<数组长度 应该根据数组长度来计算，公式为数组长度减一，也就是：sums.length-1(最大索引)
//优势：不管数组中元素的数量怎么变化，for循环的判断条件不需要改动
// for (let i: number = 0; i <= sums.length - 1; i++){
// //获取sums数组中的每一个元素
// console.log(sums[i])
// }
//简化判断条件（计数器i的值为整数，所以，i<=2与i<3作用相同）
for (let i: number = 0; i < sums.length; i++) {
console.log(sums[i])
}

//求数组中所有元素的和[10, 60 ,80]
//准备一个数组
let num: number[] = [10, 60, 80]
//思路：
//1.准备一个变量来存储和（he）
let he: number = 0
//2.使用for循环遍历数组，拿到数组中的每一个元素
for (let i: number = 0; i < num.length; i++) {
//3.在for循环中让he += 数组的每一个元素
he += num[i]
}
console.log(he)

//找出数组中的最大值
let num3: number[] = [2, 66, 10, 5]
//思路：
//1.创建变量max，来存储最大值
//2.从数组中取值 假设数组中的第一个元素为最大值，作为max的默认值
let max: number = num3[0]
//3.使用for循环遍历数组，获取到数组中的每一个元素 max默认存储的为索引号为0的第一个元素，所以索引号为0的第一个元素没有必要参与比较
for (let i: number = 1; i < num3.length; i++) {
//4.在for循环中，判断每一个元素 num1[i] 是否大于max
//5.如果大于，就把该元素存储到max中（max一直都是最大值）
//如果小于或等于，不做任何处理（因为找的是最大值）
if (num3[i] > max) {
max = num3[i]
}
}
console.log(max)

//找出数组中所有不为0的元素
let num2: number[] = [2, 0, 6, 10, 0, 5, 0]
//思路：
//1.创建一个新数组（newArr），存储不为0的元素
let newArr: number[] = []
//2.使用for循环遍历数组，拿到数组中的每一个元素num2[i]
for (let i: number = 0; i < num2.length; i++) {
//3.在for循环中判断每一个元素是否为0 !不等于
if (num2[i] ! 0) {
//4.如果不为0，那么，将当前元素num2[i]添加到新数组中 添加元素
newArr[newArr.length] = num2[i]
//数组名称 数组长度 新值
}
//5.如果为0，就不做任何处理
}
console.log(newArr)

函数：
//相似的代码重复写，代码冗余
//使用函数来包装（封装）相似的代码，在需要的时候调用函数，相似的代码不再重复写
//函数，即声明一次可以调用任意多次的一段代码
//通过将要实现的功能，使用函数封装起来，实现代码复用，提升开发效率
//函数的三个主要内容：1.输入（参数） 2.处理（函数体） 3.输出（返回值）
function getSum(num0: number[]) {
let sum: number = 0
for (let i: number = 0; i < num0.length; i++) {
sum += num0[i]
}
console.log(sum)
}
let num0: number[] = [6, 8, 9]
getSum(num0)
let num1: number[] = [1, 7, 8]
getSum(num1)

//函数的使用分为两步：
//1.声明函数
// function 函数名称() {
// 函数体
// }
//函数名称：推荐以动词开头，因为函数表示做一件事情，实现一个功能
//函数体：表示要实现功能的代码，复用的代码
function sing() {
console.log(‘You are beautiful’)
}
//2.调用函数
//函数名称()
//只有调用函数后，函数中的代码才会执行
sing()

//创建一个函数，计算两个变量num1、num2的和
//1.创建函数sum
function sum() {
//2.在函数体中，计算两个变量num1、num2的和
let num1: number = 6
let num2: number = 8
let result: number = num1 + num2
console.log(result)
}
//3.调用函数sum
sum()

//函数参数
//函数参数的作用：增加了函数的灵活性、通用性，针对相同的功能，能够适应更多的数据
function song(songName: string) {
console.log(songName)
}
//调用函数时动态传入参数
song(‘千千万万’)
song(‘年少有为’)

//函数的参数分为两部分：形参、实参
//通过形参和实参的配合，函数可以接收动态的数据，从而让函数变得更加灵活，强大
//形参：声明函数时指定的参数，放在声明函数的小括号中
//语法：形参名称:类型注释 如songName: string 类似于变量声明，但是没有赋值
//作用：指定函数可接收的数据
//然后就可以在函数体中，像使用变量一样使用形参了
function shu(shuName: number) {
console.log(shuName)
}
//实参：调用函数时传入的参数，放在调用函数的小括号中
//作用：实参是一个具体的值（比如’字符串’、8、[]等），用来赋值给形参
shu(18)

//根据具体功能，函数参数可以有多个，参数之间使用逗号（,）来分隔
//实参和形参按照顺序一一对应
function fn(name: string, age: number) {
console.log(‘1.’ + name)
console.log(‘2.’ + age)
}
//调用函数
//调用函数时，鼠标放在函数名称上，会显示该函数的参数以及类型
//实参必须符合形参的类型要求，否则会报错
fn(‘Join Snow’, 18)
//代码会报错，因为实参没有与形参一一对应
//()

//1.改造函数（sum），实现计算任意两个数字的和
// function sum1() {
// let num1: number = 6
// let num2: number = 9
// let result: number = num1 + num2
// console.log(result)
// }
// sum1()
// sum1()

function sum1(num1: number, num2: number) {
let result: number = num1 + num2
console.log(result)
}
sum1(8, 6)
sum1(10, 20)

//2.封装函数（getSum），计算任意数组中所有元素的和
//说明：数组中的元素为数值类型
function GetSum(num: number[]) {
//声明一个sum来统计和
let sum: number = 0
for (let i: number = 0; i < num.length; i++) {
sum += num[i]
}
console.log(sum)
}
GetSum([1, 2, 6, 8, 7])
GetSum([66, 77, 88])

//函数返回值
//函数返回值的作用：将函数内部计算的结果返回，以便于使用该结果继续参与其他的计算
//需求：计算以下两次调用结果的和
//getSum([2, 4, 6])
//getSum([1, 3, 5])
//关键点：拿到函数内部计算出来的结果，然后才能进行后续的加法计算
function GEtSum(num: number[]): number {
let sum: number = 0
for (let i: number = 0; i < num.length; i++) {
sum += num[i]
}
// console.log(sum)
return sum
}
//如果没有指定函数的返回值，那么这个函数的默认返回类型就是void
//通过变量来接收GEtSum([1, 3, 5]) + GEtSum([2, 4, 6])结果
let result: number = GEtSum([1, 3, 5]) + GEtSum([2, 4, 6])
console.log(result)

//函数返回值的基本使用
//步骤：1.指定返回值类型 在声明函数的小括号后面，通过 :类型注解 指定

// function fn(): 类型注解 {}

// 2.指定返回值 在函数体中，使用return关键字来返回函数执行的结果

//function fn(): 类型注解 {
//返回值必须符合返回值类型的要求，否则会报错
// return 返回值
// }
function un(): number {
return 18
}
// (1)使用变量接收函数返回值
// let result: 类型注解 = fn()
let jie: number = un()
console.log(jie)
//使用变量接收函数返回值，相当于：直接将函数返回值赋值给变量
//let jie: number = 18
//注意：变量（result）的类型与函数（fn）的返回值类型要一致
//然后，就可以使用这个变量（返回值），继续进行其他计算了
console.log(jie * 2)

//（2）直接使用函数调用的结果（返回值），进行其他计算
console.log(un() / 2)

//改造函数（GetSum）计算数组中所有元素的和并返回
function GETSum(num: number[]): number {
let sum: number = 0
for (let i: number = 0; i < num.length; i++) {
sum += num[i]
}
// console.log(sum)
return sum
}
//声明变量接收返回结果
let res: number = GETSum([1, 2, 6, 8, 7])
console.log(res)

//封装函数（calcArea），计算任意三角形面积并返回
function calcArea(a: number, h: number): number {
//声明变量接收结果
//三角形面积公式：1/2 * 底 * 高
//let area: number = 1 / 2 * a * h
//return area
//简化
return 1 / 2 * a * h
}
//调用封装好的函数打印结果
console.log(calcArea(3, 4))

//封装函数（getMax），得到任意两个数中的最大值并返回
function getMax(a: number, b: number): number {
// if (a > b) {
// return a
// }
// else {
// return b
// }
//三元表达式简化if else
return a > b ? a : b
}
//打印调用的结果
console.log(getMax(6, 8))
console.log(getMax(6, 6))
console.log(getMax(9, 8))

//return的说明
//1.将函数的计算结果返回
//2.终止函数代码的执行，即：return后面的代码不会执行
function mn(): number {
console.log(‘mn 执行了’)
return 18
console.log(‘我不会执行，放在这没有意义’)
}
mn()
//3.return只能在函数中使用，否则会报错
// return
//4.return可以单独使用（后面可以不跟内容），用来刻意终止函数的执行
//如果函数没有返回值，默认返回值类型是：void（空），可省略不写
function play(age: number): void {
if (age < 18) {
return
}
console.log(‘可以去网吧’)
}
play(17) //情况1：进入if后return，后续代码不执行
play(20) //情况2：不进if，直接打印内容