Array对象的实用方法总结

1.Array 对象

1. 静态方法

   1. Array.isArray()
      作用: 方法返回一个布尔值，表示参数是否为数组

      var arr = [1, 2, 3];
      typeof arr // "object"
      Array.isArray(arr) // true
      

   2. slice()
      作用: 用于提取目标数组的一部分，返回一个新数组，原数组不变 arr.slice(start, end); 它的第一个参数为起始位置（从0开始，会包括在返回的新数组之中），第二个参数为终止位置（但该位置的元素本身不包括在内）。如果省略第二个参数，则一直返回到原数组的最后一个成员。
      slice()没有参数，实际上等于返回一个原数组的拷贝 得到一个新的数组
      应用: 是将类似数组的对象转为真正的数组。

      Array.prototype.slice.call({ 0: 'a', 1: 'b', length: 2 })// ['a', 'b']
      Array.prototype.slice.call(document.querySelectorAll("div"));
      Array.prototype.slice.call(arguments);
      

   3. splice()

      作用:方法用于删除原数组的一部分成员，并可以在删除的位置添加新的数组成员，返回值是被删除的元素。注意，该方法会改变原数组。 arr.splice(start, count, addElement1, addElement2, …);第一个参数是删除的起始位置（从0开始），第二个参数是被删除的元素个数。如果后面还有更多的参数，则表示这些就是要被插入数组的新元素.

          //从第四个位置删除2个 并插入1跟2 
          var a = ['a', 'b', 'c', 'd', 'e', 'f'];
          a.splice(4, 2, 1, 2) // ["e", "f"]
          a // ["a", "b", "c", "d", 1, 2]
          
          //起始位置如果是负数，就表示从倒数位置开始删除。
          var a = ['a', 'b', 'c', 'd', 'e', 'f'];
          a.splice(-4, 2) // ["c", "d"]
      
          //只是单纯地插入元素，splice方法的第二个参数可以设为0
          //从第一个位置插入一个2
          var a = [1, 1, 1];
          a.splice(1, 0, 2) // []
          a // [1, 2, 1, 1]
          
          //只提供第一个参数，等同于将原数组在指定位置拆分成两个数组
          //在第二个位置拆分
          var a = [1, 2, 3, 4];
          a.splice(2) // [3, 4]
          a // [1, 2]
      

   4. map()

      作用: 方法将数组的所有成员依次传入参数函数，然后把每一次的执行结果组成一个新数组返回。

          var numbers = [1, 2, 3];
          //numbers的所有成员一次执行参数函数 ，不影响原数组
          numbers.map(function (n) {
          return n + 1;
          });
          // [2, 3, 4]
          numbers
          // [1, 2, 3]
      
          //map()方法接受一个函数作为参数。该函数调用时，map()方法向它传入三个参数：当前成员、当前位置和数组本身。
          [1, 2, 3].map(function(elem, index, arr) {
          return elem * index;
          });
          // [0, 2, 6]
          
      
          //map()方法还可以接受第二个参数，用来绑定回调函数内部的this变量
          var arr = ['a', 'b', 'c'];
      
          [1, 2].map(function (e) {
          return this[e];
          }, arr)
          //也就是说，这个this就是指代了arr,arr[1],arr[2]得到b跟c
          // ['b', 'c']
      

   5. forEach()

      如果数组遍历的目的是为了得到返回值，那么使用map()方法，否则使用forEach()方法,另外forEach无法中断执行

   6. filter()

      作用: 方法用于过滤数组成员，满足条件的成员组成一个新数组返回

          //将大于3的数组成员，作为一个新数组返回
          [1, 2, 3, 4, 5].filter(function (elem) {
              return (elem > 3);
          }) //[4,5]
          //方法的参数函数可以接受三个参数：当前成员，当前位置和整个数组。
          //法还可以接受第二个参数，用来绑定参数函数内部的this变量。
          var obj = { MAX: 3 };
          var myFilter = function (item) {
          if (item > this.MAX) return true;
          };
      
          var arr = [2, 8, 3, 4, 1, 3, 2, 9];
          arr.filter(myFilter, obj) // [8, 4, 9]
      

   7. some()，every()

      它们接受一个函数作为参数，所有数组成员依次执行该函数。该函数接受三个参数：当前成员、当前位置和整个数组，然后返回一个布尔值

   8. reduce() , reduceRight()
      作用:reduce()方法和reduceRight()方法依次处理数组的每个成员，最终累计为一个值。它们的差别是，reduce()是从左到右处理（从第一个成员到最后一个成员），reduceRight()则是从右到左（从最后一个成员到第一个成员），其他完全一样。

      [1, 2, 3, 4, 5].reduce(function (a, b) {
          console.log(a, b);
          return a + b;
      })
      // 1 2
      // 3 3
      // 6 4
      // 10 5
      //最后结果：15
      //第一次执行：a是数组的第一个成员1，b是数组的第二个成员2。
      //第二次执行：a为上一轮的返回值3，b为第三个成员3。
      //第三次执行：a为上一轮的返回值6，b为第四个成员4。
      //第四次执行：a为上一轮返回值10，b为第五个成员5。至此
      //所有成员遍历完成，整个方法的返回值就是最后一轮的返回值15。
      [1, 2, 3, 4, 5].reduce(function (
          a,   // 累积变量，必须
          b,   // 当前变量，必须
          i,   // 当前位置，可选
          arr  // 原数组，可选
      ) {
          // ... ...
      //要对累积变量指定初值
      [1, 2, 3, 4, 5].reduce(function (a, b) {
          return a + b;
      }, 10);
      // 10 +  1+2+3+4+5  
      //25
      
      function subtract(prev, cur) {
          return prev - cur;
      }
      
      [3, 2, 1].reduce(subtract) // 0
      [3, 2, 1].reduceRight(subtract) // -4
      //实际上可以用来做一些遍历相关的操作
      function findLongest(entries) {
          return entries.reduce(function (longest, entry) {
              return entry.length > longest.length ? entry : longest;
          }, '');
      }
      
      findLongest(['aaa', 'bb', 'c']) // "aaa"
      
      

   9. indexOf() , lastIndexOf

      作用: 方法返回给定元素在数组中第一次出现的位置，如果没有出现则返回-1.

          var a = ['a', 'b', 'c'];
      
          a.indexOf('b') // 1
          a.indexOf('y') // -1
      
          //indexOf方法还可以接受第二个参数，表示搜索的开始位置
          ['a', 'b', 'c'].indexOf('a', 1) // -1
      
          //lastIndexOf方法返回给定元素在数组中最后一次出现的位置，如果没有出现则返回-1    
          var a = [2, 5, 9, 2];
          a.lastIndexOf(2) // 3
          a.lastIndexOf(7) // -1
      
      

   10. 链式使用

           var users = [
               {name: 'tom', email: 'tom@example.com'},
               {name: 'peter', email: 'peter@example.com'}
           ];
       
           users.map(function (user) {
           return user.email;
           }).filter(function (email) {
           return /^t/.test(email);
           }).forEach(function (email) {
           console.log(email);
           });
       
           //map先产生一个email的数组，接下来 filter 过滤出以t开头的 Email 地址 ,然后 forEach 遍历输出出来