命令符:
1. push()
+ 语法: 数组.push(数据)
+ 作用: 向数组的末尾追加一个数据, 等价于 arr[arr.length] = 值
+ 返回值: 追加数据后最新的数组长度
2. pop()
+ 语法: 数组.pop()
+ 作用: 删除数组的最后一个数据
+ 返回值: 被删除的数据
3. unshift()
+ 语法: 数组.unshift(数据)
+ 作用: 向数组的最前面插入一个数据
+ 返回值: 插入数据后最新的数组长度
4. shift()
+ 语法: 数组.shift()
+ 作用: 删除数组最前面一个数据
+ 返回值: 被删除的数据
-
5. reverse()
+ 语法: 数组.reverse()
+ 作用: 反转数组
+ 返回值: 反转以后的数组
6. sort()
+ 语法:
=> 数组.sort()
-> 按照数据一位一位看待进行排列的, ASCII 码进行排列的
=> 数组.sort(function (a, b) { return a - b })
-> 按照数字大小进行升序排列, 从小到大
=> 数组.sort(function (a, b) { return b - a })
-> 按照数字大小进行降序排列, 从大到小
+ 作用: 对数组进行排序
+ 返回值: 排序以后的数组
7. splice()
+ 语法:
=> 数组.splice(开始索引, 多少个)
=> 数组.splice(开始索引, 多少个, 要插入的内容)
-> 要插入的内容可以写多个
-> 注意: 从哪里开始删除, 从哪里开始插入
+ 作用: 截取数组中的部分内容, 并且插入内容
+ 返回值: 必然是一个新的数组
=> 新数组内是被删除的部分内容
=> 如果你没有删除的内容, 那么就是一个空的新数组
8. concat()
+ 语法: 原始数组.concat(数据或者数组)
=> 参数可以是数据, 也可以是一个数组
=> 可以书写多个
+ 作用: 拼接数组, 把参数的所有内容拼接到数组的末尾
=> 如果你的参数也是一个数组, 会把参数数组拆开, 依次拼接到原始数组内
+ 返回值: 拼接好的数组
9. join()
+ 语法: 数组.join(连接符号)
=> 参数不写的时候, 默认使用 逗号(,) 连接
+ 作用: 使用连接符号把数组内的每一个数据连接成一个 **字符串**
+ 返回值: 必然是一个字符串类型, 连接好的内容
10. slice()
+ 语法: 数组.slice(开始索引, 结束索引)
=> 特点1: 包前不包后, 包含开始索引位置, 不包含结束索引位置
=> 特点2: 可以填写负整数, 表示倒数多少个, 其实就是 数组.length + 负整数
+ 作用: 截取数组的部分内容
+ 返回值: 必然是一个新的数组
=> 你截取了内容, 那么新数组内就是你截取的内容
=> 你没有截取内容, 那么就是一个空的新数组
11. indexOf()
+ 语法: 数组.indexOf(数据, 开始索引)
=> 开始索引位置可以不写, 默认是 0
+ 作用: 从左到右查看该数据在数组中 **第一次** 出现的索引位置
+ 返回值:
=> 如果数组中有该数据存在, 那么就是第一次出现的索引位置
=> 如果数组中没有该数据存在, 那么就是 -1
12. lastIndexOf()
+ 语法: 数组.lastIndexOf(数据, 开始索引)
=> 开始索引位置可以不写, 默认是数组的最后一位索引
+ 作用: 从后向前查看该数据在数组中 **第一次** 出现的索引位置
+ 返回值:
=> 如果数组中有该数据存在, 那么就是第一次出现的索引位置
=> 如果数组中没有该数据存在, 那么就是 -1
+ 注意: 只是从后向前查找, 但是不改变数据的索引位置
13. forEach()
+ 语法: 数组.forEach(function (item, index, arr) {})
+ 作用: 遍历数组
+ 返回值: 没有
14. map()
+ 语法: 数组.map(function (item, index, arr) {})
+ 作用: 映射数组
+ 返回值: **是一个新的数组, 和原始数组长度一模一样的新数组**
=> 新数组内的每一个数据是从原始数组中映射过来的(操作一下原始数组的数据)
+ 注意: 映射条件以 return 的形式书写
15. filter()
+ 语法: 数组.filter(function (item, index, arr) {})
+ 作用: 过滤数组
+ 返回值: **是一个新的数组, 原始数组中满足条件的项**
=> 新数组内的每一个数据都是从原数组中过滤出来的内容
+ 注意: 过滤条件以 return 的形式书写
16. find()
+ 语法: 数组.find(function (item, index, arr) {})
+ 作用: 在数组中查找第一个符合条件的数据
+ 返回值: 你查找到的符合要求的数据
+ 注意: 查找条件以 return 的形式书写
17. findIndex()
+ 语法: 数组.findIdnex(function (item, index, arr) {})
+ 作用: 在数组中查找第一个符合条件的数据的索引
+ 返回值: 你查找到的符合要求的数据的索引
+ 注意: 查找条件以 return 的形式书写
18. every()
+ 语法: 数组.every(function (item, index, arr) {})
+ 作用: 判断数组中是不是每一个都满足条件
+ 返回值: 必然是一个布尔值
=> 如果数组中每一项都满足条件, 那么返回 true
=> 只要数组中有任何一项不满足条件, 那么返回 false
+ 注意: 判断条件以 return 的形式书写
19. some()
+ 语法: 数组.some(function (item, index, arr) {})
+ 作用: 判断数组中是不是有某一个满足条件
+ 返回值: 必然是一个布尔值
=> 如果数组中有任何一个满足条件, 那么返回 true
=> 只有数组中所有的都不满足条件的时候, 返回 false
+ 注意: 判断条件以 return 的形式书写
用法:
// 准备一个数组
var arr = [ 100, 200, 300, 400, 500 ]
console.log('原始数组 : ', arr)
1. push()
// var res = arr.push('新来的')
// console.log('追加之后 : ', arr)
// console.log('返回值 : ', res)
// 2. pop()
// var res = arr.pop()
// console.log('删除之后 : ', arr)
// console.log('返回值 : ', res)
// 3. unshift()
// var res = arr.unshift('新来的')
// console.log('插入之后 : ', arr)
// console.log('返回值 : ', res)
// 4. shift()
var res = arr.shift()
console.log('删除之后 : ', arr)
console.log('返回值 : ', res)
// 5. reverse()
// var arr = [ 'hello', 'world', '你好', '世界' ]
// console.log('原始数组 : ', arr)
// var res = arr.reverse()
// console.log('反转之后 : ', arr)
// console.log('返回值 : ', res)
// 6. sort()
// var arr = [ 1, 22, 3, 11, 10, 7, 21, 105 ]
// console.log('原始数组 : ', arr)
// 语法1:
// var res = arr.sort()
console.log('排序之后 : ', arr)
console.log('返回值 : ', res)
// 语法2:
// var res = arr.sort(function (a, b) { return a - b })
// console.log('排序之后 : ', arr)
// console.log('返回值 : ', res)
// 语法3:
// var res = arr.sort(function (a, b) { return b - a })
// console.log('排序之后 : ', arr)
// console.log('返回值 : ', res)
// 7. splice
var arr = [ 100, 200, 300, 400, 500, 600, 700 ]
// 0 1 2 3 4 5 6
console.log('原始数组 : ', arr)
// 语法1:
// 表示从数组 [2] 位置开始, 删除 3 个内容
// var res = arr.splice(2, 3)
// console.log('删除之后 : ', arr)
// console.log('返回值 : ', res)
// 语法2:
// 表示从数组 [2] 位置开始, 删除 1 个内容, 把 '新来的' 内容插入到 [2] 位置
// var res = arr.splice(2, 1, '新来的')
// console.log('删除之后 : ', arr)
// console.log('返回值 : ', res)
// 表示从数组 [2] 位置开始, 删除 1 个内容, 把 '新来的' 和 '又来一个' 插入到 [2] 位置和 [3] 位置, 剩余数据向后顺延
// var res = arr.splice(2, 1, '新来的', '又来一个')
// console.log('删除之后 : ', arr)
// console.log('返回值 : ', res)
// 表示从数组 [2] 位置开始, 删除 0 个数据, 把 '新来的' 插入到 [2] 位置, 剩余的向后顺延
// var res = arr.splice(2, 0, '新来的')
// // [ 100, 200, '新来的', 300, 400, 500, 600, 700 ]
// console.log('删除之后 : ', arr)
// console.log('返回值 : ', res)
// 8. concat()
// var arr = [ 100, 200, 300 ]
// console.log('原始数组 : ', arr)
// 把 '新来的' 和 arr 组成一个新的数组
// var res = arr.concat('新来的')
// console.log('拼接之后 : ', arr)
// console.log('返回值 : ', res)
// 把 [ 'a', 'b', 'c' ] 内的所有内容和 原始数组 arr 拼接成一个数组
// var res = arr.concat([ 'a', 'b', 'c' ], [ 10, 20, 30 ], 666)
// console.log('拼接之后 : ', arr)
// console.log('返回值 : ', res)
// 9. join()
// var arr = [ 2022, 3, 25 ]
// console.log('原始数组 : ', arr)
// var res = arr.join('-')
// console.log('连接之后 : ', arr)
// console.log('返回值 : ', res)
// 10. slice()
// var arr = [ 100, 200, 300, 400, 500, 600, 700 ]
// 0 1 2 3 4 5 6
// console.log('原始数组 : ', arr)
// 表示从数组 [2] 位置开始截取到数组 [5] 位置, 包含 [2] 位置数据, 不包含 [5] 位置数据
// 注意: 不会改变原始数组, 相当于把指定位置的内容复制一份拿出来
// 注意: 如果第一个参数不写, 那么就是 0
// 注意: 如果第二个参数不写或者超出数组的长度, 那么就是截取到数组末尾
// var res = arr.slice(2, 5)
// console.log('截取之后 : ', arr)
// console.log('返回值 : ', res)
// 你填写的 -2 等价于 arr.length + -2, 其实就是 5
// var res = arr.slice(2, -2)
// console.log('截取之后 : ', arr)
// console.log('返回值 : ', res)
// 11. indexOf()
// var arr = [ 100, 200, 300, 400, 100, 200, 300, 100, 200, 100 ]
// console.log('原始数组 : ', arr)
// 表示从左到右开始查找 200 这个数据在 arr 中第一次出现的位置
// var res = arr.indexOf(200)
// console.log('返回值 : ', res)
// 表示从 [2] 位置开始, 从左到右查找 200 这个数据在 arr 中第一次出现的位置
// var res = arr.indexOf(200, 2)
// console.log('返回值 : ', res)
// 12. lastIndexOf()
var arr = [ 100, 200, 300, 400, 100, 200, 300, 100, 200, 100 ]
console.log('原始数组 : ', arr)
// 表示从右向左开始查找 200 这个数据在 arr 中第一次出现的位置
// var res = arr.lastIndexOf(200)
// console.log('返回值 : ', res)
// 表示从 [7] 位置开始, 从右向左查找 200 这个数据在 arr 中第一次出现的位置
var res = arr.lastIndexOf(200, 7)
console.log('返回值 : ', res)
// 13. forEach()
// var arr = [ 100, 200, 300, 400, 500 ]
// console.log('原始数组 : ', arr)
// 这个 函数 会根据 arr 数组中有多少个成员, 执行多少回
// 这个 函数 可以接受三个形参
// 第一个形参: 表示 数组中的每一项
// 第二个形参: 表示 数组每一项的索引
// 第三个形参: 表示 原始数组
// arr.forEach(function (item, index, arr) {
// console.log('我执行了')
// console.log('item : ', item)
// console.log('index : ', index)
// console.log('arr : ', arr)
// console.log('---------------------------')}
// 14. map()
// var arr = [ 10, 20, 30, 40, 50 ]
// console.log('原始数组 : ', arr)
// var res = arr.map(function (item, index) {
// // 把原始数组中的每一项放大十倍
// return item * 10
// })
// console.log(res) // [100, 200, 300, 400, 500]
// 15. filter()
// var arr = [ 100, 200, 300, 400, 500 ]
// console.log('原始数组 : ', arr)
// var res = arr.filter(function (item, index) {
// // 把原始数组中所有 大于 300 的数据过滤出来
// return item > 300
// })
// console.log('返回值 : ', res)
// 16. find()
// var arr = [ 100, 200, 300, 400 ]
// console.log('原始数组 : ', arr)
// var res = arr.find(function (item) {
// // 从 每一项 中, 查找第一个 百位数是 偶数的
// return parseInt(item / 100) % 2 === 0
// })
// console.log('返回值 : ', res)
// 17. findIndex()
// var arr = [ 100, 200, 300, 400 ]
// console.log('原始数组 : ', arr)
// var res = arr.findIndex(function (item) {
// // 从 每一项 中, 查找第一个 百位数是 偶数的
// return parseInt(item / 100) % 2 === 0
// })
// console.log('返回值 : ', res)
// 18. every()
// var arr = [ 100, 200, 300, 400, 500 ]
// console.log('原始数组 : ', arr)
// var res = arr.every(function (item) {
// // 判断是不是每一项都 大于 100
// return item > 100
// })
// console.log('返回值 : ', res)
// 19. some()
var arr = [ 100, 200, 300, 400, 500 ]
console.log('原始数组 : ', arr)
var res = arr.some(function (item) {
// 判断是不是有大于 100 的项
return item > 400
})