数组迭代方法汇总

数组的迭代方法

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

• Array.forEach() 值：一般用于遍历

 //不能 return 
arr.forEach((v,i,a)=>{
})

• Array.map() 值：返回处理过的数组
  不会更改原来的函数，return 会返回新的数组

var numbers1 = [45, 4, 9, 16, 25];
var numbers2 = numbers1.map(myFunction);

function myFunction(value) {
  return value * 2;
}

• Array.filter() 值：返回满足条件的数组
  方法创建一个包含通过测试的数组元素的新数组。

var numbers = [45, 4, 9, 16, 25];
var over18 = numbers.filter(myFunction);

function myFunction(value, index, array) {
  return value > 18;
}

• Array.every 值返回true或者false
  检查所有的数组值是否通过测试,

var numbers = [45, 4, 9, 16, 25];
var allOver18 = numbers.every(myFunction);

function myFunction(value, index, array) {
  return value > 18;
}

• Array.some 值：返回true false 有一个满足就会返回true
  检查数组值是否通过了测试

var numbers = [45, 4, 9, 16, 25];
var someOver18 = numbers.some(myFunction);

function myFunction(value, index, array) {
  return value > 18;
}

• Array.find()
  方法返回通过测试函数的第一个数组元素的值。

var numbers = [4, 9, 16, 25, 29];
var first = numbers.find(myFunction);

function myFunction(value, index, array) {
  return value > 18;
}

• Array.findIndex()：
  传入一个回调函数，找到数组中符合当前搜索规则的第一个元素，返回它的下标，终止搜索

const arr = [1, "2", 3, 3, "2"]
console.log(arr.findIndex(n => typeof n === "number")) // 0

• Array.indexOf()
  indexOf() 方法在数组中搜索元素值并返回其位置。
  从0位置开始 从0开始计数

var fruits = ["Apple", "Orange", "Apple", "Mango"];
var a = fruits.indexOf("Apple");

• Array.lastIndexOf()

var fruits = ["Apple", "Orange", "Apple", "Mango"];
var a = fruits.lastIndexOf("Apple");

• Array.reduce()
  应用：
  去重

let arr = [1, 2, 2, 4, null, null].reduce((accumulator, current) => {
    return accumulator.includes(current) ? accumulator : accumulator.concat(current);
}, []);

数组扁平化
数组求和
计算出现的次数

  let names = ['Alice', 'Bob', 'Tiff', 'Bruce', 'Alice'];

      let nameNum = names.reduce((pre,cur)=>{
        if(cur in pre){
          pre[cur]++
        }else{
          pre[cur] = 1 
        }
        return pre
      },{})
      console.log(nameNum); //{Alice: 2, Bob: 1, Tiff: 1, Bruce: 1}

• Array.reduceRight()
  相同：
  和其它函数不同之处在于第一个值是上一次便利的值

不同：
和reduce:从左向右边，reduceRight：从右边向左边

var numbers1 = [45, 4, 9, 16, 25];
var sum = numbers1.reduce(myFunction);

function myFunction(total, value, index, array) {
  return total + value;
}

• for.....in

let names = ['Tom','Jerry']
for(let i in names){
console.log(arr[i]);
}

• values() 返回键值对的键

//数组
const arr = ['a', 'b', 'c'];
for(let v of arr.values()) {
  console.log(v)
}
//'a' 'b' 'c'

//Set
const arr = new Set(['a', 'b', 'c']);
for(let v of arr.values()) {
  console.log(v)
}
// 'a' 'b' 'c'

//Map
const arr = new Map();
arr.set('a', 'a');
arr.set('b', 'b');
for(let v of arr.values()) {
  console.log(v)
}
// 'a' 'b'

keys 返回键值对的 键值

//数组
const arr = ['a', 'b', 'c'];
for(let v of arr.keys()) {
  console.log(v)
}
// 0 1 2

//Set
const arr = new Set(['a', 'b', 'c']);
for(let v of arr.keys()) {
  console.log(v)
}
// 'a' 'b' 'c'

//Map
const arr = new Map();
arr.set('a', 'a');
arr.set('b', 'b');
for(let v of arr.keys()) {
  console.log(v)
}
// 'a' 'b'

• includes
  判断数组中是否存在该元素，参数：查找的值、起始位置，可以替换 ES5 时代的 indexOf 判断方式。indexOf 判断元素是否为 NaN，会判断错误。

var a = [1, 2, 3];
a.includes(2); // true
a.includes(4); // false