JS数组常用的方法

文章的原始链接

创建一个数组：

      // 字面量方式：
      // 这个方法也是我们最常用的，在舒适化数组的时候相当方便
      var aa = [3, 11, 8];
      // 构造器
      // 实际上 new Array === Array,加不加new 没有影响
      var a = Array(); // []
      var ab = Array(3); //[,,]
      var b = Array(1, 2, 3); //[1, 2, 3]

1、ES6 Array.of() 返回由所有数值组成的数组

定义：返回由所有参数值组成的数组，如果没有参数，就返回一个空数组。
目的：Array.of() 出现的目的是为了解决上述构造器因参数个数不同，导致的行为有差异的问题。

 let a = Array.of(3, 11, 8);
      console.log(a); //[3, 11, 8]
      let b = Array.of(3);
      console.log(b); //[3]
      let c = Array.of();
      console.log(c); //[]

2、ES6 Arrary.from() 方法

Array.from()方法就是将一个类数组对象或者可遍历对象转换成一个真正的数组。
那么什么是类数组对象呢？所谓的类数组对象，最基本的要求就是具有length属性的对象。

1）将类数组对象转换为真正的数组。

let arrayLike = {
        0: "yy",
        1: "65",
        2: ["yy", "dd"],
        length: 3,
      };
      let arr = Array.from(arrayLike);
      console.log(arr); //['yy', '65', ["yy", "dd"]]

注释：如果将上面代码中的length属性去掉，那么会是一个长度为0的空数组。

尝试将对象的属性名修改为非数字类型，如下：

let arrayLike = {
        yy: "yy",
        ff: "65",
        dd: ["yy", "dd"],
        length: 3,
      };
      let arr = Array.from(arrayLike);
      console.log(arr); //[undefined, undefined, undefined]

所以，根据上面的尝试结果可得：要将一个类数组对象转换为一个真正的数组，必须具备以下条件：

1. 该类数组对象必须有length属性，用于指定数组的长度。如果没有length，那么转换后的数组是一个空数组。
2. 该类数组对象的属性名必须为数值型或者字符串类型的数字。
PS：该类数组对象的属性名可以加引号，也可不加

2）将set解构的数据转换为真正的数组

 let arr = new Set(Array.of(2, 3, 4));
      console.log(Array.from(arr)); //[2, 3, 4]

Array.from 还可以接收第二个参数，作用类似于数组的map方法，用于对每个元素进行处理，将处理后的值放入返回的数组。

     let arr = new Set(Array.of(2, 3, 4));
      let arr1 = Array.from(arr, (item) => item + 1);
      console.log(arr1); // [3, 4, 5]

3）将字符串转换为数组

let str = "tytyty";
      console.log(Array.from(str)); //['t', 'y', 't', 'y', 't', 'y']

一、改变数组的方法（9个）

注意：对于能够改变原数组的方法，要注意避免在循环遍历中改变数组的选项，比如：改变数组的长度，导致遍历的长度出现问题。

let a =[1,2,3];
      ES5:
      a.splice()/ a.sort()/ a.pop()/ a.shift()/ a.push()/ a.unshift()/ a.reverse()
      ES6:
      a.copyWithin()/ a.fill()

1、splice() 添加/删除元素

定义：splice() 方法从数组中添加和删除项目，然后返回被删除的项目。
语法：array.splice(index,howmany,item1,.....,itemX)
参数：

1. index : 必须。整数，规定添加/删除项目的位置，使用负数可以从数组结尾处规定位置。
2. howmany：可选。要删除的项目数量。如果设置为0，则不会删除项目。
3. item1,…,itemX：可选。向数组添加项目

1）删除元素

let a = [1, 2, 4, 12];
      let item = a.splice(0, 2);
      console.log(item, a); //[1, 2]  [4, 12]

      // 从数组下标0开始，删除3个元素
      let items = a.splice(-1, 1);
      console.log(items, a); //[12] [4]
      // 从数组的最后一个元素开始删除，正向数一个元素，删除12，a内剩余4

