util-16.数组操作相关(arrayUtil)

/**
 * ========================16.数组操作 s========================
 */
arrOperate();
function arrOperate(){
    function arrayUtil(arr){
        this.arr = arr;
    }

    var arr = new arrayUtil([new Date(),"字符串",{"param1":"value1"}]);
    console.log(arr.toLocaleString())
    /*[eg: arr.delFirstItem()]*/
    arrayUtil.prototype.a = function(){
        // [eg:]
    }

    /**
     *   在指定位置开始删除指定个数选项并插入选项[eg: arr.spliceArray(0,2,[6,7])]
     *   功能实现：
     pop: arr.spliceArray(arr.arr.length-1,1);  ----delLastItem
     push: arr.spliceArray(arr.arr.length,0,[6,7]);  ----apendItem
     shift: arr.spliceArray(0,1);  ----delFirstItem
     unshift: arr.spliceArray(0,0,[6,7]);  ----prependItem
     concat: arr.spliceArray(arr.arr.length,0,[6,7]);  ----concatArray
     * @param startInd
     * @param delLen
     * @returns {*}
     */
    arrayUtil.prototype.spliceArray = function(startInd,delLen){
        console.log("startInd==="+startInd)
        //splice(start,deleteCount,val1,val2,...)：从start位置开始删除deleteCount项数组，返回删除项，并从该位置起插入val1,val2,...
        if (arguments[2]) {
            for (var len=arguments[2].length,i=len-1; i>=0; i--) {
                this.arr.splice(Number(startInd)+Number(delLen),0,arguments[2][i]);
            }
        }
        this.arr.splice(startInd,delLen);
        return this.arr;
    }

    /**
     * 删除数组第一项[eg: arr.delFirstItem()]
     * @returns {*}
     */
    arrayUtil.prototype.delFirstItem = function(){
        //shift：删除原数组第一项，并返回删除元素的值；如果数组为空则返回undefined
        this.arr.shift();
        return this.arr;
    }

    /**
     * 删除数组最后一项[eg: arr.delLastItem()]
     * @returns {*}
     */
    arrayUtil.prototype.delLastItem = function(){
        //pop：删除原数组最后一项，并返回删除元素的值；如果数组为空则返回undefined
        this.arr.pop();
        return this.arr;
    }

    /**
     * 数组最前面按参数顺序追加选项[eg: arr.prependItem([6,7])]
     * @returns {*}
     */
    arrayUtil.prototype.prependItem = function(){
        /**
         * unshift:
         * array.unshift(item1[,item2,...]); 方法可向数组的开头添加一个或更多元素，并返回新的长度。
         var arr = ["aa","bb","cc"];
         arr.unshift("mm","nn"); //5
         console.log(arr);  // ["mm", "nn", "aa", "bb", "cc"]
         *
         * shift: 从数组中移除元素:
         * array.shift(); 方法用于把数组的第一个元素从其中删除，并返回第一个元素的值；如果数组为空则返回undefined
         */
        if(arguments.length > 0){
            for(var len=arguments[0].length,i=len-1; i>=0; i--){
                this.arr.unshift(arguments[0][i]);
            }
        }
        return this.arr;
    }

    /**
     * 数组最后面按参数顺序追加选项，同concatArray[eg: arr.apendItem([6,7])]
     * @returns {*}
     */
    arrayUtil.prototype.apendItem = function(){
        //push：将参数添加到原数组末尾，并返回数组的长度 [eg:a.push(6,7);]
        if(arguments.length > 0){
            for(var i=0,len=arguments[0].length; i<len; i++){
                this.arr.push(arguments[0][i]);
                //同this.arr = this.arr.concat(arguments[0][i]);
            }
        }
        return this.arr;
    }

    /**
     * 数组最后面按参数顺序追加选项，同apendItem[eg: arr.concatArray([6,7])]
     * @returns {T[] | string | T[]}
     */
    arrayUtil.prototype.concatArray = function(){
        /**
         * concat：返回一个新数组，不修改原数组，是将参数添加到原数组中构成的 [eg:a.concat(6,7);]
         * concat使用示例：返回一个新数组，不修改原数组，不去重
         1.连接数组中的值:  arr.concat(值1,值2);
         2.连接两个数组:  arr1.concat(arr2);
         3.链接多个数组:  arr2.concat(arr2,arr3,...);
         同：Array.prototype.push.apply(arr1,arr2);  //arr1的值改变
         * @type {T[] | string | T[]}
         */
        var newArr = this.arr.concat();
        if (arguments.length>0) {
            for (var i=0,len=arguments[0].length; i<len; i++) {
                newArr = newArr.concat(arguments[0][i]);
            }
        }
        return newArr;
    }

    /**
     * 获取指定开始下标到结束下标之间的元素组成的数组[eg: arr.sliceArr(2,5)]
     * @param startInd
     * @param endInd
     * @returns {*}
     */
    arrayUtil.prototype.sliceArr = function(startInd,endInd){
        /**
         * slice(start,end)：参数为负，从后数起；end<start，返回空数组。返回从原数组中指定开始下标到结束下标(不包含下标为end的元素)之间的项组成的新数组
         */
        return this.arr.slice(startInd,endInd);
    }

    /**
     * 将数组转换成以分隔符链接的字符串[eg: arr.arrTostring("|")]
     * @returns {string}
     */
    arrayUtil.prototype.arrTostring = function(){
        /**
         * join(separator):将数组的元素组起一个字符串，以separator为分隔符，省略的话则用默认用逗号为分隔符
         */
        if (arguments.length>0) {
            return this.arr.join(arguments[0]);
        }else{
            return this.arr.join();
        }
    }

    /**
     * 查找指定的元素在数组中的位置，即索引，数组包含indexOf方法[eg: arr.getItemIndexOf(4)]
     * @param item
     * @returns {number}
     */
    arrayUtil.prototype.getItemIndexOf = function(item){
        for (var i = 0; i < this.arr.length; i++) {
            if (this.arr[i] == item) {
                return i;
            }
        }
        return -1;
    }

    /**
     * 删除数组中指定元素[eg: arr.removeItem(4)]
     * @param item
     * @returns {*}
     */
    arrayUtil.prototype.removeItem = function(item){
        var ind = this.indexOf(item);   //数组自带indexOf方法
        if (ind > -1) {
            this.arr.splice(ind,1);
        }
        return this.arr;
    }

    /**
     * 获取数组中的最大值[eg: arr.getMaxItem()]
     * @returns {number}
     */
    arrayUtil.prototype.getMaxItem = function(){
        return Math.max.apply(null,this.arr);
        //apply与call的区别: apply把参数放在数组里，call把参数按顺序传入
    }

    /**
     * 获取数组中的最小值[eg: arr.getMinItem()]
     * @returns {number}
     */
    arrayUtil.prototype.getMinItem = function(){
        return Math.min.apply(null,this.arr);
    }

    /**
     * 单个元素数组排序，Array默认按字符编码排序[eg: arr.arraySort(true)]
     * @param type
     * @returns {*}
     */
    arrayUtil.prototype.arraySort = function(type){
        if (type) {  //升序
            this.arr.sort(function(a,b){return a-b;});
        }else{  //默认降序
            this.arr.sort(function(a,b){return b-a;});
        }
        return this.arr;
    }

    /**
     * 合并两个数组不去重，也可使用concat()[eg: (arr.arrayMerged(arr1)]
     * @param arr
     * @returns {*}
     */
    arrayUtil.prototype.arrayMerged = function(arr){
        Array.prototype.push.apply(this.arr,arr);
        //同this.arr = this.arr.concat(arr);
        return this.arr;
    }

    /**
     * 单元素数组去重[eg: arr.arrayUnique(true)]
     * @param type
     * @returns {*}
     */
    arrayUtil.prototype.arrayUnique = function(type){
        if (type) {   //排序去重，影响排序
            this.arr = arrayUniqueBySort(this.arr);
        }else{  //默认hash去重，不影响排序
            this.arr = arrayUniqueByHash(this.arr);
        }
        return this.arr;

        //利用hash存储，如果已存在，去重
        function  arrayUniqueByHash(arr){
            var templateHash = {},
                newArr = [];
            for(var i=0,len=arr.length; i<len; i++){
                var item = arr[i];
                if (!templateHash[item]){
                    templateHash[item] = true;
                    newArr.push(item);
                }
            }
            return newArr;
        }

        //先排序，再根据相邻元素是否有相同的值，去重
        function arrayUniqueBySort(arr){
            arr.sort(function(a,b){return a-b;});
            var newArr=[arr[0]];
            for(var i = 1,len=arr.length; i < len; i++){
                var item =arr[i];
                if(item !== newArr[newArr.length-1]){
                    newArr.push(item);
                }
            }
            return newArr;
        }
    }

    /**
     * json字段排序[eg:
     单一字段排序：arr.arrayJsonSort("percent",true,parseInt)，
     多字段排序：arr.arrayJsonSort([
     ["percent",true,parseInt],
     ["ageMin",true,parseInt],
     ["ageMax",true,parseInt]
     ])
     ]
     * @returns {*}
     */
    arrayUtil.prototype.arrayJsonSort = function(){
        console.log("instanceof====="+(arguments[0] instanceof Array));
        console.log("typeOf====="+(typeof(arguments[0])));
        var _this = this;   //arguments[0] instanceof Array
        if (arguments[0] instanceof Array) { //多字段排序
            var len = this.arr.length;
            var parameter = arguments[0];
            for (var i = 0; i < parameter.length; i++) {
                var item = parameter[i];
                if (i==0) {  //按第一个字段排序
                    this.arr.sort(SortBy(item[0],item[1],item[2]));
                    console.log("第一字段排序后数组：\n",JSON.stringify(this.arr));
                }else{  //按第二个字段排序
                    var param = parameter[i-1][0];
                    var sortParam = parameter[i];
                    var newArr =[[this.arr[0]]];
                    var childArrVal = this.arr[0][param];
                    var arrNum = 0;

                    for (var k = 1; k < len; k++) {
                        if (this.arr[k][param] == childArrVal) {
                            newArr[arrNum].push(this.arr[k]);
                        }else{
                            arrNum++;
                            childArrVal = this.arr[k][param];
                            newArr.push(new Array());
                            newArr[arrNum].push(this.arr[k]);
                        }
                    }
                    console.log("重整合数组：\n",JSON.stringify(newArr));

                    if(newArr.length != len){  //如果有重复数据则重新组合
                        var endArr = [];
                        for(var m=0; m<newArr.length; m++){
                            newArr[m].sort(SortBy(sortParam[0],sortParam[1],sortParam[2]));
                            Array.prototype.push.apply(endArr,newArr[m]);
                        }
                        this.arr = endArr;
                    }
                }
            }
        }else{  //单一字段排序
            this.arr.sort(SortBy(arguments[0],arguments[1],arguments[2]));
        }
        return this.arr;


        /**
         * 按字段排序
         * @param field  //排序字段
         * @param reverse  //降序(逆时针)true 升序(顺时针)false
         * @param primer  //类型转换
         * @returns {Function}
         * @constructor
         */
        function SortBy(field, reverse, primer) {
            reverse = (reverse) ? -1 : 1;
            return function (a, b) {
                a = a[field];
                b = b[field];
                if (typeof (primer) != 'undefined') {
                    a = primer(a);
                    b = primer(b);
                }
                if (a < b) return reverse * -1;
                if (a > b) return reverse * 1;
                return 0;
            }
        }
    };

    /**
     * json数组去重，但不排序，不改变原数组:
     根据第一字段key去重，然后保留第二字段secondkey值为secondkeyval的数据
     调用方法：
     var newarr = arr.unique("useropenid","pushflag",0);
     * @param key
     * @param secondkey
     * @param secondkeyval
     * @returns {*[]}
     */
    Array.prototype.unique = function(key,secondkey,secondkeyval) {
        var arr = this;
        var n = [arr[0]];
        for (var i = 1; i < arr.length; i++) {
            if (key === undefined) {
                if (n.indexOf(arr[i]) == -1) n.push(arr[i]);
            } else {
                inner: {
                    var has = false;
                    for (var j = 0; j < n.length; j++) {
                        if (arr[i][key] == n[j][key]) {
                            if(arr[i][secondkey]!=secondkeyval){
                                has = true;
                                break inner;
                            }
                        }
                    }
                }
                if (!has) {
                    n.push(arr[i]);
                }
            }
        }
        return n;
    }


    /**
     * 创建一个新的匹配过滤条件的数组[eg: arr.filterItem(function(val,ind,array){ return val > 5;})]
     * @param callback
     * @returns {*}
     */
    arrayUtil.prototype.filterItem = function(callback){
        // callback 被调用时传入三个参数：param1元素的值, param2元素的索引, param3被遍历的数组[eg:]
        return this.arr.filter(callback);
    }


    /**
     * toLocaleString() 返回一个字符串表示数组中的元素。数组中的元素将使用各自的 toLocaleString 方法转成字符串
     --Object: Object.prototype.toLocaleString()
     Number: Number.prototype.toLocaleString()
     Date: Date.prototype.toLocaleString()
     [eg: arr.toLocaleString()
     -----
     [new Date(),"字符串",{"param1":"value1"}]
     ----
     2016/11/3 下午3:30:14,字符串,[object Object]]
     * @returns {string}
     */
    arrayUtil.prototype.toLocaleString = function(){
        return this.arr.toLocaleString();
    }


    /**
     * 数组反转，改变原数组
     * @returns {Uint8Array | this | T[] | Int16Array | Uint32Array | Uint8ClampedArray | Uint16Array | Float32Array | Int32Array | Int8Array | Float64Array | this | void}
     */
    arrayUtil.prototype.reverse = function(){
        return this.arr.reverse();
    }
}

/**
 * polyfill----------数组的过滤方法Array.prototype.filter-----浏览器兼容性
 */
if (!Array.prototype.filter){
    Array.prototype.filter = function(fun /*, thisArg */)
    {
        "use strict";

        if (this === void 0 || this === null)
            throw new TypeError();

        var t = Object(this);
        var len = t.length >>> 0;
        if (typeof fun !== "function")
            throw new TypeError();

        var res = [];
        var thisArg = arguments.length >= 2 ? arguments[1] : void 0;
        for (var i = 0; i < len; i++)
        {
            if (i in t)
            {
                var val = t[i];

                // NOTE: Technically this should Object.defineProperty at
                //       the next index, as push can be affected by
                //       properties on Object.prototype and Array.prototype.
                //       But that method's new, and collisions should be
                //       rare, so use the more-compatible alternative.
                if (fun.call(thisArg, val, i, t))
                    res.push(val);
            }
        }

        return res;
    };
}
/**
 * ========================16.数组操作 e========================
 */