主题
1-10数组和数组操作（二）
本页对应 第一章JavaScript基础，共 5 段视频，约 35 分钟。
学习目标
- 能准确使用
push、unshift向数组末尾或开头新增一个或多个元素，并说明二者会修改原数组且返回新数组长度。 - 能准确使用
pop、shift删除数组末尾或开头的一个元素，并说明二者会修改原数组且返回被删除的元素。 - 能独立编写数组筛选代码：遍历旧数组，按“大于等于 10”或“不等于 0”的条件筛选，并通过
push追加到新数组，得到正确结果。 - 能解释并运用
splice删除任意位置元素：正确设置起始索引和删除个数，并说明省略删除个数时默认删除到数组末尾。 - 能解释并运用
splice在任意位置新增元素：起始索引写目标位置索引，删除个数不省略且不删除时写0，后续参数为新增元素，可新增多个。 - 能根据“操作数组开头、末尾或中间”的场景选择合适方法，并区分
splice与push、pop、unshift、shift的适用场景。
知识点
为什么需要循环嵌套：从自转公转到“重复中的重复”
地球一边自转，一边绕太阳公转。把自转看成一个循环，把公转看成另一个循环，就得到“循环里还有循环”的直观模型。
为什么需要：有些任务不是单纯重复一次，而是“外层每做一件事，内层都要把一组小事完整做一遍”。例如第1天记5个单词，第2天再记5个单词。
怎么想：先确定外层循环负责什么，再确定内层循环负责什么。外层控制“第几天/第几行”，内层控制“这一天记几个/这一行打几个”。
怎么做：JavaScript 中任意循环语句都支持嵌套。笔记给出的基本语法示意如下：
javascript
for（初始化; 循环条件;变量计数） {
for（初始化; 循环条件；变量计数）{
// 要重复执行的代码
}
}注意实际写代码时括号、分号要用英文半角。
易错点：内外层循环变量不要混用；内层循环必须写在外层循环体里面；不要误以为内层只执行一次——外层每走一次，内层都要完整走一轮。
外层走一次，内层走一轮：用“第几天记单词”验证执行顺序
笔记用“第n天记第j个单词”的例子说明执行顺序：
js
// 1. 外面的循环 记录第n天
for (let i = 1; i < 4; i++) {
document.write(`第${i}天 <br>`)
// 2. 里层的循环记录 几个单词
for (let j = 1; j < 6; j++) {
document.write(`记住第${j}个单词<br>`)
}
}为什么需要：只看语法容易糊涂，必须通过输出验证“谁先谁后”。
怎么想：当 i = 1 时，先输出“第1天”，然后内层 j 从1到5，连续输出5个单词；内层结束后，外层才进入 i = 2。
怎么做：运行后观察输出顺序，确认“外层循环一次，里层循环循环全部”。
易错点：<br> 的换行位置要放在合适位置；内层变量 j 每轮外层开始时都会重新初始化；如果内外层变量写成同一个名字，条件会互相干扰。
打印直角三角形：让内层次数跟着外层变化
笔记中的三角形代码：
javascript
// 外层打印几行
for (let i = 1; i <= 5; i++) {
// 里层打印几个星星
for (let j = 1; j <= i; j++) {
document.write('★')
}
document.write('<br>')
}
为什么需要：固定次数的内层循环只能打印矩形；三角形要求“第1行1个、第2行2个……”，内层次数要随外层变化。
怎么想：外层 i 表示行号，内层 j 表示这一行第几个星。第 i 行打印 i 个星，所以条件是 j <= i。
怎么做：内层只负责连续输出 ★，内层结束后再输出 <br> 换行。
易错点：写成 j <= 5 会变成每行5个星；把 <br> 写进内层会导致每打一个星就换行；忘记外层循环只控制行数。
九九乘法表：把“星星”替换成算式
样式部分保留笔记 CSS：
css
span {
display: inline-block;
width: 100px;
padding: 5px 10px;
border: 1px solid pink;
margin: 2px;
border-radius: 5px;
box-shadow: 2px 2px 2px rgba(255, 192, 203, .4);
background-color: rgba(255, 192, 203, .1);
text-align: center;
color: hotpink;
}JavaScript 部分：
javascript
// 外层打印几行
for (let i = 1; i <= 9; i++) {
// 里层打印几个星星
for (let j = 1; j <= i; j++) {
// 只需要把 ★ 换成 1 x 2 = 2
document.write(`
<div> \${j} x \${i} = \${j * i} </div>
`)
}
document.write('<br>')
}
为什么需要：乘法表本质上是“9行，每行个数递增”的二维重复，和三角形结构一致。
怎么想：先沿用三角形的行列关系：外层 i 控制行，内层 j 控制列，j <= i。然后把输出的 ★ 替换成 \${j} x \${i} = \${j * i}。
怎么做：调试时可以先打印星星，确认行列正确，再把星星替换成算式；这样能把“循环结构”和“内容格式”分开排查。
易错点：笔记 CSS 选择器写的是 span，而 JS 输出的是 <div>，直接套用样式时标签要统一；乘号左右顺序要清楚，通常写作“列 × 行”；换行 <br> 要放在内层循环结束之后，否则乘法表会被打散。
数组是什么：为什么需要 → 怎么想 → 怎么做 → 易错点
为什么需要：如果保存一个班同学姓名，用多个变量很麻烦；数组能在单个变量名下存储多个数据。
怎么想：数组是引用数据类型，用 [] 定义，元素之间用英文逗号分隔，元素可叫数组单元。
怎么做：
html
<script>
// 1. 语法，使用 [] 来定义一个空数组
// 定义一个空数组，然后赋值给变量 classes
// let classes = []
// 2. 定义非空数组
let classes = ['小明', '小刚', '小红', '小丽', '小米']
</script>易错点：元素之间必须是英文逗号；数组单元可以是任意数据类型，不只字符串。
访问数组和数组索引：为什么需要 → 怎么想 → 怎么做 → 易错点
为什么需要：存数据不是目的，关键要能取出某个数据。
怎么想：每个数组单元都有编号，叫索引或下标，从 0 开始。
怎么做：
html
<script>
// 数组： 可以单个变量下存储多个数据
// 1. 声明数组
let names = ['小明', '小刚', '小红', '小丽', '小米']
// let names = ['小明', '小刚', true, '小丽', 1]
console.log(names)
// 1.1 数组是按照顺序来存储的，每个数据都有自己的编号
// 1.2 编号是从0开始的， 0 1 2 3... 也称为 索引 或者 下标
// 1.3 数组里面可以存放任意的数据类型
// 2. 数组取值 数组名[下标]
console.log(names[0]) // '小明'
console.log(names[1]) // '小刚'
console.log(names[2]) // '小红'
console.log(names[3]) // '小丽'
console.log(names[4]) // '小米'
</script>数组单元值可以是任意类型：
html
<script>
// 6. 数组单值类型可以是任意数据类型
// a) 数组单元值的类型为字符类型
let list = ['HTML', 'CSS', 'JavaScript']
// b) 数组单元值的类型为数值类型
let scores = [78, 84, 70, 62, 75]
// c) 混合多种类型
let mixin = [true, 1, false, 'hello']
</script>易错点：索引从 0 开始，不是从 1 开始；取不到时返回 undefined。
遍历数组：为什么需要 → 怎么想 → 怎么做 → 易错点
为什么需要：要依次访问数组中每个元素。
怎么想：用 for 循环，让 i 从 0 到 arr.length - 1，通过 arr[i] 访问。
怎么做：
html
<script>
let arr = ['迪丽热巴', '古力娜扎', '佟丽丫丫', '玛尔扎哈', '哈尼克孜']
// console.log(arr[0])
// console.log(arr[1])
// console.log(arr[2])
// console.log(arr[3])
// 遍历数组： 把数组里面的数据每个都会访问到
// for (let i = 0; i < 4; i++) {
// // console.log(i) 数组名[索引号]
// console.log(arr[i])
// }
// 1. 数组的长度 数组.length
// console.log(arr.length) // 4
for (let i = 0; i < arr.length; i++) {
console.log(arr[i])
}
// 2. 数组里面的数据也称为 数组元素
</script>易错点：循环条件写 i < arr.length，不要写 <=；数组长度用 数组.length。
查询和修改数组：为什么需要 → 怎么想 → 怎么做 → 易错点
为什么需要：数组本质是数据集合，操作无非增、删、改、查。
怎么想：查询用 数组[索引]；修改用 数组[索引] = 新值。
怎么做：
html
<script>
// 1. 查询数组元素
let arr = ['迪丽热巴', '古丽扎娜']
console.log(arr[0]) // '迪丽热巴'
console.log(arr[1]) // '古丽扎娜'
console.log(arr[2]) // undefined
// 2. 修改数组元素 数组[索引] = 新值
arr[1] = '佟丽丫丫'
// console.log(arr)
arr[3] = '古丽扎娜' // 如果索引号不存在，则是增加数组元素 （不提倡）
console.log(arr)
console.log(arr.length) // 4 修改了数组长度
</script>易错点：查询不到返回 undefined；修改不存在的索引会新增元素并改变长度，尽量避免。
新增：push 与 unshift：为什么需要 → 怎么想 → 怎么做 → 易错点
为什么需要：班里来了新同学，要把名字加入数组。
怎么想：末尾新增用 push，开头新增用 unshift，都可一次加多个。
怎么做：
javascript
// 数组新增元素
// 1. 可以向数组的末尾新增1个或者多个数组元素 数组.push(元素1...元素n)
let arr = ['迪丽热巴']
// console.log(arr.push('佟丽丫丫')) // 返回的是新数组的长度 2
// arr.push('佟丽丫丫', '古丽扎娜')
// console.log(arr) // 修改原数组
// 2. 可以向数组的开头增加1个或者多个数组元素 数组.unshift(元素1,...元素n)
// console.log(arr.unshift('佟丽丫丫')) // 返回的是新数组的长度 2
arr.unshift('佟丽丫丫', '古丽扎娜')
console.log(arr) // 修改原数组调试过程：打印 arr.push('佟丽丫丫') 返回 2，说明返回值是新数组长度；原数组被修改。unshift 同样返回新长度，也修改原数组。
易错点：push/unshift 返回新长度，不是数组；会修改原数组。
删除：pop 与 shift：为什么需要 → 怎么想 → 怎么做 → 易错点
为什么需要：要删掉数组最后一个或第一个元素。
怎么想：pop() 删末尾，shift() 删开头；一次只能删一个，小括号为空。
怎么做：
javascript
<script>
// 删除元素
// 1. 删除数组中的最后一个元素 数组.pop() 修改原数组
let arr = ['red', 'green']
// arr.pop()
// console.log(arr.pop()) // 返回的是被删除的元素
// console.log(arr)
// 2. 删除数组中的第一个元素 数组.shift() 修改原数组的
arr.shift()
// console.log(arr.shift()) // 返回的是被删除的元素
console.log(arr)
</script>调试过程：console.log(arr.pop()) 返回被删除的 green；shift() 返回被删除的 red。
易错点：返回值是被删除元素，不是新数组；只能删一个，删多个要多次执行；会修改原数组。
数组 splice 方法：为什么需要 → 怎么想 → 怎么做 → 易错点
为什么需要：push/pop/unshift/shift 只能处理开头结尾，中间位置需要 splice。
怎么想：语法 splice(start, deleteCount, item1, item2...)；start 从 0 计数；deleteCount 省略则删到最后；新增时第二个参数不能省，写 0。
怎么做：
javascript
<script>
// splice 删除和增加数组元素
let arr = ['迪丽热巴', '古力娜扎', '佟丽丫丫', '玛尔扎哈']
// 1. splice 删除 数组.splice(起始位置, 删除几个)
// arr.splice(1, 1) // 记住起始位置是索引号，从0 开始数
// arr.splice(1) // 如果第二个参数（删除几个）省略了，则默认删除到最后
// console.log(arr)
// 2. splice 增加 数组.splice(起始位置, 删除几个, 新增元素1,...新增元素n)
arr.splice(1, 0, '刘德华', 'pink')
// 2.1 注意如果是新增，则起始位置是目标位置的索引号， 删除几个（第二个参数）不能省略我们写为 0， 后面写新增的元素
console.log(arr)
// 3. splice 不是替换pop shift unshift push. arr.splice(0, 1)
// 开头结尾找前面 pop shift unshift push
// splice管中间
</script>调试过程：arr.splice(1, 1) 会从索引 1 删除 1 个；arr.splice(1) 会从索引 1 删到最后；arr.splice(1, 0, '刘德华', 'pink') 表示在索引 1 前插入，不删除。
易错点：start 是索引不是“第几个”；新增时第二个参数写 0；splice 不替代开头结尾方法，开头结尾优先用 push/pop/unshift/shift，中间增删用 splice；它会修改原数组。
课件图示
代码示例
示例一：循环嵌套（天数/单词、直角三角形、九九乘法表）
js
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<title>循环嵌套</title>
<style>
body {
font-family: Consolas, 'Microsoft YaHei', sans-serif;
line-height: 1.8;
}
span {
display: inline-block;
width: 100px;
padding: 5px 10px;
border: 1px solid pink;
margin: 2px;
border-radius: 5px;
box-shadow: 2px 2px 2px rgba(255, 192, 203, .4);
background-color: rgba(255, 192, 203, .1);
text-align: center;
color: hotpink;
}
</style>
</head>
<body>
<script>
// 1. 外层循环记录第 n 天，里层循环记录第几个单词
for (let i = 1; i < 4; i++) {
document.write(`第${i}天 <br>`)
for (let j = 1; j < 6; j++) {
document.write(`记住第${j}个单词<br>`)
}
}
document.write('<hr>')
// 2. 直角三角形：外层管几行，里层管几个星星
for (let i = 1; i <= 5; i++) {
for (let j = 1; j <= i; j++) {
document.write('★')
}
document.write('<br>')
}
document.write('<hr>')
// 3. 九九乘法表：只需把 ★ 换成 1 x 2 = 2
for (let i = 1; i <= 9; i++) {
for (let j = 1; j <= i; j++) {
document.write(`<span>${j} x ${i} = ${j * i}</span>`)
}
document.write('<br>')
}
</script>
</body>
</html>要点解释：
- 外层循环执行一次，里层循环执行全部。所以打印顺序是「第1天 → 5个单词 → 第2天 → 5个单词…」，这是嵌套循环最核心的理解点。
- 内层循环条件
j <= i是三角形的关键：i每加 1，里层就多打印一个星星，形成递增效果。写成固定的j <= 5就变成矩形了。 - 换行
document.write('<br>')必须写在内层循环结束之后、外层循环之内，写进内层会变成竖排。 - 易错点：笔记里 CSS 选择器写的是
span，而 JS 里输出的是<div>，两者对不上样式就不生效。这里统一用<span>，标签与选择器必须一致。 - 易错点：乘法表输出的是
\${j} x \${i}，注意顺序是「列 × 行」，写成\${i} x \${j}表格就倒过来了。
示例二：数组的定义、访问、遍历与增删（push / unshift / pop / shift）
html
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<title>数组基本使用与增删</title>
</head>
<body>
<script>
// 1. 定义数组：[] 定义，元素之间用英文逗号分隔
let names = ['小明', '小刚', '小红', '小丽', '小米']
// 数组单元可以是任意数据类型
let mixin = [true, 1, false, 'hello']
// 2. 访问数组：数组名[索引]，索引从 0 开始
console.log(names[0]) // '小明'
console.log(names[2]) // '小红'
console.log(names[5]) // undefined（查询不到返回 undefined）
// 3. 遍历数组：用 length 控制循环，不要写死数字
let arr = ['迪丽热巴', '古力娜扎', '佟丽丫丫', '玛尔扎哈', '哈尼克孜']
for (let i = 0; i < arr.length; i++) {
console.log(arr[i])
}
// 4. 修改与"越界新增"（不提倡）
let arr2 = ['迪丽热巴', '古丽扎娜']
arr2[1] = '佟丽丫丫' // 修改：下标存在 → 改值
arr2[3] = '古丽扎娜' // 下标不存在 → 新增，并修改了数组长度
console.log(arr2) // ['迪丽热巴', '佟丽丫丫', 空, '古丽扎娜']
console.log(arr2.length) // 4
// 5. 新增元素：修改原数组，返回新数组的长度
let a = ['迪丽热巴']
console.log(a.push('佟丽丫丫')) // 2（返回值是新长度）
a.push('佟丽丫丫', '古丽扎娜') // 末尾新增多个
a.unshift('刘德华') // 开头新增
console.log(a)
// 6. 删除元素：修改原数组，返回被删除的那个元素
let b = ['red', 'green']
console.log(b.pop()) // 'green'，删最后一个，小括号为空
console.log(b) // ['red']
let c = ['red', 'green']
console.log(c.shift()) // 'red'，删第一个
console.log(c) // ['green']
</script>
</body>
</html>要点解释：
- 索引从 0 开始：
names[0]是第一个元素，names[names.length - 1]才是最后一个。 - 遍历一定要写
i < arr.length，不要像笔记注释里那样写死i < 4，否则数组长度一变就出错。 push/unshift返回的是新数组长度，pop/shift返回的是被删除的元素，两者返回值含义完全不同，考试和面试常考。pop()、shift()小括号里什么都不写，一次只能删一个；想删多个就多调用几次。- 这四个方法都会修改原数组，操作的都是数组的「开头和末尾」。
- 易错点：
arr2[3] = '古丽扎娜'跳过下标 2 赋值，中间会产生空位（长度变 4），日常开发要避免。
示例三：splice 指定位置增删 + 数组筛选案例
html
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<title>splice 与数组筛选</title>
</head>
<body>
<script>
// ===== 1. splice 删除：数组.splice(起始位置, 删除几个) =====
let arr = ['迪丽热巴', '古力娜扎', '佟丽丫丫', '玛尔扎哈']
arr.splice(1, 1) // 从索引 1 开始，删除 1 个
console.log(arr) // ['迪丽热巴', '佟丽丫丫', '玛尔扎哈']
let arr1 = ['迪丽热巴', '古力娜扎', '佟丽丫丫', '玛尔扎哈']
arr1.splice(1) // 第二个参数省略 → 从索引 1 删到最后
console.log(arr1) // ['迪丽热巴']
let arr2 = ['迪丽热巴', '古力娜扎', '佟丽丫丫', '玛尔扎哈']
arr2.splice(1, 2) // 从索引 1 开始，删 2 个
console.log(arr2) // ['迪丽热巴', '玛尔扎哈']
// ===== 2. splice 新增：数组.splice(起始位置, 删除几个, 新增元素1, ...新增元素n) =====
let arr3 = ['迪丽热巴', '古力娜扎', '佟丽丫丫', '玛尔扎哈']
// 想把刘德华、pink放到索引 1 的位置 → 第二个参数写 0 表示不删除
arr3.splice(1, 0, '刘德华', 'pink')
console.log(arr3) // ['迪丽热巴', '刘德华', 'pink', '古力娜扎', '佟丽丫丫', '玛尔扎哈']
// ===== 3. 筛选数组：把大于等于 10 的元素放进新数组 =====
let oldArr = [2, 0, 6, 1, 77, 0, 52, 0, 25, 7]
let newArr = [] // 先准备一个空的新数组
for (let i = 0; i < oldArr.length; i++) { // 遍历旧数组
if (oldArr[i] >= 10) { // 判断条件
newArr.push(oldArr[i]) // 满足条件 → 追加给新数组
}
}
console.log(newArr) // [77, 52, 25]
// ===== 4. 举一反三：去掉 0，得到不含 0 的新数组 =====
let newArr2 = []
for (let i = 0; i < oldArr.length; i++) {
if (oldArr[i] !== 0) { // 条件换成"不等于 0"
newArr2.push(oldArr[i])
}
}
console.log(newArr2) // [2, 6, 1, 77, 52, 25, 7]
</script>
</body>
</html>要点解释：
splice(start, deleteCount, item1, item2...)：第一个参数是起始位置的索引号（从 0 数），不是"第几个"；要删第二个元素就写1。- 删除时第二个参数可省略，省略即从起始位置删到最后；要删两个就写
splice(1, 2)。 - 新增时第二个参数不能省略，不想删除就写
0，后面的元素会被插入到起始位置之前。 splice会修改原数组，它不替代push / pop / unshift / shift：开头结尾找那四个，中间位置用 splice。- 筛选数组的固定套路：准备新数组 → 遍历旧数组 → 判断条件 →
newArr.push(旧数组[i])。 - 易错点：最容易写反的是
oldArr.push(newArr[i])或newArr.push(oldArr)——是新数组去 push 旧数组里的元素。 - 易错点：判断"不等于"必须用
!==（或!=），写成= 0就变成赋值了，条件永远为真。
常见错误
嵌套循环打印出“一列”而不是“一片” 现象：三角形/九九乘法表只输出一行，或每行只有一颗星。 原因：内外层用了同一个循环变量（如内外都是
i），内层把i改回初值，外层条件永远成立或提前终止。 修法：外层i、内层j，变量名必须不同；写完后口头念一遍“外层走一次，内层走一轮”。内层循环上限写成固定数字 现象：想打印 5 行的三角，结果每行都是 5 颗星，变成矩形。 原因：内层写成
j <= 5，没有和外层变量挂钩。 修法：内层条件用外层变量做上限（j <= i），行数与列数才产生关系。换行语句放错位置 现象：每颗星后面都换行，或整张表挤在一行。 原因：
document.write('<br>')写进了内层循环体内，或写在了外层循环之外。 修法：换行属于“一行的结束”，必须放在内层循环结束之后、外层循环体内。遍历数组漏掉最后一个元素或读出
undefined现象：['a','b','c','d']只打印 3 个；或末尾多打印一个undefined。 原因：条件写成i < 4（写死数字）或i <= arr.length（多走一轮）。 修法：统一用i < arr.length，长度交给length管，数组增删后不用改代码。把
push的返回值当成新数组 现象：arr = arr.push('小明')之后arr变成数字2，后面全部报错。 原因：push返回的是新数组的长度，不是数组本身；pop/shift返回的是被删除的元素。 修法：新增/删除只调用、不接收，arr.push('小明')单独一行；需要长度再单独取arr.length。splice的起始位置数错、新增时漏写第二个参数 现象：想删第 2 个元素却删掉了第 1 个；想插入元素结果把后面全删光了。 原因：起始位置按“第几个”从 1 数，而它是索引、从 0 数；插入时省略deleteCount，默认删到末尾。 修法：位置先在心里减 1 再写；纯插入必须写splice(index, 0, 新元素)。筛选数组时方向写反 现象：控制台报错，或原数组被改得面目全非。 原因：写成
arr.push(newArr[i])，或newArr = newArr.push(arr[i])。 修法：记住“新数组负责收，旧数组负责供”——newArr.push(arr[i])，且原数组只读不改。
练习
- 用嵌套循环打印一个 5 行的倒三角形（第 1 行 5 颗星，逐行递减到 1 颗），再打印一个 5 行 5 列的空心方框（只有边框有星）。
- 定义数组
[12, 5, 77, 0, 25, 3, 0, 52]，分别完成：① 筛选出所有不为 0 的元素放入新数组；② 筛选出所有大于等于 20 的元素放入新数组。要求原数组不被修改。 - 给定
['小明','小刚','小红','小丽']，按顺序完成四步并每步打印数组：末尾加'小米'、开头加'小强'、删除最后一个、删除第一个。 - 给定
['迪丽热巴','古力娜扎','佟丽丫丫','玛尔扎哈']，用splice完成：① 删掉中间的'古丽娜扎'；② 在'佟丽丫丫'之前插入'刘德华'；③ 把后两个元素整体替换成'A','B','C'。 - 用嵌套循环 + 数组，把 1~9 的乘法表存进一个二维数组（第
i行存1×i … i×i的结果），最后遍历这个二维数组，按j x i = 结果的格式输出。
原视频对照
| # | 视频 | 时长 |
|---|---|---|
| 1 | 操作数组之新增数组元素 | 06:54 |
| 2 | 筛选数组筛选大于等于10的元素 | 06:49 |
| 3 | 数组筛选筛选不为0的元素 | 04:16 |
| 4 | 操作数组之删除数组元素 | 05:57 |
| 5 | 数组splice方法 | 11:02 |
小结
- 嵌套循环的执行次数是乘法关系：外层 5 次、内层 5 次，循环体共执行 25 次；口诀“外层一次，内层一轮”。
- 内层循环的边界通常由外层变量决定，这是三角形、乘法表这类“行数决定列数”问题的通用解法。
- 数组索引从 0 开始，
arr.length是元素个数也是“下一个空位的索引”，i < arr.length是遍历的唯一推荐写法。 - 数组的增删方法都会修改原数组：
push/unshift返回新长度，pop/shift返回被删元素——返回值都不要再赋回给数组变量。 - 首尾操作用
push/pop/unshift/shift更直观，中间位置操作用splice；“开头结尾找它们，中间交给 splice”。 splice的两个参数必须分清角色：起始位置是索引（从 0 数），第二个参数是删除个数；纯插入时第二个参数写 0 且不能省。- 筛选类需求有固定三步：准备空的新数组 → 遍历旧数组 → 满足条件就
newArr.push(arr[i])，换的只是判断条件。 - 遍历 + 条件 +
push这套组合是后续所有数据处理（去重、统计、分组）的雏形，练熟比记住 API 更重要。