2）删除并添加元素

let a = [1, 2, 3, 4, 5, 7, 8];
      // 从数组下标0开始删除3个元素，同时添加一项
      let item = a.splice(0, 3, "添加1项"); //[1,2,3]
      console.log(a); //['添加1项', 4, 5, 7, 8]

      let b = [1, 2, 3, 4, 5, 7, 8];
      // 从数组的最后的第三个元素开始删除3个元素，同时添加一项
      let bItem = b.splice(-3, 3, "添加一项"); //[5, 7, 8]
      console.log(b); //[1, 2, 3, 4, '添加一项']

3）不删除只添加元素

let a = [1, 2, 3, 4, 5, 7, 8];
      let item = a.splice(0, 0, "添加1项");
      console.log(a); //['添加1项', 1, 2, 3, 4, 5, 7, 8]

      let b = [1, 2, 3, 4, 5, 7, 8];
      let bItem = b.splice(-3, 0, "添加一项"); //
      console.log(b); //[1, 2, 3, 4, '添加一项', 5, 7, 8]

2、sort() 排序

定义：sort()方法对数组元素进行排序，并返回这个数组
参数可选：规定排序顺序的比较函数
默认情况下sort()方法没有传比较函数，则默认按照字母升序，如果元素不是字符串，那么该方法会调用toString()方法将元素转化为字符串的Unicode（万国码）位点，然后再比较字符。

// 字符串排列 看起来很正常
      var a = ["Banana", "Orange", "Apple", "Mango"];
      a.sort(); // ["Apple","Banana","Mango","Orange"]
      // 数字排序的时候 因为转换成Unicode字符串之后，有些数字会比较大会排在后面 这显然不是我们想要的
      var a = [10, 1, 3, 20, 25, 8];
      console.log(a.sort()); // [1,10,20,25,3,8];

1）数组元素为数组时的升序和降序

var arr = [10, 1, 3, 4, 20, 4, 25, 8];
      // 升序 a-b <0  a将排在b的前面，按照a的大小进行排序
      console.log(arr.sort((a, b) => a - b)); //[1, 3, 4, 4, 8, 10, 20, 25]
     
      console.log(arr.sort((a, b) => b - a)); //[25, 20, 10, 8, 4, 4, 3, 1]

2）数组多条件排序

var arr = [
        { id: 10, age: 2 },
        { id: 5, age: 4 },
        { id: 6, age: 10 },
        { id: 9, age: 6 },
        { id: 2, age: 8 },
        { id: 10, age: 9 },
      ];
      arr.sort((a, b) => {
        if (a.id === b.id) {
          // 如果id相同，则按照age的降序排序
          return b.age - a.age;
        } else {
          // 如果id不相等，则按照id的升序排序
          return a.id - b.id;
        }
      });
      console.log(arr); //[{"id":2,"age":8},{"id":5,"age":4},{"id":6,"age":10},{"id":9,"age":6},{"id":10,"age":9},{"id":10,"age":2}]

3、pop()删除数组中最后一个元素

定义：pop()方法删除一个数组中的最后一个元素，并且返回这个元素
参数：无

  let a = [1, 2, 3];
      a.pop();
      console.log(a); //[1,2]

4、push()向数组的末尾添加元素

定义：push()方法可向数组的末尾添加元素，并返回新的长度
参数：item1, item2, …, itemX ,要添加到数组末尾的元素

 let a = [1, 2, 3];
      let item = a.push("添加");
      console.log(a, "item是" + item); //[1, 2, 3, '添加'] 'item是4'

5、shift()删除数组的第一个元素

定义：shift()方法删除数组的第一个元素，并返回这个元素。
参数：无

 let a = [1, 2, 3];
      let item = a.shift(); //1
      console.log(a); //[2, 3]

6、unshift()

定义：unshift()方法可以向数组的开头添加一个或者更多的元素，并返回新的长度。
参数：item1, item2, …, itemX ,要添加到数组开头的元素

      let a = [1, 2, 3];
      let item = a.unshift("添加"); //4
      console.log(a); //['添加', 1, 2, 3]

