/**
 * Created by laixiangran on 2016/01/07.
 * Array擴展
 */
(function() {

    // 遍曆數組
    if (typeof Array.prototype.forEach != "function") {
        Array.prototype.forEach = function (fn, context) {
            for (var i = 0; i < this.length; i++) {
                if (typeof fn === "function" && Object.prototype.hasOwnProperty.call(this, i)) {
                    fn.call(context, this[i], i, this);
                }
            }
        };
    }

    // 讓數組中的每一個元素調用給定的函數，然後把得到的結果放到新數組中返回
    if (typeof Array.prototype.map != "function") {
        Array.prototype.map = function (fn, context) {
            var arr = [];
            if (typeof fn === "function") {
                for (var k = 0, length = this.length; k < length; k++) {
                    arr.push(fn.call(context, this[k], k, this));
                }
            }
            return arr;
        };
    }

    // 把符合條件的元素放到一個新數組中返回
    if (typeof Array.prototype.filter != "function") {
        Array.prototype.filter = function (fn, context) {
            var arr = [];
            if (typeof fn === "function") {
                for (var k = 0, length = this.length; k < length; k++) {
                    fn.call(context, this[k], k, this) && arr.push(this[k]);
                }
            }
            return arr;
        };
    }

    // 如果數組中的每個元素都能通過給定的函數的測試，則返回true，反之false
    if (typeof Array.prototype.every != "function") {
        Array.prototype.every = function (fn, context) {
            var passed = true;
            if (typeof fn === "function") {
                for (var k = 0, length = this.length; k < length; k++) {
                    if (passed === false) break;
                    passed = !!fn.call(context, this[k], k, this);
                }
            }
            return passed;
        };
    }

    // 類似every函數，但只要有一個通過給定函數的測試就返回true
    if (typeof Array.prototype.some != "function") {
        Array.prototype.some = function (fn, context) {
            var passed = false;
            if (typeof fn === "function") {
                for (var k = 0, length = this.length; k < length; k++) {
                    if (passed === true) break;
                    passed = !!fn.call(context, this[k], k, this);
                }
            }
            return passed;
        };
    }

    // 返回元素在數組的索引，沒有則返回-1，從左到右
    if (typeof Array.prototype.indexOf != "function") {
        Array.prototype.indexOf = function (item, index) {
            var n = this.length,
                i = index == null ? 0 : index < 0 ? Math.max(0, n + index) : index;
            for (; i < n; i++) {
                if (i in this && this[i] === item) {
                    return i
                }
            }
            return -1
        };
    }

    // 返回元素在數組的索引，沒有則返回-1，從右到左
    if (typeof Array.prototype.lastIndexOf != "function") {
        Array.prototype.lastIndexOf = function (item, index) {
            var n = this.length,
                i = index == null ? n-1 : index < 0 ? Math.max(0, n + index) : index;
            for (; i >= 0; i--) {
                if (i in this && this[i] === item) {
                    return i;
                }
            }
            return -1;
        };
    }

    // 讓數組元素依次調用給定函數，最後返回一個值（從左到右）
    if (typeof Array.prototype.reduce != "function") {
        Array.prototype.reduce = function (callback, initialValue) {
            var previous = initialValue, k = 0, length = this.length;
            if (typeof initialValue === "undefined") {
                previous = this[0];
                k = 1;
            }
            if (typeof callback === "function") {
                for (k; k < length; k++) {
                    this.hasOwnProperty(k) && (previous = callback(previous, this[k], k, this));
                }
            }
            return previous;
        };
    }

    // 讓數組元素依次調用給定函數，最後返回一個值（從右到左）
    if (typeof Array.prototype.reduceRight != "function") {
        Array.prototype.reduceRight = function (callback, initialValue) {
            var length = this.length, k = length - 1, previous = initialValue;
            if (typeof initialValue === "undefined") {
                previous = this[length - 1];
                k--;
            }
            if (typeof callback === "function") {
                for (k; k > -1; k-=1) {
                    this.hasOwnProperty(k) && (previous = callback(previous, this[k], k, this));
                }
            }
            return previous;
        };
    }

    // 去掉重覆項（唯一性），返回新數組
    if (typeof Array.prototype.uniq != "function") {
        Array.prototype.uniq = function() {
            var arr = [];
            arr[0] = this[0];
            for (var i = 1; i < this.length; i++) {
                if (arr.indexOf(this[i]) == -1) {
                    arr.push(this[i]);
                }
            }
            return arr;
        };
    }

    // 指定刪除數組中某值
    if (typeof Array.prototype.remove != "function") {
        Array.prototype.remove = function(item) {
            for (var i = this.length; i >= 0; i--) {
                if (item === this[i]) {
                    this.splice(i, 1);
                }
            }
            return this;
        };
    }

    // 打亂數組順序
    if (typeof Array.prototype.shuffle != "function") {
        Array.prototype.shuffle = function() {
            var i = this.length;
            while (i) {
                var j = Math.floor(Math.random()*i);
                var t = this[--i];
                this[i] = this[j];
                this[j] = t;
            }
            return this;
        };
    }

    // 求數組的最大值
    if (typeof Array.prototype.max != "function") {
        Array.prototype.max = function() {
            return Math.max.apply({}, this)
        };
    }

    // 求數組的最小值
    if (typeof Array.prototype.max != "function") {
        Array.prototype.min = function() {
            return Math.min.apply({}, this)
        };
    }

    // 判斷是否為數組
    if (typeof Array.prototype.isArray != "function") {
        Array.prototype.isArray = function() {
            return Object.prototype.toString.apply(this) === "[object Array]";
        };
    }

}());

 參考

http://www.cnblogs.com/rubylouvre/archive/2009/09/20/1570461.html

http://www.cnblogs.com/rubylouvre/archive/2009/09/16/1568123.html

http://www.cnblogs.com/rubylouvre/archive/2009/09/15/1567338.html