数组的定义

数据分两种：

1. 基本数据(字符串 数字 布尔…) 操作的是值
2. 引用数据类型(对象、数组、Map、Set…)操作的是内存中的内容

数组是用来存储数据用的，和对象类似，创建的时候都会开辟内存空间

第一种：字面量定义

const arr = [1,2,3,4,5]

第二种：构造函数

const arr = new Array()

let arr = Array(10)//创建长度为十的数组

如果数组中数据类型比较多的情况下，可以使用 type 进行定义多数据类型

type tArr = number | string | boolean | iObj | number[] | (()=>void)

值传递与引用传递

1. 值传递

当传递基本数据类型（如number、string、boolean、undefined、null）时，采用的是值传递方式。

• 原理：传递的是变量的副本，函数内部对参数的修改不会影响外部原始变量。
• 示例：

function modifyValue(num: number): void {
  num = 100;
  console.log("函数内：" + num); // 输出 100
}

let a = 10;
modifyValue(a);
console.log("函数外：" + a); // 输出 10（未被修改）

2. 引用传递

当传递对象类型（如object、array、class实例等）时，采用的是引用传递方式。

• 原理：传递的是变量的引用地址（而非数据本身），函数内部对对象属性的修改会影响外部原始对象。
• 示例：

function modifyObject(obj: { name: string }): void {
  obj.name = "李四"; // 修改对象属性
  console.log("函数内：" + obj.name); // 输出 李四
}

let person = { name: "张三" };
modifyObject(person);
console.log("函数外：" + person.name); // 输出 李四（被修改）

关键区别总结

传递方式	适用类型	本质	函数内修改是否影响外部
值传递	基本数据类型	传递值的副本	不影响
引用传递	对象类型（包括数组、类实例等）	传递引用地址的副本	影响（修改属性时）

索引和长度

数组索引值是从 0 开始，索引值是用来取数组中对应位置的内容用的
eg:num:number[]=[1,2,3,5,12]，1的索引值为0，2的索引值为1，3的索引值为2，依次类推
直接使用索引即可对数组中的元素进行增删改查

console.log("",num[3]) //输出5
num[2] = 4
console.log("",num[2]) // 输出4

数组的长度，长度主要是用来做遍历用的，开发中可能会跟分页有关联
获取数组长度的方法:length，返回值为数组的长度(等于数组中元素的个数，等于数组中最后一个元素的索引值+1)

可以通过给length赋值来改变数组长度，设置数组长度的时候
1. 如果设置原来的长度相等，数组不会发生变化
2. 设置为原来的长度-1时，会删除数组的最后一个
3. 设置的值大于原来的长度时会在后面补 null
4. 如果数组中有1，2，3。在索引为 4 的位置添加一个 5 最终结果： [1,2,3,null,5]

数组遍历

let arr:number[] = [1,2,3,4,5]

for(let i = 0; i < arr.length; i++){
console.log('qqqqqq' + arr[i])
}

for(let t of arr ){  //将数组中的元素依次赋值给t
console.log('',t)
}

数组排序

选择排序算法

let numarr = [1,2,4,2,4,5,7,3,2,6]
for( let i = 0 ; i<numarr.length ; i++ ){  //循环遍历数组
   for( let j = i+1 ; j<numarr.length ; j++ ){  //下标为i的元素与后面的元素比较
        if(numarr[j]<numarr[i]){  //如果i后面的元素比i小，则与i交换位置
             let temp  = numarr[i]
             numarr[i] = numarr[j]
             numarr[j] = temp
          }
     }//每次从待排序区间中找到最小（或最大）的元素，将其与区间的第一个元素交换位置，然后缩小待排序区间（代码具体操作为i++），重复直至完成排序。
}
console.log('',numarr)
//时间复杂度为O(n^2)

冒泡排序算法

const numArr = [6,4,3,2,7,8,1,2,44,56,12,453,67]
// 通过循环的嵌套实现数据的排序
for (let i = 0; i < numArr.length - 1; i++) { 
for (let j = 0; j < numArr.length - 1 - i; j++) { 
if(numArr[j] > numArr[j + 1]){//每次比较相邻的两个元素，若顺序错误则交换它们。每轮遍历会将最大（或最小）的元素 “浮” 到数组末尾，如同气泡上升。
let res = numArr[j]
numArr[j] = numArr[j + 1]
numArr[j + 1] = res
}
}
}
//时间复杂度最好为O(n)，最坏为O(n^2)，平均为O(n^2)