7、reverse()颠倒数组中元素的顺序

定义：reverse()方法用于颠倒数组中元素的顺序，返回颠倒的数组
参数：无

let a = [1, 2, 4];
      console.log(a.reverse()); // [4, 2, 1]

8、copyWithin()指定位置的成员复制到其他位置

定义：在当前数组内部，将指定位置的成员复制到其他位置，并返回这个数组
语法： array.copyWithin(target, start = 0, end = this.length)
参数：三个参数都是数值，如果不是，将自动转为数值。

1. target（必须）：从该位置开始替换数据，如果为负值，表示倒数。
2. start（可选）：从该位置开始读取数据，默认为0。如果为负值，表示倒数。
3. end（可选）：到该位置前停止读取数据，默认等于数组长度。使用负数可从数组结尾处规定位置。
   浏览器兼容(MDN): chrome 45,Edge 12,Firefox32,Opera 32,Safari 9, IE 不支持

 var arr = [1, 2, 3, 4, 5];
      arr.copyWithin(0, -2, -1);
      console.log(arr); //[4, 2, 3, 4, 5]

      var a=['OB1','Koro1','OB2','Koro2','OB3','Koro3','OB4','Koro4','OB5','Koro5']
      console.log(a.copyWithin(2,3,5)) //['OB1', 'Koro1', 'Koro2', 'OB3', 'OB3', 'Koro3', 'OB4', 'Koro4', 'OB5', 'Koro5']

从上面的实例中可得：

1. 第一个参数是开始被替换的元素位置。
2. 要替换数据的位置范围：从第二个参数是开始读取的元素，在第三个参数前面一个元素停止读取
3. 数组的长度不会改变
4. 读了几个元素就从开始被替换的地方替换这几个元素。

9、fill()填充数组

定义：fill()方法用于将一个固定值替换数组的元素。
语法：array.fill(value, start, end)
参数：
value：，必须，要填充数组的值。
start：可选，填充的开始位置，默认值为0；
end：可选，停止填充位置 (默认为 array.length)

 var arr = ["Banana", "Orange", "Apple", "Mango"];
      console.log(arr.fill("Runoob", 2, 4)); //['Banana', 'Orange', 'Runoob', 'Runoob']

二、不改变数组的方法（8个）

 let arr =[2,3,4,5,6]
      ES5: 
      arr.slice()/ arr.join()/ arr.toLocaleString()/ arr.toString()/ arr.concat()/ arr.indexOf()/ arr.lastIndexOf()
      ES7:
      arr.includes()

1、slice() 浅拷贝数组的元素

定义：方法返回一个从开始到结束（不包括结束）选择的数组的一部分浅拷贝到一个新数组对象，且原数组不会被修改。
注意：字符串也有一个slice()方法用来提取字符串，不要弄混。
语法： array.slice(begin, end);
参数：
begin(可选)：索引数值，接受负值，从该索引处开始提取原数组中的元素，默认值为0。
end(可选)：索引数值（不包括），接受负值，在该索引处前结束原数组元素，默认值为数组末尾（包括最后一个元素）。

 let a = ["hello", "word"];
      let b = a.slice(0, 1);
      a[0] = "替换";
      console.log(b, a); //['hello']  ['替换', 'word']

如上：新数组是浅拷贝的，元素是简单数据类型，改变之后不会互相干扰。

如果是复杂数据类型（对象，数组）的话，改变其中一个，另外一个也会改变。

let a = [{ name: "OBKorao1" }];
      let b = a.slice();
      console.log(b, a); //[{ name: "OBKorao1" }]  [{ name: "OBKorao1" }]

      a[0].name = "改变原数组的value";
      console.log(a, b); //[{"name":"改变原数组的value"}] [{"name":"改变原数组的value"}]

      (b[0].name = "改变拷贝数组"), (b[0].koro = "改变拷贝数组");
      console.log(a, b); //[{"name":"改变拷贝数组","koro":"改变拷贝数组"}]  [{"name":"改变拷贝数组","koro":"改变拷贝数组"}]

