数组循环有多种方式，在这里我就不比对那种循环之间的性能比较，纯属就说说它们的用法。
forEach()
forEach方法第一个参数传入一个回调函数，回调函数有三个形参，分别是数组元素，元素下表，元素数组，第二个参数可以传入一个任意类型的值，这个值可以改变第一个参数内部的this指向。返回值是 undefined。
let arr = [1, 2, 3, 4]let obj = { name: "张三"}
let res = arr.forEach(function(val, index, arr) {
console.log("数组元素：", val, "元素下标：", index, "原数组：", arr, '改变this指向:', this)
}, obj)
console.log("返回值: ", res)
// 数组元素： 1 元素下标： 0 原数组： [ 1, 2, 3, 4 ] 改变this指向: { name: '张三' }
// 数组元素： 2 元素下标： 1 原数组： [ 1, 2, 3, 4 ] 改变this指向: { name: '张三' }
// 数组元素： 3 元素下标： 2 原数组： [ 1, 2, 3, 4 ] 改变this指向: { name: '张三' }
// 数组元素： 4 元素下标： 3 原数组： [ 1, 2, 3, 4 ] 改变this指向: { name: '张三' }
// 返回值: undefined
map()
map方法传入一个回调函数，回调函数有三个形参，分别是数组元素，元素下表，元素数组，第二个参数可以传入一个任意类型的值，这个值可以改变第一个参数内部的this指向。返回值是一个新的数组。
let arr = [1, 2, 3, 4]let obj = { name: "张三"}
let res = arr.map(function(val, index, arr) {
console.log("数组元素：", val, "元素下标：", index, "原数组：", arr, "改变this指向:", this)
return val + 1
}, obj)
console.log("返回一个新的数组: ", res, "原数组:", arr)
// 数组元素： 1 元素下标： 0 原数组： [ 1, 2, 3, 4 ] 改变this指向: { name: '张三' }
// 数组元素： 2 元素下标： 1 原数组： [ 1, 2, 3, 4 ] 改变this指向: { name: '张三' }
// 数组元素： 3 元素下标： 2 原数组： [ 1, 2, 3, 4 ] 改变this指向: { name: '张三' }
// 数组元素： 4 元素下标： 3 原数组： [ 1, 2, 3, 4 ] 改变this指向: { name: '张三' }
// 返回一个新的数组: [ 2, 3, 4, 5 ] 原数组: [ 1, 2, 3, 4 ]
filter()
filter方法传入一个回调函数，回调函数有三个形参，分别是数组元素，元素下表，元素数组，第二个参数可以传入一个任意类型的值，这个值可以改变第一个参数内部的this指向。这个方法可以用于进行过滤筛选。它的返回值是一个过滤后的数组。
let arr = [1, 2, 3, 4]let obj = { name: "张三"}
let res = arr.filter(function(val, index, arr) {
console.log("数组元素：", val, "元素下标：", index, "原数组：", arr, "改变this的指向：", this)
return val < 2
}, obj)
console.log("返回一个过滤后的数组: ", res, "原数组:", arr)
// 数组元素： 1 元素下标： 0 原数组： [ 1, 2, 3, 4 ] 改变this的指向： { name: '张三' }
// 数组元素： 2 元素下标： 1 原数组： [ 1, 2, 3, 4 ] 改变this的指向： { name: '张三' }
// 数组元素： 3 元素下标： 2 原数组： [ 1, 2, 3, 4 ] 改变this的指向： { name: '张三' }
// 数组元素： 4 元素下标： 3 原数组： [ 1, 2, 3, 4 ] 改变this的指向： { name: '张三' }
// 返回一个过滤后的数组: [ 1 ] 原数组: [ 1, 2, 3, 4 ]
every()
every方法传入一个回调函数，回调函数有三个形参，分别是数组元素，元素下表，元素数组，第二个参数可以传入一个任意类型的值，这个值可以改变第一个参数内部的this指向。它的返回值是一个布尔值，如果数组元素都符合回调函数的条件，则返回 true，否则返回false。
let arr = [1, 2, 3, 4]let obj = { name: "张三"}
let res = arr.every(function(val, index, arr) {
console.log("数组元素：", val, "元素下标：", index, "原数组：", arr, "改变this的指向：", this)
return val < 2
}, obj)
console.log("是否数组内部的所有成员都满足回调函数里到条件: ", res, "原数组:", arr)
// 数组元素： 1 元素下标： 0 原数组： [ 1, 2, 3, 4 ] 改变this的指向： { name: '张三' }
// 数组元素： 2 元素下标： 1 原数组： [ 1, 2, 3, 4 ] 改变this的指向： { name: '张三' }
// 是否数组内部的所有成员都满足回调函数里到条件: false 原数组: [ 1, 2, 3, 4 ]
some()
every方法传入一个回调函数，回调函数有三个形参，分别是数组元素，元素下表，元素数组，第二个参数可以传入一个任意类型的值，这个值可以改变第一个参数内部的this指向。它的返回值是一个布尔值，如果数组存在元素符合回调函数的条件，则返回 true，否则返回false。
let arr = [1, 2, 3, 4]
let obj = { name: "张三"}
let res = arr.some(function(val, index, arr) {
console.log("数组元素：", val, "元素下标：", index, "原数组：", arr, "改变this的指向：", this)
return val < 2
}, obj)
console.log("是否数组内部的存在成员满足回调函数里到条件: ", res, "原数组:", arr)
// 数组元素： 1 元素下标： 0 原数组： [ 1, 2, 3, 4 ] 改变this的指向： { name: '张三' }
// 是否数组内部的存在成员满足回调函数里到条件: true 原数组: [ 1, 2, 3, 4 ]
entries()
entries方法不传入任何参数，它返回一个数组的迭代对象，该对象包含数组的键值对 (key/value)。可以用for...of... 进行循环
let arr = [1, 2, 3, 4]
for(let [key, value] of arr.entries()) {
console.log("数组下标：", key,"数组元素：", value)
}
// 数组下标： 0 数组元素： 1
// 数组下标： 1 数组元素： 2
// 数组下标： 2 数组元素： 3
// 数组下标： 3 数组元素： 4
keys()
keys方法不传入任何参数，它返回一个数组的迭代对象，该对象包含数组的键(key)。可以用for...of... 进行循环
let arr = [1, 2, 3, 4]
for(let key of arr.keys()) {
console.log("数组下标：", key)
}
// 数组下标： 0
// 数组下标： 1
// 数组下标： 2
// 数组下标： 3
values()
values方法不传入任何参数，它返回一个数组的迭代对象，该对象包含数组的元素值(value)。可以用for...of... 进行循环
let arr = [1, 2, 3, 4]
for(let value of arr.values()) {
console.log("数组元素：", value)
}
// 数组元素： 1
// 数组元素： 2
// 数组元素： 3
// 数组元素： 4
reduce()
reduce方法可以传入两个参数，第一个参数传入的是一个回调函数，回调函数里有四个参数，分别是：total，currentValue, currentIndex, array。 第二个参数传入的是一个初始值。
- total：上一次累加的值
- currentValue：当前的元素
- currentIndex：当前元素的索引
- array：当前元素所属的数组对象。
let arr = [1, 2, 3, 4, 5, 6];
let res = arr.reduce((preVal, curVal, curIndex, array) => {
console.log('上一次累加的值：', preVal, "当前循环的数组元素的值：", curVal, "数组的下标：", curIndex, "原数组：", array)
return preVal + curVal
}, 10);// 传递给函数的初始值
console.log('数组求和：', res)
// 上一次累加的值： 10 当前循环的数组元素的值： 1 数组的下标： 0 原数组： [ 1, 2, 3, 4, 5, 6 ]
// 上一次累加的值： 11 当前循环的数组元素的值： 2 数组的下标： 1 原数组： [ 1, 2, 3, 4, 5, 6 ]
// 上一次累加的值： 13 当前循环的数组元素的值： 3 数组的下标： 2 原数组： [ 1, 2, 3, 4, 5, 6 ]
// 上一次累加的值： 16 当前循环的数组元素的值： 4 数组的下标： 3 原数组： [ 1, 2, 3, 4, 5, 6 ]
// 上一次累加的值： 20 当前循环的数组元素的值： 5 数组的下标： 4 原数组： [ 1, 2, 3, 4, 5, 6 ]
// 上一次累加的值： 25 当前循环的数组元素的值： 6 数组的下标： 5 原数组： [ 1, 2, 3, 4, 5, 6 ]
// 数组求和： 31
reduceRight()
reduceRight方法的使用跟reduce方法的使用是一样的，只不过从后往前累加，看下面的代码就明白了。
let arr = [1, 2, 3, 4, 5, 6]
let res = arr.reduceRight((preVal, curVal, curIndex, array) => {
console.log('上一次累加的值：', preVal, "当前循环的数组元素的值：", curVal, "数组的下标：", curIndex, "原数组：", array)
return preVal + curVal
}, 10) // 传递给函数的初始值
console.log('数组求和：', res)
// 上一次累加的值： 10 当前循环的数组元素的值： 6 数组的下标： 5 原数组： [ 1, 2, 3, 4, 5, 6 ]
// 上一次累加的值： 16 当前循环的数组元素的值： 5 数组的下标： 4 原数组： [ 1, 2, 3, 4, 5, 6 ]
// 上一次累加的值： 21 当前循环的数组元素的值： 4 数组的下标： 3 原数组： [ 1, 2, 3, 4, 5, 6 ]
// 上一次累加的值： 25 当前循环的数组元素的值： 3 数组的下标： 2 原数组： [ 1, 2, 3, 4, 5, 6 ]
// 上一次累加的值： 28 当前循环的数组元素的值： 2 数组的下标： 1 原数组： [ 1, 2, 3, 4, 5, 6 ]
// 上一次累加的值： 30 当前循环的数组元素的值： 1 数组的下标： 0 原数组： [ 1, 2, 3, 4, 5, 6 ]
// 数组求和： 31
