js之Array常用的方法

数组不改变原数组的方法

• join，就是把 数组转换成字符串，然后给他规定个连接字符，默认的是逗号( ，)

        var arr = [1,2,3];
        console.log(arr.join()); 　　　　// 1,2,3
        console.log(arr.join("-")); 　　// 1-2-3
        console.log(arr); 　　　　　　　　// [1, 2, 3]
      

• concat() ：将参数添加到原数组中。这个方法会先创建当前数组一个副本，然后将接收到的参数添加到这个副本的末尾， 最后返回新构建的数组。
  在没有给concat()方法传递参数的情况下，它只是 复制当前数组并返回副本。
  可以用来复制一个数组，注意 若数组元素为对象类型为浅copy

      书写格式：arr.concat()，括号里面写内容  ("字符串要加引号"),
        var arr = [1,3,5,7];
        var arrCopy = arr.concat(9,[11,13]);
        console.log(arrCopy); 　　　　　　　　　　　　//[1, 3, 5, 7, 9, 11, 13]只能片平化第一层
        console.log(arr); 　　　　　　　　　　　　　　// [1, 3, 5, 7](原数组未被修改)
      

• slice()：返回从原数组中指定开始下标到结束下标之间的项组成的新数组。 slice()方法可以接受一或两个参数，即要返回项的起始和结束位置。含头不含尾 arr.slice(0)||arr.slice():相当于复制当前数据组，等价于arr.concat()

      书写格式：arr.slice( 1 , 3  )
        var arr = [1,3,5,7,9,11];
        var arrCopy = arr.slice(1);
        var arrCopy2 = arr.slice(1,4);
        var arrCopy3 = arr.slice(1,-2);
        var arrCopy4 = arr.slice(-4,-1);
        console.log(arr); 　　　　　　　　　　　　　　//[1, 3, 5, 7, 9, 11](原数组没变)
        console.log(arrCopy); 　　　　　　　　　　　 //[3, 5, 7, 9, 11]
        console.log(arrCopy2); 　　　　　　　　　　　//[3, 5, 7]
        console.log(arrCopy3); 　　　　　　　　　　　//[3, 5, 7]
        console.log(arrCopy4); 
      

改变原数组

• push(): 把里面的内容添加到数组末尾，并返回修改后的长度。
  pop()：移除数组最后一项，返回移除的那个值，减少数组的length。

          书写格式：arr.push(" ")，括号里面写内容  ("字符串要加引号"),
          书写格式：arr.pop( )
          var arr = ["Lily","lucy","Tom"];
          var count = arr.push("Jack","Sean");
          console.log(count); 　　　　　　　　　　// 5
          console.log(arr); 　　　　　　　　　　　// ["Lily", "lucy", "Tom", "Jack", "Sean"]
          var item = arr.pop();
          console.log(item); 　　　　　　　　　　 // Sean
          console.log(arr); 　　　　　　　　　　  // ["Lily", "lucy", "Tom", "Jack"]
        

• shift()：删除原数组第一项，并返回删除元素的值；如果数组为空则返回undefined
  unshift:将参数添加到原数组开头，并返回数组的长度 。

            书写格式：arr.shift(" ")，括号里面写内容  ("字符串要加引号"),
            var arr = ["Lily","lucy","Tom"];
            var count = arr.unshift("Jack","Sean");
            console.log(count); 　　　　　　　　　　　　　　// 5
            console.log(arr); 　　　　　　　　　　　　　　　//["Jack", "Sean", "Lily", "lucy", "Tom"]
            var item = arr.shift();
            console.log(item); 　　　　　　　　　　　　　　// Jack
            console.log(arr); 　　　　　　　　　　　　　　 // ["Sean", "Lily", "lucy", "Tom"]
          