2、join()数组转字符串

定义：join()方法用于把数组中的所有元素通过指定的分隔符进行分隔放入一个字符串，返回生成的字符串。
语法：array.join(str)
参数：str(可选)：指定要使用的分隔符，默认使用逗号作为分隔符。

let a = ["hello", "word"];
      let str = a.join();
      let str2 = a.join("+");
      console.log(str, str2); //hello,word    hello+word

使用join()方法或者下文说到的toString()方法时，当数组中的元素也是数组或者是对象时会出现什么情况？

     let a = [["OBkoro1", "23"], "test"];
      console.log(a.join()); //OBkoro1,23,test
      console.log(a.toString());//OBkoro1,23,test
      let b = [{ name: "OBkoro1", age: "23" }, "test"];
      console.log(b.join()); //[object Object],test
      console.log(b.toString()); //[object Object],test

根据上面代码可得：join()/toString()方法在数组元素是数组时，会将里面的数组也调用。但是如果是对象的话，对象会被转为[object object]字符串。

3、toLocaleString()数组转字符串

定义：返回一个表示数组元素的字符串。该字符串由数组中的每个元素的toLocaleString()返回值经调用join()方法连接（由逗号隔开）组成。
语法： array.toLocaleString()
参数：无

     let a = [{ name: "OBKoro1" }, 23, "abcd", new Date()];
      let str = a.toLocaleString(); // 
      console.log(str);//[object Object],23,abcd,2018/5/28 下午1:52:20
      console.log(a.join()); //[object Object],23,abcd,Thu Oct 14 2021 15:03:11 GMT+0800 (中国标准时间)

如上代码：调用数组的toLocaleString()方法，数组中的每个元素都会调用自身的toLocaleString()方法，对象调用对象的toLocaleString()，Date调用Date的toLocaleString()。

4、toString()数组转字符串

定义：toString()方法可把数组转换为由逗号链接的字符串
语法：array.toString()
参数：无
该方法的效果和join方法一样，都是由于数组转字符串的，但是与join()方法相比没有优势，也不能自定义字符串的分隔符。

注意：当数组和字符串操作时，JS会盗调用这个方法将数组自动转为字符串。

      let b = ["toString", "演示"].toString();
      console.log(b); //toString,演示
      let a = ["toString", "演示"] + "再次演示";
      console.log(a); //toString,演示再次演示

5、concat()

定义：方法用于合并两个或多个数组，返回一个新的数组。
语法：var newArr =oldArray.concat(arrayX,arrayX,......,arrayX)
参数：arrayX（必须）：该参数可以是具体的值，也可以是数组对象。可以是任意多个

let a = [1, 2, 3];
      let b = [4, 5, 6];
      // 连接两个数组
      let newArr = a.concat(b);
      // 连接三个数组
      let c = [7, 8, 9];
      let newArray2 = a.concat(b, c);
      // 添加元素
      let newArray3 = a.concat("添加元素", b, c, "末尾项");
      console.log(newArr, newArray2, newArray3);//[1, 2, 3, 4, 5, 6] [1, 2, 3, 4, 5, 6, 7, 8, 9] [1, 2, 3, '添加元素', 4, 5, 6, 7, 8, 9, '末尾项']
  

扩展： ES6扩展运算符...合并数组。
因为ES6的语法更简洁易懂，所以现在合并数组采用...处理，...运算符可以实现cancat的每个栗子，且简洁具有高度自定义数组元素位置的效果。

6、indexOf()查找数组是否存在某个元素，返回下标。

定义：返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1.
语法： array.indexOf(searchElement,fromIndex)
参数：
searchElement(必须)：被查找的元素
fromIndex(可选)：开始查找的位置（不能大于等于数组的长度，返回-1），接受负值，默认值为0。

严格相等的搜索：
数组的indexOf搜索跟字符串的indexOf不一样，数组的indexOf使用严格相等===搜索元素，即数组元素要完全匹配才能搜索成功。

