array，即數(shù)組，是由可賦值給數(shù)組聲明中指定的元素類型的數(shù)據(jù)組成的對象。

數(shù)組可由數(shù)組復合字面量（即用方括號括起來的零個或多個表達式的列表，其中每個表達式為數(shù)組中的一個元素）來賦值。數(shù)組的長度由數(shù)組中元素的個數(shù)來確定。數(shù)組中第一個元素的索引為0。

常用函數(shù)

// 聲明一個字符串數(shù)組
let array: string[] = []
// 添加元素
array.push('a','b')
// 刪除數(shù)組末尾的元素并返回該元素。
array.pop()
// 添加一個數(shù)組
array.concat(['a','2','3'])
// 獲取數(shù)組的長度
let length: number = array.length

// Array<T>.join(separator?: string | undefined): string
// 將數(shù)組的所有元素添加到由指定分隔符字符串分隔的字符串中。
// @param separator用于在結果字符串中將數(shù)組中的一個元素與下一個元素分開的字符串。如果省略，數(shù)組元素之間用逗號分隔。
array.join(',')

// Array<T>.reverse(): T[]
// 將數(shù)組中的元素逆序
array.reverse()

// Array<T>.shift(): T | undefined
// 從數(shù)組中移除第一個元素并返回它。
// 如果數(shù)組為空，則返回undefined且不修改數(shù)組。
array.shift()

// Array<T>.unshift(...items: T[]): number
// 在數(shù)組的開頭插入新元素，并返回新的數(shù)組長度。
array.unshift('4')

// Array<T>.slice(start?: number | undefined, end?: number | undefined): T[]
// 返回數(shù)組中一個section的副本。
// 對于開始和結束，可以使用負索引來表示與數(shù)組結束的偏移量。
// 例如，-2表示數(shù)組的倒數(shù)第二個元素。
// start數(shù)組指定部分的起始索引。如果start未定義，則切片從索引0開始。
// @param end數(shù)組指定部分的結束索引。它不包括索引‘end’處的元素。
// 如果end未定義，則切片擴展到數(shù)組的末尾。
// 比如獲取下標為3到5的子數(shù)組
array.slice(3,5)

// Array<T>.splice(start: number, deleteCount?: number | undefined): T[] (+1 overload)
// 從數(shù)組中刪除元素，如果需要，在原來的位置插入新元素，并返回被刪除的元素。
// param start數(shù)組中從零開始移除元素的位置。
// @param deleteCount要刪除的元素數(shù)量。
// @返回一個包含被刪除元素的數(shù)組。
array.splice(0,1)

// Array<T>.sort(compareFn?: ((a: T, b: T) => number) | undefined): T[]
// 對數(shù)組進行排序。
// 這個方法改變數(shù)組并返回對相同數(shù)組的引用。
// @param compareFn函數(shù)用于確定元素的順序。它有望回歸
// 如果第一個參數(shù)小于第二個參數(shù)，則為負值，如果它們相等則為零，并且為正數(shù)
// 否則為*值。如果省略，則元素按升序、ASCII字符順序排序。
array.sort((a,b) => a.length - b.length)

// Array<T>.indexOf(searchElement: T, fromIndex?: number | undefined): number
// 返回數(shù)組中值第一次出現(xiàn)的索引，如果不存在則返回-1
// @param searchElement要在數(shù)組中找到的值。
// @param fromIndex數(shù)組的索引，從這里開始搜索。如果省略fromIndex，則從索引0開始搜索。
array.indexOf('1')

// Array<T>.lastIndexOf(searchElement: T, fromIndex?: number | undefined): number
// 返回指定值在數(shù)組中最后出現(xiàn)的索引，如果不存在則返回-1。
// @param searchElement要在數(shù)組中找到的值。
// @param fromIndex開始向后搜索的數(shù)組索引。如果省略fromIndex，則從數(shù)組中的最后一個索引開始搜索。
array.lastIndexOf('1', 2)

// every(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean;
// 判斷一個數(shù)組的所有成員是否滿足指定的測試。
// @param predicate一個最多接受三個參數(shù)的函數(shù)。每個方法調用
// 對數(shù)組中的每個元素執(zhí)行謂詞函數(shù)，直到謂詞返回一個值
// 可強制為布爾值false，或直到數(shù)組結束。
// @param thisArg在謂詞函數(shù)中this關鍵字可以引用的對象。
// 如果省略thisArg，則使用undefined作為this值。
array.every((value,index,array) => value.length > 1)

