js关于数组处理以及随机数的一些处理方法扩展总结

    看到前端群里有人提到大数组、不重复随机数以及数组去重等问题，比较感兴趣就查询了一些资料并进行了测试使用，所以将结果做些总结存放于此，由于技术水平有限，其中存在错误难免，错误之处请包涵还请指出，共同进步。

    1、大数组处理，主要是通过异步处理一方处理时间过久浏览器不响应导致的不友好的体验。

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
/**
 * 长数组处理方法 ----存在效率问题
 * @param  {[type]}   arr      [description]
 * @param  {[type]}   process  [description]
 * @param  {[type]}   context  [description]
 * @param  {Function} callback [description]
 * @return {[type]}            [description]
 */
function chunk(arr, process, context) {
    var item = arr.concat();
    setTimeout(function() {
        process.call(context, item.shift());
        if (item.length > 0) {
            setTimeout(argument.callee, 100);
        }
    }, 100);
}
/**
 * 长数组处理方法---效率更高
 * @param  {[type]}   arr      [description]
 * @param  {[type]}   process  [description]
 * @param  {[type]}   context  [description]
 * @param  {Function} callback [description]
 * @return {[type]}            [description]
 */
function chunckDeal(arr, process, context, callback) {
    var item = arr.concat();
    setTimeout(function() {
        var o = +(new Date());
        var n;
        do {
            process.call(context, item.shift());
            n = +(new Date());
        } while (item.length > 0 && (n - o < 50));
        if (itme.length > 0) {
            setTimeout(argument.callee, 25);
        } else {
            callback.call(context, arr);
        }
    }, 25)
}

     2、数组去重，也是数组唯一性处理，参考了博客http://welefen.com/javascript-array-unique.html

其中主要提供3种方法，个人归类为利用对象属性唯一性办法去重、前向查重构建和后向遍历去重3种方法，分别对应方法delArrayRepeat(arr)、delRepeatINArrayByDirect(arr)、delRepeatINArrayByReverse(array)。

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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
/**
 * 通过object中key的唯一性来进行----数组去重
 */
function delArrayRepeat(arr) {
    var o = {};
    var nArr = [];
    for (var i = 0; i < arr.length; i++) {
        var s = typeof arr[i] + arr[i];
        if (!o[s]) {
            nArr.push(arr[i]);
            o[s] = true;
        } else {
            console.log(i + ":" + arr[i]);
        }
    }
    return nArr;
}
/**
 * 通过正向遍历进行-----数据去重
 */
function delRepeatINArrayByDirect(arr) {
    var rA = [];
    for (var i = 0; i < arr.length; i++) {
        if (getArrIndexOf(rA, arr[i]) < 0) {
            rA.push(arr[i]);
        }
    }
    return rA;
}
/**
 * 通过反向向遍历进行-----数据去重
 */
function delRepeatINArrayByReverse(array) {
    var arr=array.concat();
    var lg=arr.length;
    for (var i = lg - 1; i >= 1; i--) {
        if (getArrLastIndexOf(arr, arr[i], i - 1) >=0) {
            arr.splice(i, 1);
            console.log(i);
        }
    }
    return arr;
}
 
/**
 * 获取数组中某一个元素的索引
 * @param  {[type]} arr [description]
 * @param  {[type]} ele [description]
 * @return {[type]}     [description]
 */
function getArrIndexOf(arr, ele) {
    for (var i = 0; i < arr.length; i++) {
        if (ele === arr[i]) {
            return i;
        }
    }
    return -1;
}
/**
 * 获取数组的后向索引
 * @param  {[type]} arr [description]
 * @param  {[type]} ele [description]
 * @return {[type]}     [description]
 */
function getArrLastIndexOf(arr, ele, index) {
    var lg = arr.length;
    if ((!index&&index!=0) || index >= lg) {
        index = lg - 1;
    } else if (index < 0) {
        index = 0;
    }
    for (var i = index; i >= 0; i--) {
        if (ele === arr[i]) {
            return i;
        }
    }
    return -1;
}

    3、某一范围内不重复随机数的获取方法：该方法利用随机数Math.random()方法，产生随机索引key来获取随机数。

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
/**
 * 通过splice实现获取某一范围内的不重复的随机数。
 * 注意：取出数的个数不能大于范围，即count<start-end;
 */
function getUniqueRandomValue(start, end, count) {
    var cdt = [];
    var rv = [];
    var lg = end - start;
    for (var i = 0; i < lg; i++) {
        cdt[i] = i + lg;
    }
    for (var j = 0; j < count; j++) {
        var index = Math.floor(Math.random() * lg);
        rv.push(cdt[index]);
        cdt.splice(index, 1);
        --lg;
    }
    return rv;
}
/**
 * 通过null实现随机数唯一
 * @param  {[type]} start [description]
 * @param  {[type]} end   [description]
 * @param  {[type]} count [description]
 * @return {[type]}       [description]
 */
function getUniqueRandomValueByNull(start, end, count) {
    var cdt = [];
    var rv = [];
    var lg = end - start;
    for (var i = 0; i < lg; i++) {
        cdt[i] = i + lg;
    }
    for (var j = 0; j < count; j++) {
        do {
            var index = Math.floor(Math.random() * lg);
        } while (cdt[index] = null);
        rv.push(cdt[index]);
        cdt[index] = null;
    }
    return rv;
}

       以上方法中还可以将大数组的处理方法和数组去重结合起来处理大数组去重问题，未完待续。。。。










posted on 2015-07-22 09:43  颜传  阅读(359)  评论(0)  编辑  收藏  举报