数组常用方法

改变原数组的方法

1. pop()——最后位置删除一个数据
   • let arr:number[] = [1,2,3]
// 返回值：返回值是被删除的数据本身
let res = arr.pop()
console.log('',arr)//1,2
console.log('',res) // 3
2. push()——最后一个位置添加一个数据
   • let arr:number[] = [1,2,3]
// 语法： 数组名.push(要加的数据)
// 注意：要添加数据的类型要和数组的要求一致
// 返回值，返回值是数组的长度
let res = arr.push(666)
console.log('',arr)// 1,2,3,666
console.log('',res) // 4
3. shift()——最前面删除一个数据
   • let arr:number[] = [1,2,3]
// 返回值：返回值是被删除的数据本身
let res = arr.shift()
console.log('',arr) // 2,3
console.log('',res) //1
4. unshift()——最前面添加内容
   • let arr:number[] = [1,2,3]
// 语法：数组名称.unshift(添加的数据)
// 返回值，返回值是数组的长度
let res = arr.unshift(0)
console.log('',arr) // 0,1,2,3
console.log('',res) // 4
5. reverse——内容顺序反转一下
   • let arr:number[] = [1,2,3]
// 返回值：反转后的新数组，注意原数组会被修改
const res:number[] = arr.reverse()
console.log('',arr) // 3,2,1
console.log('',res) // 3,2,1
6. sort——数组排序，默认是升序
   • 不指定比较函数（默认排序）
     如果不提供 compareFunction，sort() 会将元素转换为字符串，然后按照 Unicode 码点顺序排序。
     示例：
     const arr = [10, 2, 5, 1, 9]; arr.sort(); console.log(arr); // 输出：[1, 10, 2, 5, 9]（按字符串排序）
     
     注意：默认排序可能不符合数字的大小排序预期（如上面的 10 排在 2 前面），因此数字排序通常需要指定比较函数。
   • 指定比较函数（自定义排序）
     比较函数接收两个参数 a 和 b（表示数组中相邻的两个元素），并返回一个数字，用于决定排序顺序：
     若返回 正数：b 排在 a 前面（a 比 b 大）。
     若返回 负数：a 排在 b 前面（a 比 b 小）。
     若返回 0：a 和 b 位置不变（相等）。
   • 常见排序场景
     （1）数字升序排序
     const numbers = [10, 2, 5, 1, 9];
// 升序：a - b
numbers.sort((a, b) => a - b);
console.log(numbers); // 输出：[1, 2, 5, 9, 10]
     
     （2）数字降序排序
     const numbers = [10, 2, 5, 1, 9];
// 降序：b - a
numbers.sort((a, b) => b - a);
console.log(numbers);
// 输出：[10, 9, 5, 2, 1]
     
     （3）对象数组排序
     根据对象的某个属性排序（如按年龄、价格等）：
     interface Person { name: string; age: number; }
const people: Person[] = [ { name: "张三", age: 25 }, { name: "李四", age: 18 }, { name: "王五", age: 30 } ];
// 按年龄升序
people.sort((a, b) => a.age - b.age);
console.log(people);
// 输出：[{name: "李四", age: 18}, {name: "张三", age: 25}, {name: "王五", age: 30}]
     
     （4）字符串按长度排序
     const words = ["apple", "banana", "cherry", "date"];
// 按字符串长度升序
words.sort((a, b) => a.length - b.length);
console.log(words);
// 输出：["date", "apple", "banana", "cherry"]
7. splice——删除指定内容
   • let arr:number[] = [2,1,3]
// 语法： 数组名.splice(开始的索引值, 删除的数量)
// 返回值是被删除之后的数组
arr.splice(2,1)
console.log('',arr) //2,1
// 如果只传第一个参数，那么会从当前位置开始直接删除后面的所有内容arr.splice(1)
console.log('',arr) //2

不改变原数组方法

1. concat()——数组合并
   • let arr:number[] = [2,1,3]
