编程语言
首页 > 编程语言> > JavaScript的Array知识汇总

JavaScript的Array知识汇总

作者：互联网

JavaScript的Array知识汇总

2018-07-01

JavaScript的Array知识汇总:包括数组基本操作，以及一些数组去重、冒泡排序、快速排序的一些实现思路

数组中常用方法

数组求和

1
2
3
4
5
6
7
8
9
 
/*  已之数组中每一项都是数字，实现数组求和*/
 //循环事件
   var total = null
   for (var i = 0; i < arr1.length; i++) {
       total+= arr[i]
   }
   //join求和
  var total = eval(arr1.join('+'))
  // -> eval:把字符串变为js表达式执行

数组中的排列和排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
 /*  reverse:把数组中的每一项倒过来排列
 *  参数：无
 *  返回值：排序后的数组
 *  原数组发生改变
 */
 var arr = [1,2,3,4,5,6]
 arr.reverse()// [6, 5, 4, 3, 2, 1]

/*  sort 实现数组的排序
 *  参数：无或者callback
 *  返回值：排序后的数组
 *  原数组发生改变
 *
 * 不传递参数的情况下：可以给10以内的数字升序排列，超过10的就无法处理（多位数只识别第一位）
 * var arr1 = [1,22,33,4,52,6]
 * console.log(arr1.sort()) //[1, 22, 33, 4, 52, 6]
 * //传参的情况下
 *  arr.sort(function(a.b){
 *      return a - b //->升序
 *      return b - a //->降序
 *  })
 *  sort的主体原理 记得查一下
 */

验证数组是否包含某一项

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
/*
 *  indexOf / lastIndexOf:获取当前项在数组中第一次或者最后一次出现的位置的索引
 *  数组中这两个方法在 IE6-8中不兼容
 *  字符串中的这两个方法是兼容所有的浏览器 包括IE6-8
 *
 *  如果当前数组中并没有这一项返回的索引是-1，我们根据这一点可以验证数组是否包含这一项
 */
 if(arr.indexOf(12)>-1){
     //->数组中包含12
 }

 //兼容写法
  Array.prototype.myIndexOf = function myIndexOf(value){
       var result = -1;
       //指调用此方法的数组
       for (var i = 0; i < this.length; i++) {
           if(value === this[i]){
               result = i;
               break
           }
       }
       return result
   }
  arr.myIndexOf(12)

遍历数组的一些方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
 //->以下方法在IE6-8都不兼容


/*
 * forEach：遍历数组中的每一项
 */
  arr.forEach(function(value,index){
      //->数组中有多少项，当前回调函数执行多少次：
      //每一次传递进来的value就是当前遍历数组这一项的值 index为这一项的索引
  })

  /*
  * map：遍历数组中的每一项，在forEach的基础上可以修改每一项的值
  */
   arr.map(function(value,index){
       //->数组中有多少项，当前回调函数执行多少次：
       //每一次传递进来的value就是当前遍历数组这一项的值 index为这一项的索引
       return XXX //->RETURN后面返回的结果就是把当前的这一项修改为XXX
   })

 filter find reduce some every

数组去重

  • 方案一：双循环去重 遍历数组中的每一项，拿每一项和他后面的项依次比较，如果相同了，就把相同的这一项在原来的数组中删除即可
  • 但是性能不好 循环次数太多
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
var arr = [1,2,2,3,4,5,1,3,4,5,8,9,9,9,0,3,1,2]
 //  arr.length-1 因为最后一项后边没有内容，不需要在比较
 for (var i = 0; i < arr.length-1; i++) {
     var cur = arr[i]//->当前遍历的这一项（索引i）
     //->把拿出的这一项和后一边的每一项做比较
     //->i+1:把当前项和后边项比较 当前项索引是i，后一项是 i+1
     for (var j = i+1; j < arr.length; j++) {
         // arr[j]:做比较的那一项
         if(cur == arr[j]){
             //作比较的这一项和当前项相同，我们需要在原有数组中把作比较的这一项删除掉（做比较的这一项是 j）
             arr.splice(j,1);
             // -> 数组塌陷问题：我们使用splice删除数组中的某一项后，
             //删除这一项后边的每一项的索引都要向前进一位（在原有索引上减一）
             //此时如果j++ 循环操作的值累加了，
             //我们通过最新j获取的元素不是紧挨着删除这一项的元素，而是跳过了一项
             j--;//->相当于没加没减 j还是原有索引，在获取的时候就是删除这一项后边紧挨着的这一项
         }
     }
 }

数组塌陷问题

1
2
3
4
5
6
7
 
/*
    // ->j++ 造成的数组塌陷
    var arr = [1,2,2,3,4,5,1(6),3(7),4(8),5,8,9,9,9,0,3,1,2]
    j下标为6  值是1  把这项删除
    var arr = [1,2,2,3,4,5,3(6),4(7),5,8,9,9,9,0,3,1,2]
    j++  j=7 3 正常应该获取的是3  但是现在索引7的位置是4 3这个值就被跳过去了
*/

也可以直接避免数组塌陷 在删除的时候不进行j++

