ArkTS-数组详解

// 声明一个字符串数组
let array: string[] = []
// 添加元素
array.push('a','b')
// 删除数组末尾的元素并返回该元素。
array.pop()
// 添加一个数组
array.concat(['a','2','3'])
// 获取数组的长度
let length: number = array.length

// Array.join(separator?: string | undefined): string
// 将数组的所有元素添加到由指定分隔符字符串分隔的字符串中。
// @param separator用于在结果字符串中将数组中的一个元素与下一个元素分开的字符串。如果省略，数组元素之间用逗号分隔。
array.join(',')

// Array.reverse(): T[]
// 将数组中的元素逆序
array.reverse()

// Array.shift(): T | undefined
// 从数组中移除第一个元素并返回它。
// 如果数组为空，则返回undefined且不修改数组。
array.shift()

// Array.unshift(...items: T[]): number
// 在数组的开头插入新元素，并返回新的数组长度。
array.unshift('4')

// Array.slice(start?: number | undefined, end?: number | undefined): T[]
// 返回数组中一个section的副本。
// 对于开始和结束，可以使用负索引来表示与数组结束的偏移量。
// 例如，-2表示数组的倒数第二个元素。
// start数组指定部分的起始索引。如果start未定义，则切片从索引0开始。
// @param end数组指定部分的结束索引。它不包括索引‘end’处的元素。
// 如果end未定义，则切片扩展到数组的末尾。
// 比如获取下标为3到5的子数组
array.slice(3,5)

// Array.splice(start: number, deleteCount?: number | undefined): T[] (+1 overload)
// 从数组中删除元素，如果需要，在原来的位置插入新元素，并返回被删除的元素。
// param start数组中从零开始移除元素的位置。
// @param deleteCount要删除的元素数量。
// @返回一个包含被删除元素的数组。
array.splice(0,1)

// Array.sort(compareFn?: ((a: T, b: T) => number) | undefined): T[]
// 对数组进行排序。
// 这个方法改变数组并返回对相同数组的引用。
// @param compareFn函数用于确定元素的顺序。它有望回归
// 如果第一个参数小于第二个参数，则为负值，如果它们相等则为零，并且为正数
// 否则为*值。如果省略，则元素按升序、ASCII字符顺序排序。
array.sort((a,b) => a.length - b.length)

// Array.indexOf(searchElement: T, fromIndex?: number | undefined): number
// 返回数组中值第一次出现的索引，如果不存在则返回-1
// @param searchElement要在数组中找到的值。
// @param fromIndex数组的索引，从这里开始搜索。如果省略fromIndex，则从索引0开始搜索。
array.indexOf('1')

// Array.lastIndexOf(searchElement: T, fromIndex?: number | undefined): number
// 返回指定值在数组中最后出现的索引，如果不存在则返回-1。
// @param searchElement要在数组中找到的值。
// @param fromIndex开始向后搜索的数组索引。如果省略fromIndex，则从数组中的最后一个索引开始搜索。
array.lastIndexOf('1', 2)

// every(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean;
// 判断一个数组的所有成员是否满足指定的测试。
// @param predicate一个最多接受三个参数的函数。每个方法调用
// 对数组中的每个元素执行谓词函数，直到谓词返回一个值
// 可强制为布尔值false，或直到数组结束。
// @param thisArg在谓词函数中this关键字可以引用的对象。
// 如果省略thisArg，则使用undefined作为this值。
array.every((value,index,array) => value.length > 1)

// Array.some(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean
// 确定指定的回调函数是否对数组中的任何元素返回true。
// @param predicate一个最多接受三个参数的函数。一些方法调用
// 对数组中的每个元素执行谓词函数，直到谓词返回一个值
// 可强制转换为布尔值true，或直到数组结束。
// @param thisArg在谓词函数中this关键字可以引用的对象。
// 如果省略thisArg，则使用undefined作为this值。
array.some((value,index,array) => value.length > 1)

// map<u>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[];
// 对数组的每个元素调用一个定义好的回调函数，并返回一个包含结果的数组。
// @param callbackfn一个最多接受三个参数的函数。map方法对数组中的每个元素调用一次callbackfn函数。
// 在callbackfn函数中this关键字可以引用的对象。如果省略thisArg，则使用undefined作为this值。
array.map((e) => e.toLowerCase())