// 不会影响原来的数组
// 返回值： 拼接之后的新数组
let res = arr.concat([4,5,6]) //[2,1,3,4,5,6]

// ... 叫做展开运算符，可以将数组中的内容全部拿出来
let res:number[] = [...arr,...[4,5,6]] // [2,1,3,4,5,6]
2. join——数组内容拼接成字符串
   • // 作用：使用符号将数组中的内容拼接在一起，如果不设置默认为不添加
// 返回值：是拼接之后的字符串
const list:string[] = ['我','爱','杭','州','西','湖']
const res:string = list.join('|') //以|分隔，可以使用其他字符串 '我|爱|杭|州|西|湖'
3.  slice——数组截取指定位置的内容
   • // arr.slice(开始位置,结束位置(不包含))
// 返回值：截取的内容，会是一个数组
// 第一个参数要小于第二个参数
const arr = [1,2,3,4,5,6,7,8,9,0]
// const res:number[] = arr.slice(0,2) // 1,2
// const res:number[] = arr.slice() // 拿全部
// const res:number[] = arr.slice(1) // 从开始到结束
// const res:number[] = arr.slice(-2) // 从后往前拿 2 个
const res:number[] = arr.slice(-3,-2) // 当参数是负数的时候从后往前截取 [9,0]
4. indexOf——查找索引
   • let arr:number[] = [22,11,33,55,33,66,44]
// arr.indexOf(要找的内容)
// 通过数组查询到当前数据第一次出现的索引位置
// *** 找到了就会返回当前的索引值，找不到返回 -1
const res:number = arr.indexOf(33) //2
5. lastIndexOf——从后往前找索引
   • let arr:number[] = [22,11,33,55,33,66,44]
// 找到最后一次出现的索引值
// *** 找到了就会返回当前的索引值，找不到返回 -1
const res:number = arr.lastIndexOf(33) //4
6. includes——数组中是否包含
   • let arr:number[] = [22,11,33,55,33,66,44]
返回值为布尔类型
const res:boolean = arr.includes(222) //false

数组高阶方法

1. forEach——对每一项数据操作
   • let arr:number[] = [22,11,33,55,33,66,44]
// for (let i = 0; i < arr.length; i++) {
// console.log(arr[i] + '')
// }
// forEach 对每一项数据进行操作
// 语法 arr.forEach((遍历出的内容, 索引值, 数组本身)=>{})
// 没有返回值
arr.forEach((val:number,index:number,list:number[])=>{
// val 第一个参数：数组中每次遍历出的内容
// index 遍历的索引值
// list 数组本身
console.log('',val,index,list)
})
2. map——映射函数
   • // arr.map((遍历出的内容，索引值，数组本身)=>{})
// 作用： 映射数组，对数组中的每一项做操作
// 返回值： 是映射处理后的新数组
// 注意事项： 映射的操作结果要通过 return 返回
let arr:number[] = [1,2,3,4,5]
const res:number[] = arr.map((item:number, index:number)=>{
// // console.log(item.toString())
return item * 2
})
console.log(JSON.stringify(res)) //[2,4,6,8,10] JSON.stringify()是将引用数据类型转为字符串
3. filter——过滤器
   • // 作用： 对数组中每一项进行条件过滤，将符合条件的内容返回出来
// 会生成一个新的数组
// 返回值：过滤结果的数组
let arr:number[] = [1,2,3,4,5]
const res:number[] = arr.filter((item: number,index: number)=>{
return item > 3
})
console.log(JSON.stringify(res)) //[4,5]
4. find——查找
   • interface iUser {
name: string
score: number
}

let students: iUser[] = [
{name: '张三', score: 10},
{name: '李四', score: 63},
{name: '王五', score: 45},
{name: '赵六', score: 20},
{name: '田七', score: 87},
{name: '老八', score: 90},
{name: '喝九', score: 59}
]