注意：indexOf()不能识别NaN。

let a = ["拉拉", 2, 4, 24, NaN];
      console.log(a.indexOf("拉拉")); //0
      console.log(a.indexOf(NaN)); //-1
      console.log(a.indexOf(2)); //1

7、lastIndexOf()查找指定元素在数组中的最后一个位置

定义：方法返回指定元素，在数组中的最后一个索引，如果不存在则返回-1.
语法： arr.lastIndexOf(searchElement,fromIndex)
参数：
searchElement(必须)：被查找的元素
fromIndex(可选)：逆向查找开始位置，默认值数组的长度-1，即查找整个数组。
关于fromIndex的三个规则：

1. 正值：如果该值大于或等于数组的长度，则整个数组会被查找。
2. 负值：将其视为从数组末尾向前的偏移。（例如-2，从数组最后第二个元素开始往前查找）
3. 负值：其绝对值大于数组长度，则方法返回-1，即数组内元素不会被查找。

      let a = [1, 2, 3, 4, 5, 6, 6];  //length=7
      console.log(a.lastIndexOf(3, 4)); //2   从下标4开始往前查找
      console.log(a.lastIndexOf(3, 100)); //2  大于或等于数组的长度，则查找整个数组
      console.log(a.lastIndexOf(3, -8)); //-1  -8的绝对值大于数组的长度，则返回-1
      console.log(a.lastIndexOf(3, -5)); //2  从第三个元素往前查找，返回2

8、 includes()查找数组是否包含某个元素，返回布尔值

定义：返回一个布尔值，表示某个数组是否包含给定的值
语法：array.includes(searchElement,fromIndex=0)
参数：
searchElement(必须)：被查找的元素。
fromIndex(可选)：默认为0，参数表示搜索的起始位置，接受负值。正值超过数组长度，数组不会被搜索，返回false。负值绝对值超过数组的长度，重置从0开始搜素。

includes()方法是为了弥补indexOf()方法的缺陷而出现的：

1. indexOf()方法不能识别NaN
2. indexOf()方法检查是否包含某个值不够语义化，需要与-1进行判断，表达不够直观。

      let a = ["one", "two", NaN];
      console.log(a.includes(NaN)); //true
      console.log(a.includes("two", 100)); //fasle 超过数组的长度，不搜索
      console.log(a.includes("two", -3)); // true 从倒数第三个元素开始搜搜
      console.log(a.includes("two", -100)); // true 赋值的绝对值超过数组长度，则搜索真个数组

三、 遍历方法（12个）

JS中遍历数组并不会改变原始数组的方法共12个：

        let a = [1,2,3];
        ES5:
        a.forEach()/ a.every()/ a.some()/ a.filter()/ a.map()/ a.reduce()/ a.reduceRight()
        ES6:
        a.find()/ a.findIndex()/ a.keys()/ a.values()/ a.entries()

1、forEach

定义：按升序为数组中含有效值得每一项执行一次回调函数。
语法：array.forEach(function(currentValue, index, arr), thisValue)
参数：
function(必须)：数组中每个元素需要调用的函数。

//回调函数的参数
 1. currentValue(必须)：数组当前元素的值
 2. index(可选)：当前元素的索引值
 3. arr(可选)：数组对象本身

thisValue(可选): 当执行回调函数时this绑定对象的值，默认值为undefined

关于forEach()需要知道的知识：

• 无法中途退出循环，只能用return退出本次回调，进行下一次回调。
• 它总是返回undefined值，即使return了一个值。

下面类似语法同样使用这些规则：

