数组
- 什么是数组
数组是存放一些数据的集合，也是引用数据类型(复杂数据类型）- 引用数据类型：数组、对象、函数
- 简单来说我们把数据放到一个盒子中, 这个盒子就是数组, 注意数组内的数据是有顺序的，但是数据的类型没有限制，但是在开发的时候一般需要将一个数组内的数据类型限制为一个
比如：纯字符串数组、纯数字数组、纯对象数组
- 数组和对象将来如何选择？
- 示例：
商品的详情存放到某一个对象中，比如: 商品名， 商品价格，商品折扣，商品描述......
商品列表假设有100个商品，那么你就有100个商品详情，按照上述的封装，那么你有100个对象，我们可以将这100个对象，存放到某个数组中，进行维护管理...
- 示例：
一、创建数组
1、字面量的方式创建(使用场景最多的方式)
var arr1 = [] //创建了一个空数组
console.log(arr1) //[]
2、内置构造函数的方式创建
var arr2 = new Array() //创建一个空数组
console.log(arr2) //[]
//创建一个长度为5的数组
var arr3 = new Array(5)
console.log(arr3)//（5）[empty*5]
//创建一个有内容的数组
var arr4 = new Array(100,200,300,'why','new','bee')
console.log(arr4)//[100,200,300,'why','new','bee']
二、数组的长度
- 数组的长度并不固定，取决于数组内部有多少个元素
- 查看方式：
1、打印数据，在控制台展开数组，找到最后的length
2、打印 数组名.length - 当数组的长度 === 0 ，代表当前数组为
空数组 - 当数组为空数组的时候，做某些操作
if(arr.length === 0){
`xxxxxxxx
}
var arr=[1,2,3,4,5]
console.log(arr)//[1,2,3,4,5]
console.log(arr.length)//5
三、数组的索引（下标）
- 有什么用？表明数组的这个位置上有什么内容
- 注意:
下标是固定的，永远是0 1 2 3 4 5 ...但是下标对应的内容不是固定的
var arr=[1,2,3,4,5]
//下标： 0 1 2 3 4
console.log(arr)
console.log(arr[0])//会得到当前数组下标0这个位置上的值--1
//通过数组的下标，我们也可以修改数组中某一个元素的内容
arr[2] = '新数据'
console.log('修改后的数组：',arr)//[1,2,'新数据',4,5]
四、数组遍历
1、需求：拿到数组各个位置上的值
var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
for (var i = 0; i < arr.length; i++) {
console.log(arr[i])
}
2、课上练习：
1）找出数组中的最大值
var arr = [34, 65, 76, 50, 12, 24]
var max = arr[0]
for (var i = 0; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i]
}
}
console.log(`最大值是${max}`)
2）计算数组中所有内容相加的和
var arr = [34, 65, 76, 50, 12, 24]
var sum = 0
for (var i = 0; i < arr.length; i++) {
sum += arr[i]
}
console.log(`数组内容和为${sum}`)
3）封装一个函数，名为includes
- 功能：传入一个数组和数字，判断这个数组中是否包含这个数字;包含返回true，否则false
function includes(arr, num) {
for (var i = 0; i < arr.length; i++) {
if (arr[i] === num) {
return true
}
}
return false
}
var res = includes([12, 23, 34, 45, 56, 67], 23)
console.log(res)
4）封装一个函数，名为indexOf
- 功能：传入一个数组和数字，判断这个数组中是否包含这个数字，包含返回这个数字的下标（从左到右第一个）否则返回-1
function indexOf(arr, num) {
for (var i = 0; i < arr.length; i++) {
if (arr[i] === num) {
return i
}
}
return -1
}
var res = indexOf([12, 67, 23, 34, 45, 56, 67], 675)
console.log(res)
5）封装一个函数，名为indexOf
- 功能：书写一个函数 LastIndexof 功能和 indexof 相同，但是查的顺序为 从右到左.
function lastIndexOf(arr, num) {
for (var i = arr.length - 1; i >= 0; i--) {
if (arr[i] === num) {
return i
}
}
return -1
}
var res = lastIndexOf([12, 67, 23, 34, 45, 56, 12, 67], 67)
console.log(res)
注意：声明式定义函数，可以在函数定义前调用
五、冒泡排序
1、基础版
var arr = [9, 8, 7, 6, 5, 4, 3, 2, 1]
// 冒泡排序 (基础版, 没有优化)
for (var j = 0; j < arr.length; j++) {
for (var i = 0; i < arr.length; i++) {
if (arr[i] > arr[i + 1]) {
var temp = arr[i]
arr[i] = arr[i + 1]
arr[i + 1] = temp
}
}
console.log('第 ', j + 1, ' 轮冒泡排序后: ', arr)
}
2、优化版
var arr = [9, 8, 7, 6, 5, 4, 3, 2, 1]
for (var i = 0; i < arr.length - 1; i++) {
for (var j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
var temp = arr[j]
arr[j] = arr[j + 1]
arr[j + 1] = temp
}
}
}
console.log(arr)
3、整个优化过程
/**
* 优化 1: 外层循环可以减少一次
*
* 一共 9 个数字, 所以需要执行 9 次 冒泡
*
* 但是前 8 次执行完毕后, 就剩下一个位置和一个数字 没有验证了
*
* 所以没必要执行最后一次了, 因为没有多的位置
*/
// for (var j = 0; j < arr.length - 1; j++) {
// for (var i = 0; i < arr.length; i++) {
// if (arr[i] > arr[i + 1]) {
// var temp = arr[i]
// arr[i] = arr[i + 1]
// arr[i + 1] = temp
// }
// }
// }
// console.log('冒泡排序后: ', arr)
//优化2：内层循环 - 1
// for (var j = 0; j < arr.length - 1; j++) {
// for (var i = 0; i < arr.length - 1; i++) {
// /**
// * 当前 数组 arr.length === 9
// *
// * 那也就是说 i 最大 为 8
// *
// * 所以最后一轮循环 i === 8
// *
// * 判断的内容为 arr[i] > arr[i + 1]
// * arr[8] > arr[9]
// *
// * 所以最后一次 判断没有意义, 所以我们此时应该让 内层循环 - 1
// */
// if (arr[i] > arr[i + 1]) {
// var temp = arr[i]
// arr[i] = arr[i + 1]
// arr[i + 1] = temp
// }
// }
// }
// console.log('冒泡排序后: ', arr)
// 优化 3, 去掉多余的无用对比
// for (var j = 0; j < arr.length - 1; j++) {
// console.log('当前是第 ', j + 1, ' 次循环, 此时变量 j ===', j)
// for (var i = 0; i < arr.length - 1 - j; i++) {
// console.log('此时对比的是: ', arr[i], arr[i + 1])
// if (arr[i] > arr[i + 1]) {
// var temp = arr[i]
// arr[i] = arr[i + 1]
// arr[i + 1] = temp
// }
// }
// console.log('==========================================================')
// }
// console.log('冒泡排序后: ', arr)
六、选择排序
1、优化版
var arr = [76, 45, 65, 23, 12, 98]
for (var i = 0; i < arr.length - 1; i++) {
var minIndex = i
for (var j = i + 1; j < arr.length; j++) {
if (arr[minIndex] > arr[j]) {
minIndex = j
}
}
var temp = arr[i]
arr[i] = arr[minIndex]
arr[minIndex] = temp
}
console.log(arr)
2、选择排序过程
/**
* 选择排序
*/
var arr = [9, 3, 6, 2, 4, 1, 8, 5, 7]
// 0 1 2 3 4 5 6 7 8
/**
* 第几次循环 假设谁是最小值 和谁交换 内层循环从 ? 开始
*
* k === 0 1 0 0 1
* k === 1 2 1 1 2
* k === 2 3 2 2 3
*/
for (var k = 0; k < arr.length; k++) {
// 1. 假设 k 是最小值的下标, 保存在 minIndex
var minIndex = k
// 2. 循环会帮我们找到真实最小值的下标, 并保存在变量 minIndex
for (var i = k + 1; i < arr.length; i++) {
if (arr[minIndex] > arr[i]) {
minIndex = i
}
}
// 3. 交换 真实最小值(下标 minIndex) 和 假设最小值 (k) 的位置
var temp = arr[k]
arr[k] = arr[minIndex]
arr[minIndex] = temp
}
console.log('排序后: ', arr)
// 假设这是我们第 11111111111111111111111111111 轮 选择排序
// 1. 假设 下标0 是最小的值
// var minIndex = 0
// // 2. 循环遍历数组, 找到真实最小的值对应的下标
// for (var i = 1; i < arr.length; i++) {
// if (arr[minIndex] > arr[i]) {
// minIndex = i
// }
// }
// // 上述循环执行完毕后, 我们一定会得到最小值对应的下标
// // console.log(minIndex)
// // 3. 将 真实最小值(下标minIndex)和假设最小值(下标0)做一个交换
// var temp = arr[0]
// arr[0] = arr[minIndex]
// arr[minIndex] = temp
// console.log('第 11111111111111111111111111111 轮 选择排序后: ', arr)
// // 假设这是我们第 22222222222222222222222222222222 轮 选择排序
// // 1. 假设 下标1 是最小的值 (因为 第一轮结束后, 下标0 真的是最小值)
// var minIndex = 1
// // 2. 循环遍历数组, 找到真实最小的值对应的下标
// for (var i = 2; i < arr.length; i++) {
// if (arr[minIndex] > arr[i]) {
// minIndex = i
// }
// }
// // 上述循环执行完毕后, 我们一定会得到最小值对应的下标
// // console.log(minIndex)
// // 3. 将 真实最小值(下标minIndex)和假设最小值(下标1)做一个交换
// var temp = arr[1]
// arr[1] = arr[minIndex]
// arr[minIndex] = temp
// console.log('第 22222222222222222222222222222222 轮 选择排序后: ', arr)
// // 假设这是我们第 333333333333333333333333333333333333333 轮 选择排序
// // 1. 假设 下标2 是最小的值 (因为 前两轮结束后, 下标0 和 下标1 真的是最小值)
// var minIndex = 2
// // 2. 循环遍历数组, 找到真实最小的值对应的下标
// for (var i = 3; i < arr.length; i++) {
// if (arr[minIndex] > arr[i]) {
// minIndex = i
// }
// }
// // 上述循环执行完毕后, 我们一定会得到最小值对应的下标
// // console.log(minIndex)
// // 3. 将 真实最小值(下标minIndex)和假设最小值(下标2)做一个交换
// var temp = arr[2]
// arr[2] = arr[minIndex]
// arr[minIndex] = temp
// console.log('第 333333333333333333333333333333333333333 轮 选择排序后: ', arr)
七、数组方法
1、push
- 语法：
数组名.push(数据) - 作用：向数组末尾新增一条数据
- 返回值：新增数据后最新的数组长度
var arr = [1, 2, 3]
//数组名.push(数据)
var len = arr.push(100)
console.log(arr)//[1,2,3,100]
console.log('返回值：', len)//4
//自己封装一个push函数
//作用：向数组末尾 新增一条数据
function push(push_arr,data) {
//向数组末尾新增一个data
push_arr[push_arr.legth] = data
return push_arr.length
}
push(arr,100)
push(arr,'why')
push(arr,true)
console.log(arr)
注意：在函数传参的过程中，如果实参的值是一个引用数据类型，然后在函数内部对这个形参做了一些修改，那么会影响到函数外边的原数据。
2、pop
- 语法：
数组名.pop() - 作用：删除数组末尾最后一个数据
- 返回值：被删除的数据
var arr = [1, 2, 3]
//arr.pop() //这种写法比较常见，返回值一般不用
var res = arr.pop()
console.log(arr, '返回值：', res)//[1，2] 3
//自己封装一个pop函数
//作用：删除数组末尾最后一个数据
//返回值：被删除的数据
var arr = [1, 2, 3]
function pop(pop_arr) {
//先将数组末尾的数据保存，用于删除后返回
var len = pop_arr[pop_arr.length-1]
//1、删除 数组末尾最后一个数据
//delete pop_arr[pop_arr.length-1]//人没了
pop_arr.length -= 1//位置和人都没了
//2、返回被删除的数据
return len
}
var res = pop(arr)
console.log('函数执行完毕后的数组：', arr)
console.log('函数执行完毕后的返回值：', res)
3、unshift
- 语法：
数组.unshift(数据) - 作用：向数组开头，添加一个数据
- 返回值：新增数据后的数组长度
var arr = [1, 2, 3]
var len = arr.unshift('新的数据')
console.log(arr, len)//['新的数据', 1, 2, 3] 4
1)自己封装一个unshift函数(原数组不变）
//自己封装一个unshift函数
var arr = [1, 2, 3]
function unshift(unshift_arr,data) {
//逻辑：1、创建一个新的数组，然后将这个数组开头放上我们执行要 //添加的数据在2、将原本数组后续的内容，放在新数组的后边
//1、创建一个新的数组，然后将这个数组开头放上新加的数据
var arr2 = [data]
//2、将原本数组后续的内容，放在新数组的后边
for(var i = 0; i < unshift_arr.length; i++){
arr2[i+1] = unshift_arr[i]
}
return {
arr:arr2,
len:arr2.length
}
}
var res = unshift(arr, 'newData')
console.log(res)
console.log(res.arr)
console.log(res.len)
2)自己封装一个unshift函数(原数组也改变）
var arr = [1, 2, 3]
console.log('原数组: ', arr)
function unshift(unshift_arr, data) {
// 1. 创建一个新的数组, 然后将这个数组开头放上我们执行要添加的数据
var newArr = [data]
// 2. 在将原本数组后续的内容, 放在新数组的后边
for (var i = 0; i < unshift_arr.length; i++) {
newArr[i + 1] = unshift_arr[i]
}
// console.log('函数内部得到一个我们想要的数组: ', newArr)
// unshift_arr = newArr // 这样写不对, 原因后续会详细讲解
// 3. 遍历 我们想要得到的数组, 拿到每一项, 然后重新赋值给 unshift_arr
for (var k = 0; k < newArr.length; k++) {
unshift_arr[k] = newArr[k]
}
/**
* 此时 只需要返回一个数组的最新长度即可
* 返回 这两个数组哪一个都无所谓
* 因为 经过 上述 三个步骤 此时两个数组 长得一模一样
*
* 但是要注意, 只是长得一样, 完全不是一个数组
*
* 就好比: 两个卧室装修的一模一样, 但两个房间不是同一个
*/
// return unshift_arr.length
return newArr.length
}
var res = unshift(arr, 'newData')
console.log('函数执行完毕后的原数组: ', arr)
4、shift
- 语法：
数组.shift() - 作用：删除数组第一个数据
- 返回值：被删除的数据
var arr = [1, 2, 3]
//arr.shift() //这种写法比较常见，返回值一般不用
var res = arr.shift()
console.log(arr, '返回值：', res)//[2，3] 1
//自己封装一个shift函数
//作用：删除数组第一个数据
//返回值：被删除的数据
var arr = [1, 2, 3]
function shift(shift_arr) {
//1、暂存数组首位的内容，将来要返回出去
var temp = shift_arr[0]
//2、遍历数组找到数组所有内容，删除首位的内容
for(var i = 0;i < shift_arr.length; i++) {
shift_arr[i] = shift_arr[i+1]
}
/*经过上述循环后，数组中【0】的值已经被替换了，但最后 多了一个undefined，那么此时只需要删除数组末尾的值就 可*/
shift_arr.length -= 1
return temp
}
var res = shift(arr)
console.log(res)
5、reverse
- 语法：
数组.reverse() - 作用:将数组反转
- 返回值：反转后的数组
- 注意：该方法能够改变原数组
var res = arr.reverse()
console.log(arr)//[500, 100, 400, 300, 200, 100]
console.log(res)//[500, 100, 400, 300, 200, 100]
//自己封装一个reverse函数
//作用：反转数组
//返回值：反转后的数组
function reverse(arr) {
//1、交换数组内部元素的位置
for(var i=0; i <arr.length/2; i++) {
ver temp = arr[i]
arr[i] = arr[arr.length - 1 - i]
arr[arr.length - 1 - i] = temp
}
return arr
}
var res = reverse(arr)
console.loh(res)
6、sort
- 语法1:
数组名.sort()- 作用：将数组内的数据，转换为 字符串，然后一位一位的对比
- 语法2：
数组名.sort(function(a,b) {return a - b})- 作用：会按照数字 从小到大排序
- 语法3:
数组名.sort(function(a,b) {return b - a})- 作用：会按照数字 从大到小排序
- 作用:将数组进行排序
- 返回值:排序好的新数组
- 注意:sort使用后能够修改原数组
1）语法1
//语法1
var arr = [1,2,3,4,5,100,300,401,404,500,1001,2023]
console.log('原数组',arr)
console.log('sort 的返回值',arr.sort())
//[1, 100, 1001, 2, 2023, 3, 300, 4, 401, 404, 5, 500]
console.log('sort方法后的数组',arr)
2）语法2
//语法2
var arr = [54, 65, 23, 1, 89]
arr.sort(function(a,b) {
return a - b
})
console.log(arr)//[1, 23, 54, 65, 89]
3）语法3
//语法3
var arr = [54, 65, 23, 1, 89]
arr.sort(function(a,b) {
return b - a
})
console.log(arr)//[89, 54, 54, 23, 1]
7、splice
- 语法1：
数组.splice(开始索引，多少个) - 语法2:
数组.splice(开始索引，多少个，要插入的数据)- 开始索引:默认为0;多少个：默认为0;要插入的数据：默认是没有
- 作用:删除数组中若干数据，并选择是否插入新的数据
- 返回值:以新数组的形式返回被删除的数据
var arr = [1, 2, 3, 4, 5]
//语法1
arr.splice(0,3) //从下标0开始，剪切3个
console.log(arr) //[4,5]
var res = arr.splic(0,3)
console.log('剪切到的内容：', res)// [1,2,3]
console.log('剪切后的数组', arr) //[4,5]
//语法2
arr.splice(0,3,'新的数据',true,undefined) //从下标0开始，剪切3个
console.log(arr) //['新的数据',true,undefined,4,5]
var res = arr.splic(0,3,'新的数据',true,undefined)
console.log('剪切到的内容：', res)// [1,2,3]
console.log('剪切后的数组', arr) //[新的数据',true,undefined,4,5]
使用哪些方法会改变原数组：以上七种！
8、indexOf
- 语法1:
数组.indexOf(数据) - 语法2:
数组.indexOf(数据，从哪个下标开始（第二个参数不传，默认为0）) - 作用:按照从左到右的顺序，查找数组中是否包含这个数据
- 返回值:找到了，返回从左到右第一次出现的下标；否则返回-1
var arr = [1,2,3,4,1,2,3]
// 0 1 2 3 4 5 6
console.log(arr.indexOf(1))// 0
console.log(arr.indexOf(100))//-1
console.log(arr.indexOf(1,3)//4
console.log(arr.indexOf(1,5)//-1
console.log('arr:' ,arr)//不会改变原数组
//手写一个indexOf函数实现功能
var arr = [1, 2, 3, 4, 1, 2, 3]
function indexOf(arr, num, b = 0) {
for (var i = b; i < arr.length; i++) {
if (num === arr[i]) {
return i
}
}
return -1
}
var res = indexOf(arr,2,2)
console.log(res)
9、lastIndexOf
- 语法：
数组.lastIndexOf(数据) - 作用:按照从右到左的顺序，查找数组中是否包含这个数据
- 返回值：找到了，返回从右到左第一次出现的下标；否则返回-1
var arr = [100, 200, 300, 400, 100, 500]
var res=arr.indexOf(100)
console.log(res)//0
var res2=arr.lastIndexOf(100)
console.log(res2)//4
10、slice
- 语法：
数组.slice(开始索引,结束索引) - 包前不包后
- 两个参数可以省略不写；相当于复制整个数组
- 开始索引：默认为 0
- 结束索引：默认为 数组长度；省略结束下标，会从开始下标复制到数组结束
- 参数可以支持负数，相当于
数组.length + 负数 - 作用:复制出数组中指定范围的内容
- 返回值：以新数组的形式返回复制出来的数据
var arr = [100, 200, 300, 400, 100, 500]
var res = arr.slice(1,3)
console.log(arr,res)//[100, 200, 300, 400, 100, 500] [200, 300]
var res2=arr.slice(1,-2)
console.log(res2)//[200, 300, 400] 从右往左截取掉2个
var res3=arr.slice(1)
console.log(res3)//[200, 300, 400, 100, 500] 从索引位置开始到最后全部截取
var res4=arr.slice(-3)
console.log(res4)//[400, 100, 500] 从右往左截取3个
11、concat
- 语法：
数组.cancat(数据1，数据2，数据3...) - 作用:把传入的数据合并到指定的数组中进行拼接
- 注意：不会改变原数组
- 返回值：拼接好的新数组
var arr = [100, 200, 300, 400, 100, 500]
var res = arr.concat([500, 600])
console.log(arr, res)//[100, 200, 300, 400, 100, 500] [100, 200, 300, 400, 100, 500, 500, 600]
var arr2 = ['jzx', 'is', 'a', 'pig']
var res2=arr.concat(arr2)
console.log(arr,res2)//[100, 200, 300, 400, 100, 500] [100, 200, 300, 400, 100, 500, 'jzx', 'is', 'a', 'pig']
12、join
- 语法：
数组.join() - 作用:将数组用
连接符将数组内的所有元素，连接成为一个完整的字符串 - 返回值：连接好的
字符串 - 如果不传参数，默认按照逗号连接
var res = arr.join('---')
console.log(arr,res)//[100, 200, 300, 400, 100, 500] '100---200---300---400---100---500'
13、补充数组塌陷（使用splice清空数组）
// 用splice清空数组
var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
for (var i = 0; i < arr.length; i++) {
arr.splice(i, 1)
i--
}
// arr.splice(0, arr.length)
console.log(arr)
八、数组遍历的方法
1、forEach
- 语法：
数组.forEach(function(item,index,origin){遍历数组后你想要做的事})- item:数组中每一个元素
- index:每一个元素对应的下标
- origin:原数组
- 作用：根据数组的元素内容，遍历数组，拿到数组的每一项
- 返回值：没有返回值
- 语义：遍历数组
arr.forEach(function (item,index,origin) {
console.log(item)
console.log(index)
console.log(origin)
console.log('--------------')
})
2、map
- 语法：
数组.map(function(item,index,origin){遍历数组后你想要做的事})- item:数组中每一个元素
- index:每一个元素对应的下标
- origin:原数组
- 作用：根据原数组映射出来一个新数组
- 返回值：是一个映射出来的新数组（需要在函数内部书写return）
- 语义：映射数组
var arr = [100, 200, 300, 400, 100, 500]
var res = arr.map(function (item, index, arr) {
return item * 10
})
console.log(arr,res) //[100, 200, 300, 400, 100, 500] [1000, 2000, 3000, 4000, 1000, 5000]
})
3、filter
- 语法：
数组.filter(function(item,index,origin){遍历数组后你想要做的事})- item:数组中每一个元素
- index:每一个元素对应的下标
- origin:原数组
- 作用：过滤数组
- 返回值：过滤出来的内容组成的一个新数组
var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
var res = arr.filter(function (item) {
return item % 2 === 0
})
console.log(res) // [2, 4, 6, 8]
4、find
- 语法：
数组.find(function(item,index,origin){遍历数组后你想要做的事})- item:数组中每一个元素
- index:每一个元素对应的下标
- origin:原数组
- 作用：去数组中查找内容
- 返回值：从左至右第一个符合条件的内容，如果找不到返回undefined
var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
var res = arr.find(function (item) {
// return item % 2 === 0
return item > 5
})
// console.log(res) // 2
console.log(res) // 6
5、findIndex
- 语法：
数组.findIndex(function(item,index,origin){遍历数组后你想要做的事})- item:数组中每一个元素
- index:每一个元素对应的下标
- origin:原数组
- 作用：去数组中查找内容
- 返回值：从左至右第一个符合条件的内容的下标，如果找不到返回-1
var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
var res = arr.findIndex(function (item) {
return item % 2 === 0
// return item > 5
})
console.log(res) // 1
// console.log(res) // 5
6、every
- 语法：
数组.every(function(item,index,origin){遍历数组后你想要做的事})- item:数组中每一个元素
- index:每一个元素对应的下标
- origin:原数组
- 作用：判断数组中是否全部都符合条件
- 返回值：符合条件返回true 否则返回false
var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
var res = arr.every(function (item) {
return item % 2 === 0
})
console.log(res) // false
7、some
- 语法：
数组.some(function(item,index,origin){遍历数组后你想要做的事})- item:数组中每一个元素
- index:每一个元素对应的下标
- origin:原数组
- 作用：判断数组中有没有符合条件的元素
- 返回值：有符合条件返回true 否则返回false
var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
var res = arr.some(function (item) {
return item % 2 === 0
// return item > 0
})
console.log(res) // true
8、reduce
- 语法：
数组.reduce(function(prev,item,index,origin){},init)- 参数1：function(prev,item,index,origin){}
- prev:如果是第一次执行那么可能是数组[0]的值，也有可能是init; 如果是第一次后续的执行，那么它的值就是上一次遍历返回的结果
- 参数2：init
- 随意传递一个值即可，只要符合需求
- 参数1：function(prev,item,index,origin){}
- 作用：累加器
- 返回值：累加后的结果
var arr = [1, 2, 3, 4, 5]
var res = arr.reduce(function (prev, item, index, origin) {
return prev + item
}, 10)
console.log(res)//25=10+1+2+3+4+5
var arr = [1, 2, 3, 4, 5]
console.log('原数组: ', arr)
var res = arr.reduce(function (prev, item) {
return prev + item
}, "")
console.log(res)//字符串12345
