数组常用的方法总结二

二维数组、以及二维数组的排序

    var arrone = [[1,2],[3,4],[8,9]];

    for(var i = 0;i<arrone.length;i++){

          for(var j = 0;j<arrone[i].length;j++){

              alert(arrone[i][j]);//1,2,3,4,8,9

          }

    }
     //二维数组的含义及调用大致如上

     //二维数组的排序

        arrone.sort(function(a,b){

            return b[1] - a[1];

        })

        console.log(arrone);//[[8,9],[3,4],[1,2]]

在一个顺序一定的数组中插入某个新元素不改变原有排列顺序

    var arr = [1,2,3,4,5];

    function addsomeone(arrname,some){

          var index = arrname.length;

          for(var i = 0;i<arrname.length;i++){

              if(arrname[i]>some){

                    index = i;

                    break;//满足此条件则跳出

            }
        }

    arrname.splice(index,0,some)

    return arrname

    }

   //arr调用函数addsomeone

  alert(addsomeone(arr,8));

  alert(addsomeone(arr,2));

数组的join和toString的区别

    var arr = [1,2,4,5,8];

    console.log(arr.join(':'))//1:2:4:5:8

    console.log(arr.join());//1,2,4,5,8

    console.log(arr.toString());//1,2,4,5,8

    //都是将数组转化为字符串，略有差别(join可以添加分隔符，而toString不可以)，如上

数组的冒泡排序的原理和实例

将数组从小到大的顺序排列,使用数组的sort的排序方式

    var arr = [1,3,5,2,8,10,6];

    arr.sort(function(a,b){

    return a-b

    })

    console.log(arr);//[1,2,3,5,6,8,10]

使用冒泡排序的方式进行排列(升序)

    var arrone = [2,67,32,12,3,7,9,5];
    //1、外层循环：控制轮数，从0开始，到array.length-1结束
    for(var i = 0;i<arrone.length-1;i++){
          //2、内层循环：控制每轮需比较次数（轮数每+1，该轮需比较次数-1）
          for(var j = 0;j<=arrone.length-1-i;j++){

          //此处若为小于号则为降序排列

              if(arrone[j]>arrone[j+1]){

                  var temp = arrone[j];

                  arrone[j] = arrone[j+1];

                arrone[j+1] = temp;

              }

        }

    }

    console.log(arrone);

将以上方法进行封装

 function paixu(arrname){
    for(var i = 0;i<arrname.length-1;i++){
        for(var j = 0;j<=arrname.length-1-i;j++){
          //此处若为小于号则为降序排列
              if(arrname[j]>arrname[j+1]){
                    var temp = arrname[j];
                    arrname[j] = arrname[j+1];
                    arrname[j+1] = temp;
               }
        }
     }
     return arrname
  }
    var arrfirst = [9,6,7,10,2,5,6,1];

    var arrsecond = [58,98,14,25,30,66];

    var firstarr = paixu(arrfirst);

    var secondarr = paixu(arrsecond);

    console.log(firstarr);//[1,2,5,6,6,7,9,10]

    console.log(secondarr);//[14,25,30,58,66,98]

冒泡排序原理图

1516130611_8752.jpg 1516130611_9640.jpg 1516130611_9545.jpg 1516130612_2532.jpg

数组的去重

方式一

   var arrone = [2,3,3,5,6,12,12,34,5,34];

  //判断一个数组里是否包含某元素

    function hassome(arrname,someone){

        for(var i = 0;i<arrname.length;i++){

            if(arrname[i] == someone){

              return true

            }

        }

        return false

      }

      //数组调用方法

      alert(hassome(arrone,34))

      //数组去重方式1，利用以上函数

      var arrtwo = [1,3,5,5,6,8,2,1];

      function delrepeat(arrtwo){

        var res = [];

        for(var i = 0;i<arrtwo.length;i++){

            if(!hassome(res,arrtwo[i])){

              res.push(arrtwo[i])

            }

        }

        return res;

      }

      alert(delrepeat(arrtwo));

方式二 ——利用排序规则

var arrthree = [1,4,2,8,5,3,6,5,3,2,1];

      function delrepeattwo(arrthree){

        var resarr = [];

        var arranother = arrthree.sort(function(a,b){

            return a-b

        });

        for(var i = 0;i<arranother.length;i++){

            if(arranother[i]!=arranother[i+1]){

              resarr.push(arranother[i])

            }

        }

        return resarr

      }

      //用数组调用以上函数

      alert(delrepeattwo(arrthree));

      //实现了排序和去重

方式三 ——ES6——new Set方法

var myArray = [1,1,2,2,3,3,4,4,5,5]
console.log([...new Set(myArray )]);// [1, 2, 3, 4, 5]
//得到的是set类数组结构
Array.from（该方法可以将 Set 结构转为数组）
function dedupe(array) {
  return Array.from(new Set(array));
}
dedupe([1, 1, 2, 3]) // [1, 2, 3]