1
2
3
4
5
6
7
8
9
10
11
 
for (var i = 0; i < arr.length-1; i++) {
    var cur = arr[i]
    for (var j = i+1; j < arr.length;) {
       //if(cur == arr[j]){
       //    arr.splice(j,1);
       //}else{
       //   j++
       //}
       cur == arr[j]?arr.splice(j,1):j++
    }
}

方案二：indexOf去重。 利用indexOf验证当前数组中是否包含这一项，包含就把当前项删除掉（不兼容IE6-8）

1
2
3
4
5
6
7
8
9
10
11
12
 
//拿到当前这一项的时候去比对除了自身这一项
var arr = [1,2,2,3,4,5,1,3,4,5,8,9,9,9,0,3,1,2]
for (var i = 0; i < arr.length; i++) {
       var cur = arr[i]//当前拿到的这一项
    //拿当前项和后边的新数组进行查找
    var curNextAry = arr.slice(i+1)//->拿到当前项后边的那些想以新数组返回，我们需要比较的就是后边的新数组
    if(curNextAry.indexOf(cur)>-1){
        //->后边项组成的数组中包括当前这一项（当前这一项就是重复的，我们把当前项删除掉即可）
        arr.splice(i,1)//删除当前项i
        i--;//注意splice删除后会造成数组塌陷
    }
}
 
1
2
3
4
5
6
 
var arr=[];
for(var i=0;i<b.length;i++){
    if(arr.indexOf(b[i])==-1){
        arr.push(b[i])
    }
}

方案三 对象去重法

排序

冒泡排序

  • 原理：让数组中的当前项和后一项进行比较，如果当前项大于后一项，我们就让两者交换位置
  • 让数组中的当前项和后一项进行比较，如果当前项大于后一项，我们就让两者交换位置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
 
/*
*  第一次比较
*  12 13 [12,13,23,14,16,11]
*  13 23 [12,13,23,14,16,11]
*  23 14 [12,13,14,23,16,11]
*  23 16 [12,13,14,16,23,11]
*  23 11 [12,13,14,16,11,23]
*  第二轮
*  12 13 [12,13,14,16,11,23]
*  13 14 [12,13,14,16,11,23]
*  14 16 [12,13,14,16,11,23]
*  16 11 [12,13,14,11,16,23]
 *  第。。。轮
*  每一轮重前到后两两比较 ，虽然不一定实现最后的排序效果，但是可以把当前最大的放在末尾
*  具体比较的轮数：arr.length-1 数组有多长我们只需要总长度-1个数放在末尾，即可实现排序
*
*  第一轮比较是6次  一共6个不需要和自己比
*  第二轮比较是4次  一共6个 不用和自己比也不用和第一轮放在末尾的最大值比
*  第三轮比较是3次  一共6个 不用和自己比也不用和第一轮和第二轮放在末尾的最大值比
*  。。。。。
*  每一轮比较的次数 arr.length-1(不用和自己比较)- 当前已经执行的轮数
*  （执行一轮就像末尾放一个最大值，这些不需要再比较）
*
*  a = 12 b = 13
*  a和b交换
*  c = a ; a =b b =c;  //比如牛奶a倒进空瓶子c 然后饮料b倒进牛奶a 牛奶a在倒进饮料b
*  如果不让有第三方变量的话
*  a = a+b 25 //a和b家在一起 然后再区分a、b
*  b = a-b 12
*  a = a-b 13
* */
var ary = [12,13,23,14,16,11];

/* 标准注释
*  bubble:实现冒泡排序
*   @parameter
*   arr:[Array]需要排序的数组
*   @return: [Array]返回排序后的数组(升序)
* */
function bubble(ary) {
    //i 外层循环控制的是比较的轮数
    for (var i = 0; i < ary.length - 1; i++) {
        //里层循环控制每一轮的次数 i已经执行的轮数
        for (var j = 0; j < ary.length - 1 - i; j++) {
            //ary[j]当前拿出来的这一项
            //ary[j+1]当前项的后一项
            if (ary[j] > ary[j + 1]) {
                //->当前这一项比后一项还要大 两者交换位置
                var temp = ary[j]//先把当前项给空瓶子 当前项空了
                ary[j] = ary[j + 1]//当前项等于后一项 后一项又空了
                ary[j + 1] = temp // 后一项等于之前存放当前项的瓶子 交换位置了
            }
        }
    }
    return ary;
}

递归算法

// ->面试题：1-100之间，把所有能被3并且被5整除得的获取到，然后累加求和