• sort()：将数组里的项从小到大排序,是按照字符编码的顺序进行排序

            书写格式：arr.sort( )
            var arr1 = ["a", "d", "c", "b"];
            console.log(arr1.sort()); 　　　　　　　　　　// ["a", "b", "c", "d"]
            sort()方法比较的是字符串，没有按照数值的大小对数字进行排序，要实现这一点，就必须使用一个排序函数
            function sortNumber(a,b)
            {
            　　return a - b
            }
            arr = [13, 24, 51, 3]; console.log(arr.sort()); 　　　　　　　　　　// [13, 24, 3, 51] 
            console.log(arr.sort(sortNumber)); 　　　　// [3, 13, 24, 51](数组被改变)
            若 a 小于 b，在排序后的数组中 a 应该出现在 b 之前，则返回一个小于 0 的值。
            若 a 等于 b，则返回 0。
            若 a 大于 b，则返回一个大于 0 的值。
          

• reverse()：反转数组项的顺序。(原数组改变)

            书写格式：arr.reverse( )
            var arr = [13, 24, 51, 3];
            console.log(arr.reverse()); 　　　　　　　　//[3, 51, 24, 13]
            console.log(arr); 　　　　　　　　　　　　　　//[3, 51, 24, 13](原数组改变)
          

• splice()：删除、插入和替换。

          删除：指定 2 个参数：要删除的第一项的位置和要删除的项数。
          书写格式：arr.splice( 1 , 3  )
          
          插入：可以向指定位置插入任意数量的项，只需提供 3 个参数：起始位置、 0（要删除的项数）和要插入的项。
          书写格式：arr.splice(  2,0,4,6  )

          替换：可以向指定位置插入任意数量的项，且同时删除任意数量的项，只需指定 3 个参数：起始位置、要删除的项数和要插入的任意数量的项。插入的项数不必与删除的项数相等。
          书写格式：arr.splice(  2,0,4,6  )
          var arr = [1,3,5,7,9,11];
          var arrRemoved = arr.splice(0,2);
          console.log(arr); 　　　　　　　　　　　　　　　//[5, 7, 9, 11]
          console.log(arrRemoved); 　　　　　　　　　　　//[1, 3]
          var arrRemoved2 = arr.splice(2,0,4,6);
          console.log(arr); 　　　　　　　　　　　　　　　// [5, 7, 4, 6, 9, 11]
          console.log(arrRemoved2); 　　　　　　　　　　// []
          var arrRemoved3 = arr.splice(1,1,2,4);
          console.log(arr); 　　　　　　　　　　　　　　　// [5, 2, 4, 4, 6, 9, 11]
          console.log(arrRemoved3); 

ES6的常用方法

• indexOf()：接收两个参数：要查找的项和（可选的）表示查找起点位置的索引。其中， 从数组的开头（位置 0）开始向后查找。
  书写格式：arr.indexof( 5 )
  lastIndexOf：接收两个参数：要查找的项和（可选的）表示查找起点位置的索引。
  其中， 从数组的末尾开始向前查找。
  书写格式：arr.lastIndexOf( 5,4 )

            var arr = [1,3,5,7,7,5,3,1];
            console.log(arr.indexOf(5)); 　　　　　　//2
            console.log(arr.lastIndexOf(5)); 　　　 //5
            console.log(arr.indexOf(5,2)); 　　　　 //2
            console.log(arr.lastIndexOf(5,4)); 　　//2
            console.log(arr.indexOf("5")); 　　　　 //-1
          

• forEach()：对数组进行遍历循环，对数组中的每一项运行给定函数。这个方法没有返回值。参数都是function类型，默认有传参，参数分别为：遍历的数组内容；第对应的数组索引，数组本身。

  　　　　书写格式：arr.forEach()
          var arr = [1, 2, 3, 4, 5];
          arr.forEach(function(x, index, a){
            console.log(x + '|' + index + '|' + (a === arr));
          });
          // 输出为：
          // 1|0|true
          // 2|1|true
          // 3|2|true
          // 4|3|true
          // 5|4|true
        

• map()：指“映射”，对数组中的每一项运行给定函数，返回每次函数调用的结果组成的数组。

          书写格式：arr.map()
          var arr = [1, 2, 3, 4, 5];
          var arr2 = arr.map(function(item){
            return item*item;
          });
          console.log(arr2); 　　　　　　　　//[1, 4, 9, 16, 25]
        

