6个Javascript数组实用的原型扩展方法

可以说数组在任何一门编程语言中都是一个极其重要的工具，在 JavaScript 也是如此，但遗憾的是原生 JavaScript 中对数组提供的方法少之又少，这在一定程度上降低了开发效率，如果你也为此所困扰，那么下面的代码对于缓解这样的尴尬局面也许能有一点帮助。

在开始对数组进行原型扩展之前，非常有必要添加一个方法来验证一个变量是否为数组类型。该方法接受一个任意数据类型的变量作为参数，如果是数组则返回true，否则，你懂得。

function isArray(a){
    return a.constructor === Array ? true : false;
}

// Usage :
var isArrayA = [3];
var isArrayB = 3;
var isArrayResultA = isArray(isArrayA); //true
var isArrayResultB = isArray(isArrayB); //false

深度拷贝

这个方法非常简单，它返回一个深度拷贝的数组。如果你对此有所迷惑，请点击这里获得详细的解释。

Array.prototype.copy = function(){
    return [].concat(this);
};

// Usage :
var copyA = [0,1];
var copyResult = copyA.copy();

去除数组中的重复项

方法 unique 将返回一个仅包含不重复元素的数组

Array.prototype.unique = function(){
    var a = [];
    var l = this.length;
    for (var i = 0; i < l; i++) {
        for (var j = i + 1; j < l; j++) {
            if (this[i] === this[j]) 
                j = ++i;
        }
        a.push(this[i]);
    }
    return a;
};

// Usage :
var uniqueA = [1,2,3,3,5,5,3,7];
var uniqueResult = uniqueA.unique();
// uniqueResult = [1, 2, 5, 3, 7];

获取数组中不相同的元素

当一个数组调用 diff 方法，将得到这个数组中元素与其他数组中元素所不同的元素。有点拗口是吧？试试就知道是怎么回事了。

Array.prototype.diff = function(){
    var a1 = this;
    var a = a2 = null;
    var n = 0;
    while (n < arguments.length) {
        a = [];
        a2 = arguments[n];
        var l = a1.length;
        var l2 = a2.length;
        var diff = true;
        for (var i = 0; i < l; i++) {
            for (var j = 0; j < l2; j++) {
                if (a1[i] === a2[j]) {
                    diff = false;
                    break;
                }
            }
            diff ? a.push(a1[i]) : diff = true;
        }
        a1 = a;
        n++;
    }
    return a.unique();
};

// Usage :
var diffA = [1,2,3];
var diffB = [2,3,4];
var diffResult = diffA.diff(diffB);
// diff = [1];

合并数组

这个方法将传入的数组进行合并，并返回合并后的新数组

Array.prototype.union = function(){
    var a = [].concat(this);
    var l = arguments.length;
    for (var i = 0; i < l; i++) {
        a = a.concat(arguments[i]);
    }
    return a;
};

// Usage :
var unionA = [1,2,3];
var unionB = [2,3,4];
var unionResult = unionA.union(unionB);
// unionResult = [1, 2, 3, 2, 3, 4]

交集

intersect 将返回传入几的数组中相同的元素

Array.prototype.intersect = function(){
    if (!arguments.length) 
        return [];
    var a1 = this;
    var a = a2 = null;
    var n = 0;
    while (n < arguments.length) {
        a = [];
        a2 = arguments[n];
        var l = a1.length;
        var l2 = a2.length;
        for (var i = 0; i < l; i++) {
            for (var j = 0; j < l2; j++) {
                if (a1[i] === a2[j]) 
                    a.push(a1[i]);
            }
        }
        a1 = a;
        n++;
    }
    return a.unique();
};

// Usage :
var intersectA = [1,2,3];
var intersectB = [2,3,4];
var intersectC = [3,4,5];
var intersectResult = intersectA.intersect(intersectB,intersectC);
// intersectResult = [3];

随机化

对一个数组进行随机排序，返回值为 undefined

Array.prototype.randomize = function(){
        this.sort(function(){
            return ((Math.random() * 3) | 0) - 1;
        });
};

// Usage :
var randomizeA = [4,7,3,7,3];
randomizeA.randomize();