1.数组

1.1 数组是什么

概念： 数组（Array）是一种将一组相关数据存储在单个变量名下的优雅方式。它是一组有序数据的集合，每个数据都有一个对应的编号（索引/下标）。

为什么需要数组： 假设我们需要存储5个学生的名字，如果不用数组：

let name1 = '小明'
let name2 = '小刚'
let name3 = '小红'
let name4 = '小丽'
let name5 = '小木'

这样的做法存在明显问题：

• 需要声明多个变量，代码冗长
• 变量之间没有关联，难以管理
• 难以进行批量操作

使用数组的优势：

let names = ['小明', '小刚', '小红', '小丽', '小木']

• 用一个变量存储多个数据
• 数据有顺序，方便管理
• 可以通过下标快速访问和操作

数组的特点：

• 数组中的元素可以是任意类型的数据（数字、字符串、布尔值、对象等）
• 数组中的元素按顺序存储，从索引0开始
• 数组可以存储不同类型的数据（虽然不推荐）
• 数组是引用类型数据

1.2 数组的基本使用

1. 声明数组

基本语法：

let 数组名 = [数据1, 数据2, 数据3, ...]

示例：

// 声明一个包含数字的数组
let scores = [98, 85, 92, 78, 88]

// 声明一个包含字符串的数组
let names = ['小明', '小刚', '小红']

// 声明一个空数组
let arr = []

// 声明包含不同类型数据的数组（不推荐）
let mix = ['张三', 18, true, null]

注意事项：

• 数组使用方括号 [] 包裹
• 元素之间用逗号 , 分隔
• 声明时可以不赋值，此时是空数组

2. 数组术语

术语	说明	示例
元素	数组中保存的每个数据	'小明', '小刚', '小红'
下标（索引）	数组中数据的编号	0, 1, 2
长度	数组中数据的个数	3

示例说明：

let names = ['小明', '小刚', '小红']
// '小明' 是索引 0 对应的元素
// '小刚' 是索引 1 对应的元素
// '小红' 是索引 2 对应的元素
// 数组长度为 3

3. 获取数组元素

语法：

数组名[下标]

示例：

let names = ['小明', '小刚', '小红', '小丽']

console.log(names[0]) // 输出：'小明'
console.log(names[1]) // 输出：'小刚'
console.log(names[2]) // 输出：'小红'
console.log(names[3]) // 输出：'小丽'

注意事项：

• 索引从 0 开始
• 访问不存在的索引时，返回 undefined

let names = ['小明', '小刚']
console.log(names[5]) // 输出：undefined（因为索引5不存在）

4. 获取数组长度

语法：

数组名.length

示例：

let names = ['小明', '小刚', '小红', '小丽']
console.log(names.length) // 输出：4

获取最后一个元素：

let names = ['小明', '小刚', '小红']
let lastIndex = names.length - 1
console.log(names[lastIndex]) // 输出：'小红'

1.3 操作数组

1. 修改数组元素

语法：

数组名[下标] = 新值

示例：

let names = ['小明', '小刚', '小红']
names[1] = '大刚' // 修改索引1的元素
console.log(names) // 输出：['小明', '大刚', '小红']

注意事项：

• 可以通过下标修改已存在的元素
• 如果直接给不存在的下标赋值，会扩充数组长度

let arr = [1, 2, 3]
arr[5] = 6
console.log(arr) // 输出：[1, 2, 3, empty × 2, 6]
console.log(arr.length) // 输出：6

2. 新增数组元素

方式一：通过下标直接新增

let arr = ['red', 'green']
arr[2] = 'blue' // 在索引2位置新增元素
console.log(arr) // 输出：['red', 'green', 'blue']

方式二：使用 push() 方法 - 在末尾添加

let arr = ['red', 'green']
arr.push('blue') // 在数组末尾添加元素
console.log(arr) // 输出：['red', 'green', 'blue']

方式三：使用 unshift() 方法 - 在开头添加

let arr = ['red', 'green']
arr.unshift('blue') // 在数组开头添加元素
console.log(arr) // 输出：['blue', 'red', 'green']

3. 删除数组元素

方式一：使用 pop() 方法 - 删除末尾元素

let arr = ['red', 'green', 'blue']
let deleted = arr.pop() // 删除并返回最后一个元素
console.log(arr) // 输出：['red', 'green']
console.log(deleted) // 输出：'blue'

方式二：使用 shift() 方法 - 删除开头元素

let arr = ['red', 'green', 'blue']
let deleted = arr.shift() // 删除并返回第一个元素
console.log(arr) // 输出：['green', 'blue']
console.log(deleted) // 输出：'red'

方式三：使用 splice() 方法 - 删除指定位置的元素

let arr = ['red', 'green', 'blue', 'yellow']
arr.splice(1, 2) // 从索引1开始，删除2个元素
console.log(arr) // 输出：['red', 'yellow']

4. 数组遍历

什么是数组遍历： 就是把数组中的每个元素从头到尾都访问一次。

方式一：使用 for 循环

let names = ['小明', '小刚', '小红', '小丽']
for (let i = 0; i < names.length; i++) {
    console.log(names[i])
}
// 输出：
// 小明
// 小刚
// 小红
// 小丽

方式二：使用 forEach() 方法

let names = ['小明', '小刚', '小红']
names.forEach(function(name) {
    console.log(name)
})

方式三：使用 for...of 循环（ES6）

let names = ['小明', '小刚', '小红']
for (let name of names) {
    console.log(name)
}