1. 对于空数组是不会执行回调函数的。
2. 对于已在迭代过程中删除的元素，或则空元素会跳过回调函数。
3. 遍历次数在第一次循环前就会确定，再添加到数组中的元素不会被遍历。
4. 如果已经存在的值被改变，则传值给callback的值是遍历到他们那一刻的值。

      let a = [1, 2, , 4]; //倒数第二个元素是空的，不会遍历（undefined、null 会遍历）
      let obj = { name: "yuyu" };
      let result = a.forEach(function (value, index, array) {
        a[3] = "添加元素";
        a.push("添加到尾部，但是不会被遍历到");
        console.log(value); //分别打印 1,2,添加元素
        console.log(this.name); //yuyu被打印三次
        // break; //break会报错
        return value; //return只能结束本次回调 会执行下次的回调
        console.log("不会被执行，因为return会执行下一次循环回调");
      }, obj);
      console.log(result); //虽然froEach写了return,但是forEach无返回值，所以为undefined

2、map() 对数组中的每个元素进行处理，返回新的数组

定义：创建一个新的数组，数组中的元素为原始数组元素调用函数处理后的值。
语法： let new_array = arr.map(function(currentValue, index, arr), thisArg)
参数：
function(必须)：数组中每个元素需要调用的函数。

//回调函数的参数
 1. currentValue(必须)：数组当前元素的值
 2. index(可选)：当前元素的索引值
 3. arr(可选)：数组对象本身

thisValue(可选)：当执行回调函数时this绑定对象的值，默认值为undefined

let a = ['1','2','3','4'];
let result = a.map(function (value, index, array) {
  return value + '新数组的新元素'
});
console.log(result, a); 
// ["1新数组的新元素","2新数组的新元素","3新数组的新元素","4新数组的新元素"] ["1","2","3","4"]

3、every()检测数组所有元素是否都符合判断条件

定义：方法用于检测数组所有元素是否都符合函数定义的条件
语法：array.every(function(currentValue, index, arr), thisValue)
参数：
function(必须)：数组中每个元素需要调用的函数

//回调函数的参数
 1. currentValue(必须)：数组当前元素的值
 2. index(可选)：当前元素的索引值
 3. arr(可选)：数组对象本身

thisValue(可选): 当执行回调函数时this绑定对象的值，默认值为undefined

方法返回值规则：

1. 如果数组中检测到有一个元素不满足条件，则整个表达式返回false，且剩余的元素不会再进行检测。
2. 如果所有元素都满足条件，则返回true.

      console.log([23, 24, 25, 6].every((item) => item > 10)); //false
      console.log([23, 24, 25, 16].every((item) => item > 10)); //true

4、some()数组中的元素是否满足判断条件的元素。

定义：数组中的是否有满足判断条件的元素。
语法：array.some(function(currentValue, index, arr), thisValue)

function(必须)：数组中每个元素需要调用的函数

//回调函数的参数
 1. currentValue(必须)：数组当前元素的值
 2. index(可选)：当前元素的索引值
 3. arr(可选)：数组对象本身

thisValue(可选): 当执行回调函数时this绑定对象的值，默认值为undefined

方法返回值规则：

1. 如果有一个元素满足条件，则表达式返回true，剩余的元素不会再执行检测。
2. 如果没有满足条件的元素，则返回false。

      console.log([23, 24, 25, 6].some((item) => item > 10)); //true
      console.log([23, 24, 25, 16].some((item) => item > 100)); //false

5、filter()过滤原始数组，返回新数组

定义：返回一个新数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。
语法：let new_array = arr.filter(function(currentValue, index, arr), thisArg)
参数：
function(必须)：数组中每个元素需要调用的函数。

//回调函数的参数
 1. currentValue(必须)：数组当前元素的值
 2. index(可选)：当前元素的索引值
 3. arr(可选)：数组对象本身

thisValue(可选): 当执行回调函数时this绑定对象的值，默认值为undefined

      let arr = [12, 1, 14, 15];
      console.log(
        arr.filter((item) => item > 10), //[12, 14, 15]
        arr //[12, 1, 14, 15]
      );

6、reduce()为数组提供累加器，合并为一个值。

定义：reduce()方法对累加器和数组中的每个元素（从左到右）应用一个函数，最终合并为一个值。
语法：array.reduce(function(total, currentValue, currentIndex, arr), initialValue)
参数：
function(必须)：数组中每个元素需要调用的函数。

