ArkTS的进阶语法-4(函数补充,正则表达式)

文章目录

    • ArkTS的进阶语法
      • 1. 泛型
        • 1.泛型函数
        • 2.使用泛型约束
        • 3.多个泛型参数
        • 4.泛型接口
        • 5.泛型类
      • 2.工具类型
        • **1.partial<Type>**
      • 3.空安全
        • 1.联合类型设置为空
        • 2.非空断言运算符
        • 3.空值合并运算符
        • 4.可选链
      • 4.模块化
        • 1.默认导入与导出
        • 2.按需导入与导出
        • 3.全部导入
      • 5.定时器
        • 1.setTimeout(延迟执行)
        • 2.setInterval(间隔执行)
      • 6.递归
      • 7.常用内置对象
        • **1.Math对象**
        • **2.Date对象**
      • 8.String字符串对象
        • 1.split(分隔)
        • 2.trim(去空格)
        • 3.toLowerCase(转小写)和toUpperCase(转大写)
        • 4.includes(判断是否存在)
        • 5.slice(提取)
      • 9.数组的常用方法
        • 1.indexOf方法
        • 2.join方法
        • 3.forEach方法
        • 4.map方法
        • 5.filter方法
        • 6.sort方法
        • 7.reduce方法
        • 8.findIndex方法
        • 9.find方法
        • 10.every方法
        • 11.some方法
      • 10.函数补充🎈
        • 1.回调函数
        • 2.箭头函数化简
      • 11.正则表达式🎈
        • 1.概述
        • 2.基本使用
        • 3.元字符
          • 1.边界符
          • 2.量词
          • 3.范围
          • 4.字符类
          • 5.替换和修饰符

ArkTS的进阶语法

(今天更新的是,函数补充与正则表达式)

1. 泛型

​ 泛型在保证类型安全(不丢失类型信息)的同时,可以让函数等与多种不同的类型一起工作,灵活可复用

**通俗一点就是:类型是可变的!

1.泛型函数

顾名思义就是,泛型和函数结合到一起使用

Type 是泛型参数的名字,类似于之前的形参,

  • 可以自行定义,有意义即可

  • 首字母大写

  • 参见泛型参数名 T、Type

    // 函数定义
    function identity<Type>(arg: Type): Type {return arg;
    }// 在使用的时候传入具体的类型,函数就可以正常工作啦~
    identity<string>('123')
    identity<number>(123)
    identity<boolean>(false)
    identity<string[]>(['1', '2', '3'])

    结合 编译器 的 类型推断 功能,在使用函数的时候还可以进行简写,比如下面的写法,和上面的是一样的。

    虽然大部分时候可以推断出类型,但是如果碰到 编译器 无法推断类型时,就需要显式传入类型参数,这在更复杂的示例中可能会发生。

identity('123')
identity(123)
identity(false)
identity(['1', '2', '3'])

使用泛型变量