// Array<T>.some(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean
// 確定指定的回調函數(shù)是否對數(shù)組中的任何元素返回true。
// @param predicate一個最多接受三個參數(shù)的函數(shù)。一些方法調用
// 對數(shù)組中的每個元素執(zhí)行謂詞函數(shù)，直到謂詞返回一個值
// 可強制轉換為布爾值true，或直到數(shù)組結束。
// @param thisArg在謂詞函數(shù)中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[];
// 對數(shù)組的每個元素調用一個定義好的回調函數(shù)，并返回一個包含結果的數(shù)組。
// @param callbackfn一個最多接受三個參數(shù)的函數(shù)。map方法對數(shù)組中的每個元素調用一次callbackfn函數(shù)。
// 在callbackfn函數(shù)中this關鍵字可以引用的對象。如果省略thisArg，則使用undefined作為this值。
array.map((e) => e.toLowerCase())

// filter(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): T[];
// 返回滿足回調函數(shù)中指定條件的數(shù)組元素。
// @param predicate一個最多接受三個參數(shù)的函數(shù)。過濾器方法對數(shù)組中的每個元素調用謂詞函數(shù)一次。
// @param thisArg在謂詞函數(shù)中this關鍵字可以引用的對象。如果省略thisArg，則使用undefined作為this值。
array.filter((e,index,arr) => e.length == 1)

// reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T
// 為數(shù)組中的所有元素調用指定的回調函數(shù)?；卣{函數(shù)的返回值是累積的結果，并在下次調用回調函數(shù)時作為參數(shù)提供。
// @param callbackfn一個最多接受四個參數(shù)的函數(shù)。reduce方法對數(shù)組中的每個元素調用一次callbackfn函數(shù)。
// @param initialValue如果指定了initialValue，將作為初始值開始累積。對callbackfn函數(shù)的第一次調用將該值作為參數(shù)而不是數(shù)組值提供。
array.reduce((previousValue,currentValue,currentIndex,array) => previousValue + currentValue)

// find(predicate: (value: T, index: number, obj: T[]) => unknown, thisArg?: any): T | undefined;
// 返回數(shù)組中predicate為true且未定義的第一個元素的值
// @param predicate find按升序對數(shù)組的每個元素調用一次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 ’索引的數(shù)組元素更改為靜態(tài)‘ value ’，并返回修改后的數(shù)組
// @param value用來填充數(shù)組section的值
// @param開始索引開始填充數(shù)組。如果start為負，則將其視為
// length+start，其中l(wèi)ength是數(shù)組的長度。
// @param結束索引停止填充數(shù)組在。如果end為負，則將其視為長度+結束。
array.fill('1', 0, 10)

// entries(): IterableIterator<[number, T]>;
// 返回數(shù)組中每個元素下標、值
array.entries()

// 返回每一個數(shù)組的下標
array.keys()

// 返回數(shù)組中值的可迭代對象
array.values()

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

// Array<string>.forEach(callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any): void
// 使用 forEach 循環(huán)遍歷數(shù)組
array.forEach((value,index,array) => console.log(value))

// 使用 for循環(huán)遍歷數(shù)組
for (let i = 0; i < array.length; i++) {
    console.log(array[i]);
}

// 使用 for...of循環(huán)遍歷數(shù)組：
for (let fruit of array) {
    console.log(fruit);
}

數(shù)組的高階函數(shù)

// Array.flat (this: T[], depth?: 1 | undefined): T[]
// 是一個用于將嵌套的數(shù)組 “拉平”（展平）為一維數(shù)組的方法。
// array：是要進行展平操作的數(shù)組。
// depth（可選）：指定要遞歸展平的層數(shù)，默認值為 1。如果設置為 Infinity，則會將數(shù)組完全展平，不管嵌套有多深。
const flatArray = [1, 2, [3, 4]]
const result1 = flatArray.flat()
console.log(result1.toString()) // 1,2,3,4

// 方法對數(shù)組中的每個元素執(zhí)行一個提供的函數(shù)（映射函數(shù)），然后將結果數(shù)組展平成一個新的數(shù)組。
// 它首先對原數(shù)組的每個元素調用映射函數(shù)，得到一個新的數(shù)組，然后將這些新數(shù)組中的所有元素合并成一個單一的數(shù)組，
// 從而實現(xiàn)了映射和展平的操作
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 數(shù)組，然后將這些數(shù)組展平成一個大的數(shù)組
//總的來說，flatMap 提供了一種方便的方式來對數(shù)組進行映射操作并同時展平結果，使得處理多維數(shù)組或具有嵌套結構的數(shù)組時更加簡潔和高效。