• filter()：“过滤”功能，数组中的每一项运行给定函数，返回满足过滤条件组成的数组。

          书写格式：arr.filter()
          var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
          var arr2 = arr.filter(function(x, index) {
            return index % 3 === 0 || x >= 8;
          }); 
          console.log(arr2); 　　　　　　　　//[1, 4, 7, 8, 9, 10]
        

• every()：判断数组中每一项都是否满足条件，只有所有项都满足条件，才会返回true。

          书写格式：arr.every()
          var arr = [1, 2, 3, 4, 5];
          var arr2 = arr.every(function(x) {
            return x < 10;
          }); 
          console.log(arr2); 　　　　　　　　//true
          var arr3 = arr.every(function(x) {
            return x < 3;
          }); 
          console.log(arr3); 　　　　　　　　// false
        

• some()：判断数组中是否存在满足条件的项，只要有一项满足条件，就会返回true。

  　　　　书写格式：arr.some()
          var arr = [1, 2, 3, 4, 5];
          var arr2 = arr.some(function(x) {
            return x < 3;
          }); 
          console.log(arr2); 　　　　　　　　//true
          var arr3 = arr.some(function(x) {
          return x < 1;
          }); 
          console.log(arr3); 　　　　　　　　// false
        

• 简述js中 for in 与 for of 区别

          for in是ES5标准，遍历key. 也会遍历原型上的key
          for of是ES6标准，遍历value.
          例子：
          Object.prototype.objCustom = function () {}; 
          Array.prototype.arrCustom = function () {};
          
          let iterable = [3, 5, 7];
          iterable.foo = "hello";
          
          for (let i in iterable) {
            console.log(i); //  0, 1, 2, "foo", "arrCustom", "objCustom"
          }
          
          for (let i of iterable) {
            console.log(i); // 3, 5, 7
           } 
        

• 扁平化数组

          // 片平化数组
          function flatten(targetArr, resArr = []) {
            for (element of targetArr) {
              if (Array.isArray(element)) {
                flatten(element, resArr)
              } else {
                resArr.push(element)
              }
            }
          }
          //-------------------------------------
          const arr = [[0], 1, 2, [3, [4, 5]], 6]
          console.log(arr.flat(2))
          // [0, 1, 2, 3, 4, 5, 6]
          console.log(arr.flat())
          // [0, 1, 2, 3, [4, 5], 6]
          console.log(arr.flat(Infinity))
        

• 数组去重

        一、利用ES6中的 Set 方法去重
　　    注：Set为ES6新增的一个对象，允许存储任何类型（原始值或引用值）的唯一值
        console.log(...new Set(arr));　// [1,0,2,9,8,3]

        二、使用双重for循环，再利用数组的splice方法去重（ES5常用）
        var arr = [1, 5, 6, 0, 7, 3, 0, 5, 9,5,5];
             function unique(arr) {
                    for (var i = 0, len = arr.length; i < len; i++) {
                        for (var j = i + 1, len = arr.length; j < len; j++) {
                            if (arr[i] === arr[j]) {
                                arr.splice(j, 1);
                                j--;        // 每删除一个数j的值就减1
                                len--;      // j值减小时len也要相应减1（减少循环次数，节省性能）   
                            }
                        }
                    }
                    return arr;
              }
            console.log(unique(arr));       //  1, 5, 6, 0, 7, 3, 9
          三、利用数组的indexOf方法去重
            var arr =[1,-5,-4,0,-4,7,7,3];
            function unique(arr){
                var arr1 = [];       // 新建一个数组来存放arr中的值
                for(var i=0,len=arr.length; i < len; i++){
                       if(arr1.indexOf(arr[i]) === -1){
                           arr1.push(arr[i]);
                       }
                   }
                   return arr1;
                }
                console.log(unique(arr));    // 1, -5, -4, 0, 7, 3

          四、利用数组的filter方法去重
              var arr = [1,2,8,9,5,8,4,0,4];
                function unique( arr ){
                    // 如果新数组的当前元素的索引值 == 该元素在原始数组中的第一个索引，则返回当前元素
                    return arr.filter(function(item,index){
                        return arr.indexOf(item,0) === index;
                    });
                }
                console.log(unique(arr));    //  1, 2, 8, 9, 5, 4, 0