// filter(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): T[];
// 返回满足回调函数中指定条件的数组元素。
// @param predicate一个最多接受三个参数的函数。过滤器方法对数组中的每个元素调用谓词函数一次。
// @param thisArg在谓词函数中this关键字可以引用的对象。如果省略thisArg，则使用undefined作为this值。
array.filter((e,index,arr) => e.length == 1)

// reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T
// 为数组中的所有元素调用指定的回调函数。回调函数的返回值是累积的结果，并在下次调用回调函数时作为参数提供。
// @param callbackfn一个最多接受四个参数的函数。reduce方法对数组中的每个元素调用一次callbackfn函数。
// @param initialValue如果指定了initialValue，将作为初始值开始累积。对callbackfn函数的第一次调用将该值作为参数而不是数组值提供。
array.reduce((previousValue,currentValue,currentIndex,array) => previousValue + currentValue)

// find(predicate: (value: T, index: number, obj: T[]) => unknown, thisArg?: any): T | undefined;
// 返回数组中predicate为true且未定义的第一个元素的值
// @param predicate find按升序对数组的每个元素调用一次predicate
// 顺序，直到找到一个谓词返回true。如果找到了这样的元素，就找到
// 立即返回该元素值。否则，find返回undefined。
// @param thisArg如果提供，它将被用作每次调用的this值
// 谓词。如果未提供，则使用undefined。
array.find((value) => value == '1')

// findIndex(predicate: (value: T, index: number, obj: T[]) => unknown, thisArg?: any): number;
array.findIndex((value) => value == 'a')

// fill(value: T, start?: number, end?: number): this;
// 将所有从‘ start ’到‘ end ’索引的数组元素更改为静态‘ value ’，并返回修改后的数组
// @param value用来填充数组section的值
// @param开始索引开始填充数组。如果start为负，则将其视为
// length+start，其中length是数组的长度。
// @param结束索引停止填充数组在。如果end为负，则将其视为长度+结束。
array.fill('1', 0, 10)

// entries(): IterableIterator<[number, T]>;
// 返回数组中每个元素下标、值
array.entries()

// 返回每一个数组的下标
array.keys()

// 返回数组中值的可迭代对象
array.values()

// 是否包含该元素
array.includes('1')

// Array.forEach(callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any): void
// 使用 forEach 循环遍历数组
array.forEach((value,index,array) => console.log(value))

// 使用 for循环遍历数组
for (let i = 0; i < array.length; i++) {
    console.log(array[i]);
}

// 使用 for...of循环遍历数组：
for (let fruit of array) {
    console.log(fruit);
}
</u>

// Array.flat (this: T[], depth?: 1 | undefined): T[]
// 是一个用于将嵌套的数组 “拉平”（展平）为一维数组的方法。
// array：是要进行展平操作的数组。
// depth（可选）：指定要递归展平的层数，默认值为 1。如果设置为 Infinity，则会将数组完全展平，不管嵌套有多深。
const flatArray = [1, 2, [3, 4]]
const result1 = flatArray.flat()
console.log(result1.toString()) // 1,2,3,4

// 方法对数组中的每个元素执行一个提供的函数（映射函数），然后将结果数组展平成一个新的数组。
// 它首先对原数组的每个元素调用映射函数，得到一个新的数组，然后将这些新数组中的所有元素合并成一个单一的数组，
// 从而实现了映射和展平的操作
class User {
  id?: number
  name?: string
  hobbies?: string[]
}
const users = [
   { id: 1, name: 'Alice', hobbies: ['reading', 'painting'] },
   { id: 2, name: 'Bob', hobbies: ['running', 'swimming'] }
 ];
const hobbiesArray = users.flatMap(user => user.hobbies);
console.log(hobbiesArray);
// 输出 ["reading", "painting", "running", "swimming"]，先取出每个用户的 hobbies 数组，然后将这些数组展平成一个大的数组
//总的来说，flatMap 提供了一种方便的方式来对数组进行映射操作并同时展平结果，使得处理多维数组或具有嵌套结构的数组时更加简洁和高效。