//回调函数的参数
 1. total(必须)：初始值，或者上一次调用回调返回的值。
 2. currentValue(必须)：数组当前元素的值。
 3. currentIndex(可选)：当前元素的索引值。
 4. arr(可选)：数组对象本身

initialValue(可选): 指定第一次回调 的第一个参数。

回调第一次执行时：

1. 如果initialValue在调用reduce时被提供，那么第一个total将等于initialValue，此时的currentValue等于数组中的第一个值。
2. 如果initialValue未被提供，那么第一个total等于数组中的第一个值，currentValue等于数组中的第二个值。此时如果数组为空，那么将抛出TypeError。
3. 如果数组仅有一个元素，并且没有提供initialValue，或者提供了initialValue但数组为空，那么回调不会被执行，数组内唯一值将被返回。

//数组求和
 let sum = [0, 1, 2, 3].reduce(function (a, b) {
        console.log(a, b);
        return a + b;
      }, 0); //initialValue 已提供，所以依次打印的a和b分别是：0,0  0,1  1,2  3,3
      console.log(sum); //6
 //将二维数组转化为一维数组 将数组展开
  let flattened = [
        [0, 1],
        [2, 3],
        [4, 5],
      ].reduce((acc, cur) => {
        console.log(acc, cur); //依次打印的acc和cur分别是：[0, 1]  [2, 3]; [0, 1, 2, 3] [4, 5];
        return acc.concat(cur);
      }); //initialValue 未提供，所以初始的acc=[0, 1] cur= [2, 3]
      console.log(flattened); //[0, 1, 2, 3, 4, 5]

7、reduceRight() 从右至左累加

定义：reduceRight()方法的功能和reduce()功能是一样的，不同的是reduceRight()从数组的末尾向前将数组中的数组项做累加。
语法：array.reduceRight(function(total, currentValue, currentIndex, arr), initialValue)
注意：reduce()对于空数组是不会执行回调函数。
参数：
function(必须)：数组中每个元素需要调用的函数。

//回调函数的参数
 1. total(必须)：初始值，或者上一次调用回调返回的值。
 2. currentValue(必须)：数组当前元素的值。
 3. currentIndex(可选)：当前元素的索引值。
 4. arr(可选)：数组对象本身

initialValue(可选): 指定第一次回调 的第一个参数。

      let arr = [2, 45, 30, 100];
      console.log(arr.reduceRight((a, b) => a - b)); //23

8和9、find()&findIndex()根据条件找到数组成员

find()定义：用于找出第一个符合条件的数组成员，并返回该成员，如果没有符合条件的成员，则返回undefined。
findIndex()定义：返回第一个符合条件数组成员的位置，如果所有成员都不符合条件，则返回-1.
语法： let new_array = arr.find(function(currentValue, index, arr), thisArg)
let new_array = arr.findIndex(function(currentValue, index, arr), thisArg)
参数：
function(必须)：数组中每个元素需要调用的函数。

//回调函数的参数
 1. currentValue(必须)：数组当前元素的值
 2. index(可选)：当前元素的索引值
 3. arr(可选)：数组对象本身

thisValue(可选): 当执行回调函数时this绑定对象的值，默认值为undefined

find()和findIndex()都可以识别NaN，弥补indexOf()的不足

      // find
      let a = [1, 4, 5, 10].find((item) => item > 4);//5
      let b = [1, 4, 5, 10, NaN].find((item) => Object.is(NaN, item));//NaN
      
      // findIndex
      let a = [1, 4, 5, 10].findIndex((item) => item > 4); //2
      let b = [1, 4, 5, 10, NaN].findIndex((item) => Object.is(NaN, item)); //4

10 11 12、keys()&values()&entries()遍历键名，遍历键值、遍历健名+键值。

定义：三个方法都返回一个新的Array iterator 对象，对象根据方法不同包含不同的值。
语法：

    array.keys()
    array.values()
    array.entries()

参数：无。