// 作用： 查找到数组中满足条件的第一个内容，可以查找引用数据类型的内容，indexof只能查找基本数据类型的内容
// 返回值： 找到的结果，没有找到就是 undefined
const res: iUser | undefined = students.find((item:iUser)=>{
return item.score > 80
})
//
// console.log(JSON.stringify(res))
5. findIndex——查找索引
   • interface iUser {
name: string
score: number
}
let students: iUser[] = [
{name: '张三', score: 10},
{name: '李四', score: 63},
{name: '王五', score: 45},
{name: '赵六', score: 20},
{name: '田七', score: 87},
{name: '老八', score: 90},
{name: '喝九', score: 59}
]
// 作用： 查找数组中满足条件的第一个元素的索引值
// 返回值： 找到元素的索引值
const res = students.findIndex((item: iUser)=>{
return item.score > 80
})
console.log(res.toString())
6. every——判断数组中是否每一个元素都满足条件
   • interface iUser {
name: string
score: number
}
let students: iUser[] = [
{name: '张三', score: 10},
{name: '李四', score: 63},
{name: '王五', score: 45},
{name: '赵六', score: 20},
{name: '田七', score: 87},
{name: '老八', score: 90},
{name: '喝九', score: 59}
]
// 作用：判断数组中的每一项是否都符合条件，只要有一个不符合最终结果就是 false
// 返回值：返回布尔类型的结果，必须全部都满足才会是 true
const res: boolean = students.every((item: iUser)=>{
return item.score > 6
})
console.log(String(res)) //true
7. some——判断数组中是否存在满足条件的元素
   • interface iUser {
name: string
score: number
}
let students: iUser[] = [
{name: '张三', score: 10},
{name: '李四', score: 63},
{name: '王五', score: 45},
{name: '赵六', score: 20},
{name: '田七', score: 87},
{name: '老八', score: 90},
{name: '喝九', score: 59}
]
// 作用：判断数组中是否有满足条件的内容，只要有一个就会返回 true
// 返回值：查询结果，全部都不满足的时候才会是 falseß
const res:boolean = students.some((item: iUser)=>{
return item.score > 89
})
console.log(String(res)) //true
8. reduce——对数组中的所有元素进行累积计算，最终将数组 “缩减” 为一个单一的值
   • array.reduce( callback: (accumulator: T, currentValue: U, currentIndex?: number, array?: U[]) => T, initialValue?: T ): T
     
     参数说明：
     1.** callback（回调函数）**：每次遍历数组时执行的函数，负责定义累积逻辑，接收 4 个参数：
     accumulator：累积器，存储上一次回调的返回值（或初始值）；
     currentValue：当前正在处理的数组元素；
     currentIndex（可选）：当前元素的索引；
     array（可选）：原数组本身。
     2.** initialValue（初始值）**（可选）：
     若提供，accumulator 的初始值为 initialValue，遍历从数组第一个元素开始；
     若不提供，accumulator 的初始值为数组第一个元素，遍历从第二个元素开始。
   • //计算数组元素的总和
// 定义一个数字数组
const numbers: number[] = [1, 2, 3, 4, 5];
// 使用reduce计算总和
const sum: number = numbers.reduce((acc, current) => {
return acc + current; // 累加当前元素到累积器
}, 0); // 初始值为0
console.log(sum); // 输出：15（1+2+3+4+5）

多维数组

多维数组是指 “数组的数组”，即数组的元素本身也是一个数组的元素。它通过嵌套结构实现 “多维度” 的数据存储，最常见的是二维数组（数组元素为一维数组），更高维度（如三维、四维）的数组则是在二维数组基础上进一步嵌套。

/*
     * 多维数组：在数组中嵌套数组
     * [
     *    {
     *       title: '浙江',
     *       son: [
     *          {title: '杭州', son: [{}]},
     *          {},
     *          {}
     *        ]
     *    }
     * ]
     * */

多维数组扁平化

多维数组扁平是指将多维数组转换为一维数组的过程，即去掉所有嵌套结构，让所有元素都处于同一层级。例如，将 [1, [2, [3, 4]], 5] （三维数组）扁平化为 [1, 2, 3, 4, 5]。

方法：flat() 如上面的三维数组可直接使用flat(3)扁平化，不破坏原数组

let testnum = [[1],2,[3,4,[5]]]
console.log(JSON.stringify(testnum)) // [[1],2,[3,4,[5]]]
let res = testnum.flat(3)
console.log(JSON.stringify(res)) //[1,2,3,4,5]