5. 常用数组方法总结

方法名	说明	示例
push(元素)	在末尾添加一个或多个元素，返回新长度	arr.push(4)
pop()	删除并返回最后一个元素	arr.pop()
unshift(元素)	在开头添加一个或多个元素，返回新长度	arr.unshift(1)
shift()	删除并返回第一个元素	arr.shift()
splice(start, count)	从指定位置删除/添加元素	arr.splice(1, 2)
reverse()	反转数组	arr.reverse()
sort()	对数组进行排序	arr.sort()

1.4 数组案例

案例1：求数组中所有元素的和

需求： 定义一个数组 scores = [98, 85, 92, 78, 88]，求所有学生的总分和平均分。

分析：

1. 声明一个数组存储成绩
2. 声明一个变量 sum 存储总分，初始值为 0
3. 遍历数组，累加每个元素到 sum
4. 计算平均分 = 总分 / 数组长度
5. 输出结果

代码实现：

let scores = [98, 85, 92, 78, 88]
let sum = 0

// 计算总分
for (let i = 0; i < scores.length; i++) {
    sum += scores[i]
}

// 计算平均分
let avg = sum / scores.length

console.log('总分为：' + sum)      // 输出：总分为：441
console.log('平均分为：' + avg)    // 输出：平均分为：88.2

案例2：找出数组中的最大值

需求： 定义一个数组 nums = [23, 45, 12, 67, 34, 89, 56]，找出其中的最大值。

分析：

1. 声明一个数组
2. 假设第一个元素就是最大值 max = arr[0]
3. 从第二个元素开始遍历，依次与 max 比较
4. 如果当前元素比 max 大，就更新 max
5. 遍历结束，max 就是最大值

代码实现：

let nums = [23, 45, 12, 67, 34, 89, 56]
let max = nums[0]  // 假设第一个元素是最大值

for (let i = 1; i < nums.length; i++) {
    if (nums[i] > max) {
        max = nums[i]  // 更新最大值
    }
}

console.log('数组中的最大值是：' + max)  // 输出：数组中的最大值是：89

案例3：筛选数组中的偶数

需求： 定义一个数组 nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]，筛选出所有的偶数。

分析：

1. 声明一个新数组存储偶数
2. 遍历原数组
3. 判断每个元素是否能被 2 整除
4. 如果是偶数，添加到新数组中

代码实现：

let nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
let evenNums = []  // 存储偶数的新数组

for (let i = 0; i < nums.length; i++) {
    if (nums[i] % 2 === 0) {
        evenNums.push(nums[i])  // 添加偶数到新数组
    }
}

console.log('原数组：' + nums)      // 输出：原数组：1,2,3,4,5,6,7,8,9,10
console.log('偶数数组：' + evenNums)  // 输出：偶数数组：2,4,6,8,10

案例4：数组反转

需求： 将数组 ['red', 'green', 'blue', 'yellow'] 反转为 ['yellow', 'blue', 'green', 'red']

方式一：使用内置方法

let colors = ['red', 'green', 'blue', 'yellow']
colors.reverse()
console.log(colors)  // 输出：['yellow', 'blue', 'green', 'red']

方式二：手动实现

let colors = ['red', 'green', 'blue', 'yellow']
let newColors = []

// 从后往前遍历，添加到新数组
for (let i = colors.length - 1; i >= 0; i--) {
    newColors.push(colors[i])
}

console.log(newColors)  // 输出：['yellow', 'blue', 'green', 'red']

案例5：冒泡排序

需求： 将数组 [5, 4, 3, 2, 1] 按从小到大排序

分析： 冒泡排序的基本思想：

1. 比较相邻的两个元素，如果前一个比后一个大，就交换它们
2. 每一轮遍历后，最大的元素会"冒泡"到最后
3. 重复这个过程，直到数组有序

代码实现：

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

// 外层循环控制排序轮数
for (let i = 0; i < arr.length - 1; i++) {
    // 内层循环进行相邻元素比较和交换
    for (let j = 0; j < arr.length - 1 - i; j++) {
        if (arr[j] > arr[j + 1]) {
            // 交换两个元素
            let temp = arr[j]
            arr[j] = arr[j + 1]
            arr[j + 1] = temp
        }
    }
}

console.log('排序后的数组：' + arr)  // 输出：排序后的数组：1,2,3,4,5

案例6：删除数组中的指定元素

需求： 从数组 [1, 2, 3, 4, 2, 5, 2] 中删除所有的 2

代码实现：

let arr = [1, 2, 3, 4, 2, 5, 2]
let newArr = []

for (let i = 0; i < arr.length; i++) {
    if (arr[i] !== 2) {
        newArr.push(arr[i])
    }
}

console.log('删除后的数组：' + newArr)  // 输出：删除后的数组：1,3,4,5

总结

数组核心要点

1. 数组是什么：一种有序存储多个数据的集合
2. 声明方式：使用方括号 []，元素用逗号分隔
3. 访问方式：通过索引 arr[下标]，索引从 0 开始
4. 常用操作：
   • 获取长度：arr.length
   • 新增元素：push()、unshift()
   • 删除元素：pop()、shift()
   • 遍历数组：for 循环、forEach()

学习建议

• 多练习数组遍历，理解索引的概念
• 掌握常用数组方法的使用场景
• 能够根据需求选择合适的方法操作数组
• 多做案例练习，如求和、找极值、筛选、排序等