类型变量可以用在任意支持€w3e4rtuy1256789 -=`的位置,实现更为复杂的功能

//将类型变量 Type,作为数组项的类型即可
function identity<Type>(arr: Type[]): number {return arr.length
}
2.使用泛型约束

如果开发中不希望任意的类型都可以传递给 **类型参数 ,**就可以通过泛型约束来完成

核心步骤:

  1. 定义用来约束的 接口(interface)

  2. 类型参数通过 extends 即可实现约束

    interface 接口{属性:类型
    }
    function 函数<Type extends 接口>(){}// 后续使用函数时,传入的类型必须要有 接口中的属性
    ------试一试
    interface ILengthwise {length: number
    }function identity<Type extends ILengthwise>(arr: Type) {console.log(arr.length.toString())
    }// 使用的时候 只要有 length 属性即可
    identity([1, 2, 3, 4]) // 数组有 length 属性 正常运行
    identity('1234') // 字符串也有 length 属性 正常运行// identity(124) // 数值没有 length 属性 报错class Cloth implements ILengthwise {length: number = 10
    }class Trousers {length: number = 110
    }identity(new Cloth()) // Cloth 有 length 属性 正常运行
    identity(new Trousers()) // Trousers 有 length 属性 正常运行
3.多个泛型参数

日常开发的时候,如果有需要可以添加多个 类型变量,只需要定义并使用 多个类型变量即可

function funcA<T, T2>(param1: T, param2: T2) {console.log('参数 1', param1)console.log('参数 2', param2)
}funcA<string, number>('张三', 18)
funcA<string[], boolean[]>(['张三','李四'], [false])
4.泛型接口

定义接口时结合泛型,那么这个接口就是 泛型接口

interface 接口<Type>{// 内部使用Type
}
interface IdFunc<Type> {id: (value: Type) => Typeids: () => Type[]
}let obj: IdFunc<number> = {id(value) { return value },ids() { return [1, 3, 5] }
}
5.泛型类

和泛型接口类似,如果定义类的时候结合泛型,那么这个类就是 泛型类

class 类名<Type>{// 内部可以使用 Type
}
-----试一试
// 定义
class Person <T> {id: Tconstructor(id: T) {this.id = id}getId(): T {return this.id}
}// 使用
let p = new Person<number>(10)

2.工具类型

ArkTS提供了4 中工具类型,来帮组我们简化编码

4 种工具类型中,熟练掌握 Partial 即可,可以简化编码

1.partial

(partial:部分)

基于传入的Type类型构造一个[新类型],将Type的所有属性设置为可选。

(泛型约束太复杂了这个完全可以替代他)

type 新类型 = Partial<接口>
type 新类型 = Partial<类>// 后续使用新类型即可
interface Person {name: string age: number friends: string[]
}type ParPerson = Partial<Person>// 因为都是可选的,可以设置为空对象
let p: ParPerson = {}

2.Required

基于传入的Type类型构造一个【新类型】,将 Type 的所有属性设置为必填

type 新类型 = Required<接口>
type 新类型 = Required<类>// 后续使用新类型即可
class Person {name?: stringage?: numberfriends?: string[]
}type RequiredPerson = Required<Person>// 都是必须得属性,必须设置值
let p: Required<Person> = {name: 'jack',age: 10,friends: []
}

3.Readonly

基于 Type构造一个【新类型】,并将Type 的所有属性设置为readonly

type 新类型 = Readonly<接口>
type 新类型 = Readonly<类>// 后续使用新类型即可
class Person {name: string = ''age: number = 0
}type ReadonlyIPerson = Readonly<Person>const p: ReadonlyIPerson = {name: 'jack',age: 10
}p.name = 'rose' // 报错 属性全部变成只读

4.Record<Keys,Type>

构造一个对象类型,其属性键为Keys,属性值为Type。该实用程序可用于将一种类型的属性映射到另一种类型。

class CatInfo {age: number = 0breed: string = ''
}// 联合类型
type CatName = "miffy" | "boris" | "mordred";// 通过Record 构建新的对象类型
// 属性名:必须是CatName 中的值
// 属性值:必须是CatInfo 类型
type Ctype = Record<CatName, CatInfo>const cats: Ctype = {'miffy': { age: 5, breed: "Maine Coon" },'boris': { age: 5, breed: "Maine Coon" },'mordred': { age: 16, breed: "British Shorthair" },
};

3.空安全

默认情况下,ArkTS中的所有类型都是不可为空的。如果要设置为空,需要进行特殊的处理,并且在获取 可能为空的值的时候也需要特殊处理

1.联合类型设置为空
let x: number = null;    // 编译时错误
let y: string = null;    // 编译时错误
let z: number[] = null;  // 编译时错误
通过联合类型指定为空即可,使用时可能需要判断是否为空
// 通过联合类型设置为空
let x: number | null = null;
x = 1;    // ok
x = null; // ok
// 取值的时候,根据需求可能需要考虑 屏蔽掉空值的情况
if (x != null) { /* do something */ }
2.非空断言运算符

后缀运算符! 可用于断言其操作数为非空。

应用于空值时,运算符将抛出错误。否则,值的类型将从T | null更改为T:

let x: number | null = 1;
let y: number
y = x + 1;  // 编译时错误:无法对可空值作加法
y = x! + 1; // 通过非空断言,告诉编译器 x不为 null
3.空值合并运算符

空值合并二元运算符?? 用于检查左侧表达式的求值是否等于null。如果是,则表达式的结果为右侧表达式;否则,结果为左侧表达式。

换句话说,a ?? b等价于三元运算符a != null ? a : b。

在以下示例中,getNick方法如果设置了昵称,则返回昵称;否则,返回空字符串:

class Person {name: string | null = nullgetName(): string {// return this.name === null ? '' : this.name// 等同于 如果 name不为空 就返回 name 反之返回 ''return this.name ?? ''}
}
4.可选链

在访问对象属性时,如果该属性是undefined或者null,可选链运算符会返回undefined。

(可选链?当前面的对象不为空或undefined才调用属性或方法)

class Dog {bark() {console.log('啊呜~')}
}class Person {name?: stringdog?: Dogconstructor(name: string, dog?: Dog) {this.name = namethis.dog = dog}
}const p: Person = new Person('jack')// p.dog.bark()// 报错 dog 可能为空// 逻辑判断
if (p.dog) {p.dog.bark()
}// 当 dog不为null 或 undefined 时 再调用 bark 并且不会报错
p.dog?.bark()

4.模块化

  1. 把一个大的程序拆分成【互相依赖】的若干小文件
  2. 这些小文件还可以通过【特定的语法】组合到一起
  3. 这个过程称之为【模块化】

优点:

1.更好维护

2.更好的复用性

缺点:

需要学习模块化语法

分析:

  1. 功能写完只有10行代码,模块化没啥必要!
  2. 功能写完有100行,或者1000行代码,里面有【好几段逻辑】在其他地方也要用–模块化
1.默认导入与导出

ArkTS 中每个 ets 文件都可以看做是一个模块,默认只能在当前文件中使用,如果要在其他位置中使用就需要:

  1. 当前模块中 导出模块

  2. 需要使用的地方 导入模块

    // 默认导出 
    export default 需要导出的内容// 默认导入
    import xxx from '模块路径'//试一试
    // Model.ets
    // 一起写
    export default class Person {name: string = ''
    }// 分开写
    // export default Person// 只能有一个默认导出// TestModel.ets
    import Person from './model'const p: Person = new Person()

    路径

    / 表示进入某个文件夹里面.  表示当前文件所在文件夹                  ./.. 表示当前文件的上一级文件夹             ../
2.按需导入与导出

如果有很多的东西需要导出,可以使用按需导出,他也有配套的导入语法

// ---------- Model.ets ----------
const info: string = '信息'// 单独写
export const num: number = 10function sayHi() {console.log('你好吗~')
}// 或者 写到 {} 内部
export {info, sayHi
}// ---------- MainFile.ets ----------
import { info, num, sayHi as sayHello } from './Model'console.log('info:', info)
// 起别名
sayHello()
console.log('num:', num + '')
3.全部导入

导出部分不需要调整,调整导入的语法即可

import * as Utils from './utils'
// 通过 Utils 即可获取 utils模块中导出的所有内容

5.定时器

日常开发中如果需要代码 延迟一会执行,或者每隔一段时间执行一次,就可以使用定时器

定时器有两种:

  1. setTimeout: 延迟执行
  2. setInterval: 间隔执行
1.setTimeout(延迟执行)

setTimeout可以用来设置一个定时器,当设置的时间到了之后就会去执行指定的函数

执行一次用 setTimeout

setTimeout、clearTimeout是一个全局函数,可以直接使用

@Entry
@Component
struct Page01_timeoutAndInterval {timeId?: numberbuild() {Column({ space: 20 }) {Text('延时器-Timeout').fontSize(30).width('100%').textAlign(TextAlign.Center)Row({ space: 20 }) {Button('开启延时器').onClick(() => {// 开启延时器let timeId = setTimeout(() => {// 延迟执行逻辑console.log('代码执行啦')}, 2000)//  保存定时器 idthis.timeId = timeId})Button('关闭延时器').onClick(() => {// 调用 clearTimeout 清除定时器clearTimeout(this.timeId)})}}.padding(10)}
}
2.setInterval(间隔执行)

setInterval 也是可以用来设置一个定时器,根据设置的时间间隔来执行指定的函数

执行多次用 setInterval!!

setInterval、clearInterval是一个全局函数,可以直接使用

// 1. 基本使用
setInterval(()=>{// 延迟执行的逻辑
},时间)// 2. 获取返回的定时器 id
const timeId = setInterval(()=>{// 延迟执行的逻辑
},时间)// 3. 根据定时器 id 清除定时器
clearInterval(timeId)
//试一试
@Entry
@Component
struct Page02_interval{// 只是用来保存数据,不影响 UI 可以不加状态修饰符timeId?: numberbuild() {Column({ space: 20 }) {Text('定时器-Interval').fontSize(30).width('100%').textAlign(TextAlign.Center)Row({ space: 20 }) {Button('开启延时器').onClick(() => {this.timeId = setInterval(() => {console.log('代码执行啦~')}, 2000)})Button('关闭延时器').onClick(() => {clearInterval(this.timeId)})}}.padding(10)}
}

6.递归

调用自身的函数我们称之为递归函数

基本用法

在某种意义上说,递归近似于循环。两者都重复执行相同的代码,并且两者都需要一个终止条件(避免无限循环,或者在这种情况下更确切地说是无限递归)。

// 没有退出条件的 递归函数--无限递归
function func(){func()
}
//试一试
let num: number = 1function printLog(num: number) {console.log(`你好,第${num}次打印`)// 递减num--// 退出条件if (num > 1) {printLog(num)}
}// 打印 10 次
printLog(10)

7.常用内置对象

1.Math对象

是一个内置对象,它拥有一些数学常数属性和数学函数方法。Math 的所有属性与方法都是静态的,使用的时候直接通过Math点出来即可

常用方法

方法说明
Math.random()返回一个 0 到 1 之间的伪随机数。
Math.ceil(x)返回大于一个数的最小整数,即一个数向上取整后的值。
Math.floor(x)返回小于一个数的最大整数,即一个数向下取整后的值。
Math.round(x)返回四舍五入后的整数。
Math.abs(x)返回一个数的绝对值
Math.max([x[,y[, …]]])返回零到多个数值中最大值。
Math.min([x[,y[, …]]])返回零到多个数值中最小值。
Math.Pi圆周率,一个圆的周长和直径之比,约等于 3.14159。
…更多内容参考文档
const numA: number = 1.5
console.log(Math.ceil(numA) + '') // 向上取整 2
console.log(Math.floor(numA) + '') // 向下取整 1
console.log(Math.round(numA) + '') // 四舍五入 2const numB:number = -9
console.log(Math.abs(numB) + '') // 绝对值 9const numList: number[] = [13, 2, 31, 42, 15, 56, 27, 28]
const max: number = Math.max(...numList)
const min: number = Math.min(...numList)
console.log('max:', max) // 最大值
console.log('min:', min) // 最小值// 0-1 取得到0,取不到 1
console.log(Math.random() + '')// 返回 0-n的随机数的函数
function getRandomArbitrary(max: number): number {return Math.floor(Math.random() * (max + 1))
}// 返回 min-max 的随机数的函数
function getRandomIntInclusive(min: number, max: number): number {return Math.floor(Math.random() * (max - min + 1)) + min; //含最大值,含最小值
}
2.Date对象

ArkTS 中另外一个常用的内置对象 Date,他可以用来创建、解析、操作日期和时间。

使用 Date 对象首先需要通过 new 操作符进行实例化

// 获取当前日期
const date1: Date = new Date()// 获取指定日期
// ISO 8601 格式(YYYY-MM-DDTHH:mm:ss.ssZ)中间用 T 分隔
const date2: Date = new Date('1995-01-01T01:11:00')
// Unix时间戳 是指从1970年1月1日(UTC)开始到现在经历的时间(毫秒)
const date3: Date = new Date(1706170405708)

实例方法

方法名作用说明
getFullYear获取年份4 位数年份
getMonth获取月份取值 0-11
getDate获取日期月份中的日期
getHours获取小时
getMinutes获取分钟
getSeconds获取秒
getDay获取星期周日为 0

静态方法

方法名作用说明
now获取当前时间时间戳
// 大伙执行的时候 即可获取到时间戳啦~
console.log(Date.now()+'')

8.String字符串对象

String 提供了不少的方法让我们来处理字符,咱们来看几个常用的

1.split(分隔)

split() 方法根据传入的内容将字符串分隔为数组

字符串.split(分隔符)// 返回切割之后的数组
--------试一试
// 1. 切割为数组
const branchFilter: string = ' 全部分路  | 对抗路 |   中路  | 发育路  | 游走 | 打野 '
console.log('测试',branchFilter.split('|'))
// 全部分路  , 对抗路 ,   中路  , 发育路  , 游走 , 打野const tabFilter: string = '  所有段位  - 巅峰赛1350+ -   顶端排位 - 赛事  '
console.log('测试',tabFilter.split('-'))
// 所有段位  , 巅峰赛1350+ ,   顶端排位 , 赛事// 2. 获取日期
const dateStr:string =  '2024-04-27'
console.log('测试',dateStr.split('-'))
//2024,04,27
2.trim(去空格)

trim方法会从字符串的两端移除空白字符,并返回一个【新的字符串】,而不会修改原始字符串。

字符串.trim()// 返回去除空格之后的字符串// trim 去除两边空格
// 1.基础文本
const str: string = '   123   '
console.log(str.trim()) // 123
// 2.用户名
const username = '  jack  '
// 3.密码
const password = ' 1234abc '
3.toLowerCase(转小写)和toUpperCase(转大写)

toLowerCase() 方法将该字符串转换为小写形式。toUpperCase() 方法将该字符串转换为大写形式。

字符串.toLowerCase()// 返回转为小写之后的字符串
字符串.toUpperCase()// 返回转为大写之后的字符串
-----------应用场景
// toLowerCase 转小写 toUpperCase 转大写
// 1.验证码
const code = '1a2C'
// 2.带后缀名的文件信息
const filename = 'abc.PNG'
// 3.编程语言中的关键字
const boolStr = 'true'
4.includes(判断是否存在)

includes() 方法执行区分大小写的搜索,以确定是否可以在一个字符串中找到另一个字符串,并根据情况返回 true 或 false。

字符串.includes(查询的字符串)// 返回判断结果 true / false
-------------------应用场景
// includes 方法 判断是否存在特定字符
// 1. 判断是否有@符号
const emailStr = 'user@example.com'// 2.判断是否为gif文件
const fileName = 'dance.gif'// 3.判断密码中是否有下划线
const pass = 'itheima-123'// 4.判断是否有特定词汇 ,比如 牛逼 最 等
const comment = `杭州是一个令人惊叹的地方,我刚刚度过了一个超牛逼的旅行。
西湖的景色太美了,特别是在夕阳西下时,湖水波光粼粼,真是美得不像话。
还去了灵隐寺,感受到了古老的气息和庄严的氛围,让我心生敬意。
在杭州还尝了最正宗的龙井茶和小笼包,老牛逼了!
最喜欢的是游览乌镇古镇,那里的古建筑和石板路让我仿佛穿越回古代。这次旅行真是太棒了,杭州是个值得一游的地方!`
5.slice(提取)

slice方法提取字符串的一部分,并将其作为新字符串返回,而不修改原始字符串。

字符串.slice(起始索引)// 从起始索引切割到末尾
字符串.slice(起始索引,结束索引) // 从起始索引,切换到结束索引
----------应用场景
// slice方法
// 1. 提取 逗号 之后的内容
const str1 = 'hi,你好吗?'// 2. 提取 中午
const str2 = '今天中午吃的是西兰花炒蛋'

9.数组的常用方法

数组都是 Array 的实例化对象,它提供了很多的 方法来帮助我们快速处理数据

下表列出了一些较为常用方法:

方法名作用
indexof判断元素在数组中的索引,不存在返回-1
join根据传入内容拼接数组,默认为,返回拼接结果,字符串
forEach遍历数组,并且将数组的每一项作为参数传入到回调函数中,无返回值
map基于原数组,创建一个新数组
filter根据回调函数的执行结果,筛选出符合要求的元素,返回一个新数组
find返回数组中满足提供的测试函数的第一个元素的值。否则返回 undefined
findIndex返回数组中满足条件第一个元素的索引。若没有找到则返回 -1。
every返回数组中是否每一个元素都符合要求。
some返回数组中是否有一个元素符合要求。
sort方法的作用是对原数组的元素进行排序
reduce数组求和

…还有一些其他的方法,之后的课程中陆续补充

1.indexOf方法

indexOf() 方法返回数组中第一次出现给定元素的下标,如果不存在则返回 -1。

数组.indexof(要查找的元素)// 存在返回具体下标,不存在返回 -1
-------应用
// 1. 数字数组
const nums = [1,2,3,4,5]
// 2. 字符串数组
const foods = ['西兰花','西葫芦','西兰花']
2.join方法

**join()**方法将数组用逗号或指定的分隔符,将数组的每一项拼接到一起

数组.join('分隔符') // 基于传入的分隔符 将数组的每一项拼接到一起
数组.join() // 使用【逗号】将数组的每一项 拼接到一起
//试一试
const elements = ['花菜', '西兰花', '菜花']
console.log(elements.join()) // 默认拼接!
console.log(elements.join('')) // 使用''代替,
console.log(elements.join('-')) // 用 - 拼接
3.forEach方法

forEach() 方法会遍历数组,并且将数组的每一项作为参数传入到回调函数中,无返回值

数组.forEach((数组项:类型,索引:number)=>{// 逻辑
})数组.forEach(数组项=>{// 逻辑
})-------基于提供的数据,通过 forEach 依次打印每一项的 name和 title 属性
// 接口
interface HeroInfo {id: numbername: stringtitle: string
}// 数组
const arr: HeroInfo[] = [{ id: 105, name: '廉颇', title: '正义爆轰' },{ id: 106, name: '小乔', title: '恋之微风' },{ id: 107, name: '赵云', title: '苍天翔龙' },{ id: 108, name: '墨子', title: '和平守望' },
]
arr.forEach((item:HeroInfo)=>{console.log('测试',item.name,item.title)
})
4.map方法

map() 方法创建一个新数组,基于原数组,创建一个新数组(映射)

  1. 如果能推断出类型,泛型参数可以不写
  2. 如果无法推断,需要人为指定类型
数组.map<返回值类型>((数组项,索引)=>{ return xxx })
// 如果返回值的类型编译器无法推断,就需要自行设置
---------应用
// map 基本使用01- 基于numArr返回新数组,每一个数组翻倍
// map 基本使用01- 基于numArr返回新数组,每一个数组翻倍,并转为字符串
const numArr: number[] = [1, 2, 3, 4, 5]
const numArr2: number[] = numArr.map((v => {return v * 2
}))
const strArr: string[] = numArr.map((v => {return (v * 2).toString()
}))// map 基本使用03 - 基于 foodArr 返回新数组,每一项 都是一个对象
// name 为食物名,price 为5-10 的随机价格 ,比如{ name:'西兰花',price:10 }
interface FoodInfo {name: stringprice: number
}const foodArr: string[] = ['西兰花', '西葫芦', '西红柿', '西北风']
foodArr.map<FoodInfo>((v => {return {name: v,price: Math.random() * 11 + 5}
}))
5.filter方法

根据回调函数的执行结果,筛选出符合要求的元素,返回一个新数组

数组.filter((数组项:类型,索引:number)=>{return true  // 或者可以解析为 true 的值   需要这一项return false // 或者可以解析为 false 的值  不需要这一项
})
--------应用
// filter基本使用 01 - 筛选出大于 5 的数
const nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]const res1 = nums.filter((item: number, index: number) => {if (item > 5) {return true} else {return false}
})
console.log('筛选之后的结果是:', res1)interface Food {name: stringprice: number
}// filter基本使用 02 - 筛选出价格大于 5 的食物
const foods: Food[] = [{name: '西兰花',price: 6},{name: '西红柿',price: 3},{name: '榴莲',price: 30},{name: '葱花',price: 1}
]
const res2 = foods.filter((item: Food, index: number) => {if (item.price > 5) {return true} else {return false}
})
// 复杂类型的数据(对象,对象数组),可以通过 JSON.stringify()转为 字符串进行打印
console.log('筛选之后的食物:', JSON.stringify(res2))
6.sort方法

方法就地对数组的元素进行排序,并返回对相同数组的引用。排序是改变原数组

// 自定义排序规则
数组.sort((第一个比较元素,第二个比较元素)=>{return 大于0 值 // a 会调换到 b 的后面return 小于0 值 // a 会继续留在 b 的前面return 0 // 不变
})
------------------------应用
// 数值数组排序
const arr = [5, 12, 8, 130, 44]arr.sort((a,b)=>{// return a-breturn b-a
})
console.log(arr.toString())interface Food{name:stringprice:number
}// 对象数组排序
const foods:Food[] = [{name: '西兰花',price: 6},{name: '西红柿',price: 3},{name: '榴莲',price: 30},{name: '葱花',price: 1}
]
foods.sort((a,b)=>{return a.price-b.price
})
console.log(JSON.stringify(foods))
7.reduce方法

reduce方法的作用是求和,他会逐个遍历数组元素,每一步都将当前元素的值与前一步的结果相加

// 纯数值类数组求和
reduce((上一次累加结果,当前元素值)=>{})
// 对象数组求和
reduce((上一次累加结果,当前元素值)=>{}, 初始值)// 数值数组排序
const arr = [5, 12, 8, 130, 44]const res = arr.reduce((a, b) => {// return a-breturn a + b
})
console.log('res:', res)interface Food {name: stringprice: numbercount: number
}// 对象数组排序
const foods: Food[] = [{name: '西兰花',price: 6,count: 2},{name: '西红柿',price: 3,count: 3},{name: '榴莲',price: 30,count: 2},{name: '葱花',price: 1,count: 10}
]
const total = foods.reduce((a, b) => {return a + b.price * b.count
}, 0)
console.log('total:', total)
8.findIndex方法

findIndex() 方法返回数组中满足提供的测试函数的第一个元素的索引。若没有找到对应元素则返回 -1

// 索引,如果用不上可以省略不写
数组.findIndex((数组项:类型,索引:number)=>{return true  // 找到了需要的元素return false // 或者可以解析为 false 的值  不是这一项
})
// 1. 字符串数组
const arr = ['西兰花', '西葫芦', '西兰花']arr.findIndex((item: string, index: number) => {if (item == '西葫芦') {return true} else {return false}
})
9.find方法

find() 方法返回通过测试(函数内判断)的数组的第一个元素的值,找不到返回 undefined

// 索引,如果用不上可以省略不写
数组.find((数组项:类型,索引:number)=>{return true  // 找到了需要的元素return false // 或者可以解析为 false 的值  不是这一项
})// 1. 字符串数组
const arr = ['西兰花', '西葫芦', '西兰花']let idx:string|undefined = arr.find((item: string, index: number) => {if (item == '西葫芦') {return true} else {return false}
})
console.log('测试',idx)//测试 西葫芦
10.every方法

every 方法方测试一个数组内的【所有元素】是否都能通过指定函数的测试。它返回一个布尔值

// 索引,如果用不上可以省略不写
const res = 数组.every((数组项:类型,索引:number)=>{return true  // 当前元素符合要求 返回 truereturn false // 当前元素不符合要求 返回 false
})
// res 可以获取是否每个元素都符合要求
-----------应用
// 1. 数值数组 判断是否每个元素都大于 2
const numArr:number[] = [2,4,6,8,10]
let res:boolean = numArr.every((item:number)=>{return item>2
})
console.log('测试',res)
// 2. 字符串数组 判断是否每个元素里面都有绿字
const foodArr:string[] = ['绿茶','绿豆','绿色能源','绿色心情','茉莉奶绿']
let res2:boolean = foodArr.every((item:string)=>{return item.includes('绿')
})
console.log('测试',res2)
11.some方法

some 方法测试数组中是否【至少有一个元素】通过了由提供的函数实现的测试。

// 索引,如果用不上可以省略不写
const res = 数组.every((数组项:类型,索引:number)=>{return true  // 当前元素符合要求 返回 truereturn false // 当前元素不符合要求 返回 false
})
// res 可以获取是否 【至少有一个元素】符合要求
--------应用
// 1. 数值数组 判断是否每个元素都大于 2
const numArr:number[] = [2,4,6,8,10]
let res:boolean = numArr.some((item:number)=>{return item>2
})
console.log('测试',res)
// 2. 字符串数组 判断是否每个元素里面都有绿字
const foodArr:string[] = ['绿茶','绿豆','绿色能源','绿色心情','茉莉奶绿']
let res2:boolean = foodArr.some((item:string)=>{return item.includes('张三')
})
console.log('测试',res2)

10.函数补充🎈

1.回调函数

作为实参传入另一个函数,并在该函数内被调用,用来完成某些任务的函数,成为回调函数

咱们用过很多次,比如:

Button.onClick(()=>{})Scroll(){}.onScroll(()=>{})List(){}.onScrollToIndex(()=>{})Image().onAppear(()=>{});[1,2,3].filter((item:number,index:number)=>{})// ...
// 作为参数传递的函数 都是 回调函数
2.箭头函数化简

箭头函数在日常使用中,如果满足一些特定的条件,可以写的更为简洁

简写条件:

  1. 函数体只有一行,可以省略大括号

  2. 省略大括号时,如果有 return,也需要一起省略

  3. 参数只有一个,且不需要写类型,可以省略小括号

    const numArr = [1, 2, 3, 4]numArr.forEach((item: number) => {console.log('', item)
    })const res = numArr.map((item: number) => {return item * 2
    })
    const res2 = numArr.filter((item: number) => {if (item > 2) {return true} else {return false}
    })
    -------------------简写形式
    const numArr = [1, 2, 3, 4]numArr.forEach(item => console.log('', item))const res = numArr.map(item => item * 2)const res2 = numArr.filter(item => item > 2)

11.正则表达式🎈

1.概述

正则表达式是用于匹配字符串中字符组合的模式(规则)

日常开发中主要用来做三件事:匹配、替换、提取

  • 手机号表单要求用户只能输入11位的数字 (匹配)
  • 过滤掉页面内容中的一些敏感词(替换)
  • 从字符串中获取我们想要的特定部分(提取)等
2.基本使用
  1. 定义正则

  2. 使用正则

    // 方式 1:简写
    const res1: RegExp = /ArkTS/
    // 方式 2:通过实例化的方式创建
    const reg2: RegExp = new RegExp('ArkTS')console.log('web:', res1.test('ArkTS')) // true
    console.log('web:', res1.test('Java')) // false
3.元字符

元字符指的是在正则表达式中,有特殊含义的符号

正则表达式中绝大多数的字符都是描述他们本身,比如:
/ArkTS/ // 表示 ArkTS 这 5 个字母
有一些具有特殊含义的字符,可以极大的提高正则表达式的灵活性和功能,比如:/[a-z]/   // 只能是 a-z中的字母

像上面的 [] , - 就是元字符,接下来咱们来看看有哪些常用的元字符

1.边界符

正则表达式中的边界符(位置符)用来提示字符所处的位置,主要有两个字符

边界符说明
^表示匹配行首的文本(以谁开始)
$表示匹配行尾的文本(以谁结束)

如果 ^ 和 $ 在一起,表示必须是精确匹配

// 元字符之边界符
// 1. 匹配开头的位置 ^
const reg = /^ArkTS/
console.log('res:', reg.test('ArkTS语法')) //true
console.log('res:', reg.test('学习ArkTS')) //false
console.log('res:', reg.test('学习ArkTS语法')) //false
console.log('res:', reg.test('Ar')) //false// 2. 匹配结束的位置 $
const reg1 = /ArkTS$/
console.log('res1:', reg1.test('ArkTS语法')) //false
console.log('res1:', reg1.test('学习ArkTS')) //true
console.log('res1:', reg1.test('学习ArkTS语法')) //false
console.log('res1:', reg1.test('Ar')) //false// 3. 精确匹配 ^ $
const reg2 = /^ArkTS$/
console.log('res2:', reg2.test('ArkTS语法')) //false
console.log('res2:', reg2.test('学习ArkTS')) //false
console.log('res2:', reg2.test('学习ArkTS语法')) //false
console.log('res2:', reg2.test('ArkTS')) //true
console.log('res2:', reg2.test('Ar')) //false
console.log('res2:', reg2.test('ArkTSArkTS')) //false
2.量词

量词用来设定某个模式的重复次数

量词说明
*重复零次或更多次
+重复一次或更多次
?重复零次或一次
{n}重复 n 次
{n,}重复 n 次或更多次
{n,m}重复 n 到 m 次
// 元字符之量词
// 1. * 重复次数 >= 0 次
const reg1 = /^w*$/
console.log('res:', reg1.test('')) //true
console.log('res:', reg1.test('w')) //true
console.log('res:', reg1.test('ww')) //true
console.log('res:', '-----------------------')// 2. + 重复次数 >= 1 次
const reg2 = /^w+$/
console.log('res:', reg2.test('')) //false
console.log('res:', reg2.test('w')) //true
console.log('res:', reg2.test('ww')) //true
console.log('res:', '-----------------------')// 3. ? 重复次数  0 || 1
const reg3 = /^w?$/
console.log('res:', reg3.test('')) //true
console.log('res:', reg3.test('w')) //true
console.log('res:', reg3.test('ww')) //false
console.log('res:', '-----------------------')// 4. {n} 重复 n 次
const reg4 = /^w{3}$/
console.log('res:', reg4.test('')) //false
console.log('res:', reg4.test('w')) //false
console.log('res:', reg4.test('ww')) //false
console.log('res:', reg4.test('www')) //true
console.log('res:', reg4.test('wwww')) //false
console.log('res:', '-----------------------')// 5. {n,} 重复次数 >= n
const reg5 = /^w{2,}$/
console.log('res:', reg5.test('')) //false
console.log('res:', reg5.test('w')) //false
console.log('res:', reg5.test('ww')) //true
console.log('res:', reg5.test('www')) //true
console.log('res:', '-----------------------')// 6. {n,m}   n =< 重复次数 <= m
const reg6 = /^w{2,4}$/
console.log('res:', reg6.test('w')) //false
console.log('res:', reg6.test('ww')) //true
console.log('res:', reg6.test('www')) //true
console.log('res:', reg6.test('wwww')) //true
console.log('res:', reg6.test('wwwww')) //false
3.范围

表示字符的范围,定义的规则限定在某个范围,比如只能是英文字母,或者数字等等,用表示范围

范围说明
[abc]匹配包含的单个字符。也就是只有a ll b ll c 这三个单字符返回true,可以理解为多选1
[a-z]连字符。来指定字符范围。[a-z]表示 a到226个英文字母
[^abc]取反符。[^a-z]匹配除了小写字母以外的字符
// 元字符之范围  []
// 1. [abc] 匹配包含的单个字符, 多选1
const reg1 = /^[abc]$/
console.log('res:', reg1.test('a')) //true
console.log('res:', reg1.test('b')) //true
console.log('res:', reg1.test('c')) //true
console.log('res:', reg1.test('d')) //false
console.log('res:', reg1.test('ab')) // false
console.log('测试','--------------------------')
// 2. [a-z] 连字符 单个
const reg2 = /^[a-z]$/
console.log('res:', reg2.test('a')) //true
console.log('res:', reg2.test('p')) //true
console.log('res:', reg2.test('0')) //false
console.log('res:', reg2.test('A')) //false
console.log('测试','-------------------------')
// 3. [^a-z] 取反符
const reg5 = /^[^a-z]$/
console.log('res:', reg5.test('a')) //false
console.log('res:', reg5.test('A')) //true
console.log('res:', reg5.test('么')) //true
console.log('测试','-------------------------')// 4.想要包含小写字母,大写字母 ,数字
const reg3 = /^[a-zA-Z0-9]$/
console.log('res:', reg3.test('B')) //true
console.log('res:', reg3.test('b')) //true
console.log('res:', reg3.test('9')) //true
console.log('res:', reg3.test(',')) //false
console.log('测试','-------------------------')// 5.试一试:用户名可以输入英文字母,数字,可以加下划线,要求 6~16位
const reg4:RegExp =/^[a-zA-Z0-9_]{6,12}$/
console.log('测试',reg4.test('jack_1321'))//true
console.log('测试',reg4.test('1321'))//false
4.字符类

某些常见模式的简写方式,区分字母和数字

字符类说明
\d匹配0-9之间的任一数字,相当于[0-9]
\D匹配所有0-9以外的字符,相当于[^0-9]
\w匹配任意的字母、数字和下划线,相当于[A-Za-z0-9_]
\W除所有字母、数字和下划线以外的字符,相当于[^A-Za-z0-9_]
\s匹配空格(包括換行符、制表符、空格符等),相等于[\t\r\n\v\f]
\S匹配非空格的字符,相当于[^\t\r\n\v\f]
// 试一试。匹配 1990-10-10 、1990-1-1 这种格式
const reg:RegExp =/^\d{4}-\d{1,2}-\d{1,2}$/console.log('测试',reg.test('1990'))
console.log('测试',reg.test('1990-1-1'))
console.log('测试','---------------------------')
//完整版日期正则
const reg1:RegExp = /^(19|20)\d{2}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/
console.log('测试',reg1.test("1990-10-10"));  // true
console.log('测试',reg1.test("1990-1-1"));     // false
console.log('测试',reg1.test("1990-13-01"));  // false
console.log('测试',reg1.test("1990-01-32"));  // false
console.log('测试',reg1.test("2000-02-29"));  // true,这是简单版不能判断闰年
console.log('测试',reg1.test("2004-02-29"));  // true,因为2004年是闰年
5.替换和修饰符

字符串的 replace 方法,可以结合正则进行字符串的替换

默认是不是只能检索一个?

使用正则结合修饰符可以实现大小写区分,是否匹配所有

修饰符说明
i单词 ignore 的缩写,正则匹配时字母不区分大小写
g单词 global 的缩写,匹配所有满足正则表达式的结果
// 检索规则:文本、正则
// 替换内容:文本
// 返回值:替换之后的结果
字符串.replace(检索规则,替换内容)// 替换和修饰符
const str = '欢迎大家学习ArkTS,相信大家一定能学好ArkTS!!!'
// 将 ArkTS 替换位 鸿蒙开发咋写? 分别用正则和字符串作为检索规则
--------------试一试
// 替换和修饰符
const str = '欢迎大家学习ArkTS,相信大家一定能学好ArkTS!!!'
// replace 返回值是替换完毕的字符串
console.log(str.replace(/arkts/, '鸿蒙开发')) //欢迎大家学习ArkTS,相信大家一定能学好ArkTS!!!
console.log(str.replace(/arkts/i, '鸿蒙开发')) // 欢迎大家学习鸿蒙开发,相信大家一定能学好ArkTS!!!
console.log(str.replace(/arkts/gi, '鸿蒙开发')) //欢迎大家学习鸿蒙开发,相信大家一定能学好鸿蒙开发!!!
console.log(str.replace(/arkts/ig, '鸿蒙开发')) //欢迎大家学习鸿蒙开发,相信大家一定能学好鸿蒙开发!!!

1-1 这种格式
const reg:RegExp =/^\d{4}-\d{1,2}-\d{1,2}$/

console.log(‘测试’,reg.test(‘1990’))
console.log(‘测试’,reg.test(‘1990-1-1’))
console.log(‘测试’,‘---------------------------’)
//完整版日期正则
const reg1:RegExp = /^(19|20)\d{2}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/
console.log(‘测试’,reg1.test(“1990-10-10”)); // true
console.log(‘测试’,reg1.test(“1990-1-1”)); // false
console.log(‘测试’,reg1.test(“1990-13-01”)); // false
console.log(‘测试’,reg1.test(“1990-01-32”)); // false
console.log(‘测试’,reg1.test(“2000-02-29”)); // true,这是简单版不能判断闰年
console.log(‘测试’,reg1.test(“2004-02-29”)); // true,因为2004年是闰年


##### 5.替换和修饰符字符串的 **replace** 方法,可以结合正则进行字符串的替换 默认是不是只能检索一个?使用正则结合修饰符可以实现大小写区分,是否匹配所有| **修饰符** | **说明**                                         |
| ---------- | ------------------------------------------------ |
| i          | 单词 ignore 的缩写,正则匹配时字母不区分大小写   |
| g          | 单词 global 的缩写,匹配所有满足正则表达式的结果 |

// 检索规则:文本、正则
// 替换内容:文本
// 返回值:替换之后的结果
字符串.replace(检索规则,替换内容)
// 替换和修饰符
const str = ‘欢迎大家学习ArkTS,相信大家一定能学好ArkTS!!!’
// 将 ArkTS 替换位 鸿蒙开发咋写? 分别用正则和字符串作为检索规则
--------------试一试
// 替换和修饰符
const str = ‘欢迎大家学习ArkTS,相信大家一定能学好ArkTS!!!’
// replace 返回值是替换完毕的字符串
console.log(str.replace(/arkts/, ‘鸿蒙开发’)) //欢迎大家学习ArkTS,相信大家一定能学好ArkTS!!!
console.log(str.replace(/arkts/i, ‘鸿蒙开发’)) // 欢迎大家学习鸿蒙开发,相信大家一定能学好ArkTS!!!
console.log(str.replace(/arkts/gi, ‘鸿蒙开发’)) //欢迎大家学习鸿蒙开发,相信大家一定能学好鸿蒙开发!!!
console.log(str.replace(/arkts/ig, ‘鸿蒙开发’)) //欢迎大家学习鸿蒙开发,相信大家一定能学好鸿蒙开发!!!


### ---------------------------------------感觉写的不错的话就点点关注吧😘❤❤❤----------------------------------------------

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.xdnf.cn/news/14969.html

如若内容造成侵权/违法违规/事实不符,请联系一条长河网进行投诉反馈,一经查实,立即删除!

相关文章

【Linux】多线程(中)

目录 一、线程互斥 1.1 互斥概念 1.2 互斥量mutex 1.3 互斥量相关API &#xff08;1&#xff09;初始化互斥量 &#xff08;2&#xff09;销毁互斥量 &#xff08;3&#xff09;互斥量加锁和解锁 1.4 互斥量原理 1.5 重入和线程安全 二、死锁 2.1 概念 2.2 造成死锁…

光控资本:什么是庄家洗盘和出货?各有什么特征?

什么是庄家洗盘和出货&#xff1f; 庄家洗盘&#xff1a;庄家洗盘是指庄家使用其筹码优势来作出一些K线图形&#xff0c;进而引起市场上的散户投资者的惊惧&#xff0c;然后洗掉散户手中的起浮筹码&#xff0c;使盘面更加安稳&#xff0c;减轻股票后期拉升压力的行为。 庄家洗…

【Vue3】知识汇总,附详细定义和源码详解,后续出微信小程序项目(5)

快速跳转&#xff1a; 我的个人博客主页&#x1f449;&#xff1a;Reuuse博客 新开专栏&#x1f449;&#xff1a;Vue3专栏 参考文献&#x1f449;&#xff1a;uniapp官网 免费图标&#x1f449;&#xff1a;阿里巴巴矢量图标库 ❀ 感谢支持&#xff01;☀ 前情提要 &#x…

5ire:开源AI工具的新纪元

抖知书老师推荐&#xff1a; 在AI技术飞速发展的今天&#xff0c;5ire作为一款开源的AI工具&#xff0c;已经悄然改变了我们对传统AI工具的认知。那些曾对AI技术抱有疑虑的人们&#xff0c;现在可以更加自信地拥抱这一变革。原本担心工作会被AI取代的忧虑逐渐平息&#xff0c;…

Unity图形学之Shader2.0矩阵变换

1.将物体坐标系 变换 到世界坐标系&#xff1a; Unity3D里面矩阵是左乘的 P(世界) M(物体到世界的变换矩阵) * P(物体) 规律&#xff1a;3D变换 首先将物体坐标系变换到世界 2.将 世界坐标 变换 到相机坐标 P(相机) M(世界到相机的变换矩阵) * P(世界) using System.Col…

网上商城系统设计与Spring Boot框架

3 系统分析 当用户确定开发一款程序时&#xff0c;是需要遵循下面的顺序进行工作&#xff0c;概括为&#xff1a;系统分析–>系统设计–>系统开发–>系统测试&#xff0c;无论这个过程是否有变更或者迭代&#xff0c;都是按照这样的顺序开展工作的。系统分析就是分析系…

JavaWeb-JSP

可以写java代码也前端代码 jsp本来就是Serclet jsp脚本 EL表达式 要将jsp获取的东西放到域中 转发到/el-demo.jsp中 jsp中用&#xffe5;{}获取域中的信息 JSTL标签 c&#xff1a;if标签 jsp中 c:forEach标签 MVC 查询所有 在service层实现 Servlet代码&#xff1a;1.创建Br…

Area-Composition模型部署指南

一、介绍 本模型可以通过输入不同的提示词&#xff0c;然后根据各部分提示词进行融合生成图片。如下图&#xff1a; 此图像包含 4 个不同的区域&#xff1a;夜晚、傍晚、白天、早晨 二、部署 环境要求&#xff1a; 最低显存&#xff1a;10G 1. 部署ComfyUI 本篇的模型部署…

经典文献阅读之--DROID-SLAM(完美的深度学习slam框架)

0. 简介 深度学习和SLAM现在结合越来越紧密了&#xff0c;但是实际上很多时候深度学习只会作为一个block放在slam系统中。而很多深度学习slam算法&#xff0c;在slam这边的性能都不是太好&#xff0c;尤其是回环和全局优化这块。因为有一些深度学习的工作就不太适合做回环检测…

【windows 下使用 tree】

windows git bash 下使用 tree 下载tree二进制文件 https://gnuwin32.sourceforge.net/packages/tree.htm 解压缩找到 tree.exe 扔进git bash的命令目录 C:\Program Files\Git\usr\bin 打开测试

GxtWaitCursor:Qt下基于RAII的鼠标等待光标类

有时我们需要以阻塞的方式执行一点耗时的操作&#xff0c;这时需要主窗口光标呈现忙状态&#xff0c;GxtWaitCursor正是为此设计&#xff1b;重载的构造函数&#xff0c;可以让光标呈现忙状态一定时间后自动恢复。 GxtWaitCursor.h #pragma once#include <QObject>// // …

通过Python,Tkinter,文本文件,Openpyxl。实现【图书馆管理系统实现技术】

图书馆管理系统 目录 项目概述类定义 -Book类 -Library类书籍管理功能 -添加书籍 -查找书籍 -借阅书籍 -归还书籍 -列出所有书籍数据持久化 -保存书籍 -加载书籍操作日志记录图形用户界面(GUI) -界面设计 -功能实现代码原理总结实现界面 ![](https://i-blog.csdnimg.cn/dire…

飞牛私有云访问外网

飞牛私有云 fnOS NAS 是一款有着卓越的性能以及强大的兼容性和智能化的管理界面&#xff0c;它之所以能在 NAS 市场中脱颖而出&#xff0c;是因为 fnOS 基于最新的 Linux 内核&#xff08;Debian发行版&#xff09;深度开发&#xff0c;不仅兼容主流 x86 硬件&#xff0c;还支持…

HTML之表单学习记录

如果一个页面仅仅供用户浏览&#xff0c;那就是静态页面。如果这个页面还能实现与服务器进行数据交互&#xff08;像注册登录、话费充值、评论交流&#xff09;​&#xff0c;那就是动态页面。表单是我们接触动态页面的第一步。其中表单最重要的作用就是&#xff1a;在浏览器端…

redis 原理篇 30 redis内存回收 过期key处理

三十分&#xff0c;又是一个长视频&#xff0c;挺好&#xff0c;但是从标题来看&#xff0c;内容应该很简单&#xff0c;或者说&#xff0c;是他能讲简单的类型&#xff0c;本来还想再搞一篇&#xff0c;但是三十分钟的话&#xff0c;五点五十了&#xff0c;算了&#xff0c;下…

【STM32F1】——无线收发模块RF200与串口通信

【STM32F1】——无线收发模块RF200与串口通信 一、简介 本篇主要对调试无线收发模块RF200的过程进行总结,实现了以下功能。 串口普通收发:使用STM32F103C8T6的USART2串口接收中断,实现两个无线收发模块RF200间的通信。二、RF200介绍 电压:3.4-5.5V工作频率:418~455MHz发…

【MySQL从入门到放弃】InnoDB磁盘结构(二)

前言 前面我们解析了InnoDB磁盘结构中的表空间、数据字典、双写缓冲区。 本文我们继续探究磁盘结构中剩余的几个核心组件:重做日志(redo log)、撤销日志(undo log)、二进制日志(binlog) 一、重做日志 ( redo log ) WAL(Write-Ahead Logging)机制 WAL 的全称是…

Python 绘图工具详解:使用 Matplotlib、Seaborn 和 Pyecharts 绘制散点图

目录 数据可视化1.使用 matplotlib 库matplotlib 库 2 .使用 seaborn 库seaborn 库 3 .使用 pyecharts库pyecharts库 注意1. 确保安装了所有必要的库2. 检查Jupyter Notebook的版本3. 使用render()方法保存为HTML文件4. 使用IFrame在Notebook中显示HTML文件5. 检查是否有其他输…

用vscode编写verilog时,如何有信号定义提示、信号定义跳转(go to definition)、模块跳转这些功能

&#xff08;一&#xff09;安装插件SystemVerilog - Language Support 安装一个vscode插件即可&#xff0c;插件叫SystemVerilog - Language Support。虽然说另一个插件“Verilog-HDL/SystemVerilog/Bluespec SystemVerilog”也有信号提示及定义跳转功能&#xff0c;但它只能提…

LLM RAG系列:一文详解RAG,看完这篇你必会(文末福利)

RAG系列 本文介绍了RAG以及RAG pipeline的整个流程&#xff0c;包括请求转换、路由和请求构造、索引和检索、生成和评估等&#xff0c;其中引用了大量有价值的论文。 参考Advanced RAG Series: Generation and Evaluation中的5篇文章&#xff0c;并丰富了相关内容。 请求转换…