快速排序

  • var ary = [12,15,14,13,16,11]
  • ->实现方式；先找中间这一项 14
  • ->把剩余项中的每一个值和中间项进行比较，比他小的放在左边（新数组）比他大的放在右边（新数组）
  • 每一个数组都按着这个规律找
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
var ary = [12,15,14,13,16,11]
   function qucik(ary){
       //如果传递进来的数组只有一项或者为空，则不再继续取中间项拆分
       if(ary.length<=1){
           return ary; //返回当前数组
       }
       //->获取中间项的索引：把中间项的值获取到，在原有数组当中删除中间项
       var centerIndex = Math.floor(ary.length/2);
       //删除返回的是新数组 第一项才是值 要注意
       centerIndex = ary.splice(centerIndex,1)[0];
       //->用剩余数组的每一项和中间项进行比较，比中间项大的放在右边，比他小的放在左边（左右两边都是新数组）
       var aryLeft = [];
       var aryRight = [];
       for (var i = 0; i < ary.length; i++) {
           var cur = ary[i];//当前项
           cur < centerIndex ? aryLeft.push(cur):aryRight.push(cur)
       }
       //但是左边的数组aryLeft和右边的数组aryRight还没有排序需要相同的处理方式 递归算法解决
      return qucik(aryLeft).concat(centerIndex, qucik(aryRight))
   }

   console.log(qucik(ary));

插入排序

  • 实现原理：把数组中的每一项理解为扑克牌 新抓一张然后对比一下 放入到小的后边
  • 在桌面上新抓一张牌A，我们用A和手里已经抓的牌进行比较，如果A比手里当前要比较的这张牌小则继续往下一张牌比较，
  • 一直遇到比手里这张牌大，则放到这张牌的后边
  • 如果A比所有牌都要小，就把他放在最前边
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
var ary = [12,15,14,13,16,11]
   function insert(ary){
       //->先抓一张牌
       //储存手里已经抓的牌
       var handAry =[];
       handAry.push(ary[0]);//先抓一张牌
       //->依次循环抓取后边的牌 i=1 因为重第二张开始抓 (大重小循环)
       for (var i = 1; i < ary.length; i++) {
           var item = ary[i];//本次新抓的牌

           //->拿新抓的牌和先有的牌比较 j是手里牌的最后一张
           for (var j = handAry.length-1; j >=0; j--) {
              // handAry[j]当前手里比较的这张牌
               //新抓的牌item比当前比较的这张牌大，就把新抓的牌放到他后面
               if(item>handAry[j]){
                   handAry.splice(j+1,0, item)
                   break;
               }
               if(j===0){
                   //->新抓的牌是最小的 放大最开始的位置
                   handAry.unshift(item)
               }
           }
       }
       return handAry;//返回手里的牌
   }
   console.log(insert(ary));

数组中的最大值最小值

1、 数组排序法

  • 首先给数组大小排序 然后第一个是最小值最后一个是最大值
1
2
3
4
5
6
7
8
 
var ary = [12,23,34,36,24,25,35,14,25]
//数组排序法：首先给数组大小排序 然后第一个是最小值最后一个是最大值
ary.sort(function(a,b){
    return a - b
})
var min = ary[0]
var max = ary[ary.length-1]
console.log(min, max)

2、使用Math中的max/min方法

  • 他在执行的时候，把需要的那堆数一个个的传递进来，这样才可以得到最后的结果，一下放一个ary是不可以的
1
2
3
 
var ary = [12,23,34,36,24,25,35,14,25]
var min1 = Math.min(...ary)
var max1 = Math.max(...ary)

3、假设法

  • 数组中第一个是最大值拿这个值和后边逐一进行比较，如果后边某一个值比假设的大就是假设错了 ，把假设值替换
  • 和自定义属性一样都是js中最常用的方法
1
2
3
4
5
6
7
8
9
 
var ary1 = [12,23,34,36,24,25,35,14,25]
var max2 = ary[0];
var min2 = ary[0]
for (var i = 0; i < ary1.length; i++) {
    var cur = ary[i];
    cur>max2?max2=cur:null;
    cur<min2?min2=cur:null;
}
console.log(min2,max2);

数组并列排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
 
var datalist =  [
        {
            "lon": "112.534758",
            "count": 3,
            "name": "坝塘镇",
            "code": "-1",
            "lat": "28.263983"
        },
        {
            "lon": "112.556306",
            "count": 1,
            "name": "巷子口镇",
            "code": "-1",
            "lat": "28.291214"
        },
        {
            "lon": "112.542942",
            "count": 51,
            "name": "老粮仓镇",
            "code": "-1",
            "lat": "28.229213"
        },
        {
            "lon": "112.556306",
            "count": 2,
            "name": "巷子口镇",
            "code": "-1",
            "lat": "28.291214"
        },
        {
            "lon": "112.556306",
            "count": 2,
            "name": "巷子口镇",
            "code": "-1",
            "lat": "28.291214"
        }
    ]
    function pass(a,b){
        return b.count-a.count
    }
    datalist.sort(pass);
    var id = 0;
    for (var i = 0; i < datalist.length-1;i++){
        if(datalist[i].count === datalist[i+1].count){
            datalist[i].id = id
        }else{
            datalist[i].id = id
            id++
        }
    }
    if(datalist[datalist.length-1].count === datalist[datalist.length-2].count){
        datalist[datalist.length-1].id = id
    }else{
        datalist[datalist.length-1].id = id
    }
    console.log(datalist);

标签：arr,ary,JavaScript,汇总,length,数组,var,Array,一项
来源： https://www.cnblogs.com/lianggl/p/14536094.html