数组操作类

/**

• 数组操作工具类
  /
  var ListUtil = {
  /each和map的功能是一样的/
  each: function(arr, fn) {
  fn = fn || Function;
  var a = [];
  var args = Array.prototype.slice.call(arguments, 1);
  for (var i = 0; i < arr.length; i++) {
  var res = fn.apply(arr, [arr[i], i].concat(args));
  if (res != null) a.push(res);
  }
  return a;
  },
  /each和map的功能是一样的/
  map: function(arr, fn, thisObj) {
  var scope = thisObj || window;
  var a = [];
  for (var i = 0, j = arr.length; i < j; ++i) {
  var res = fn.call(scope, arr[i], i, this);
  if (res != null) a.push(res);
  }
  return a;
  },
  /*

  • 数组的排序
  • @param: array
  • @param :sortFlag
  • @returns: {*}
    /
    orderBy: function(array, sortFlag) {
    var $arr = array;
    if (sortFlag == ‘asc’) {
    $arr.sort(ListUtil._numAscSort);
    } else if (sortFlag == ‘desc’) {
    $arr.sort(ListUtil._numDescSort);
    } else {
    KaTeX parse error: Expected 'EOF', got '}' at position 34: …_numAscSort); }̲ // console.lo…arr====="+JSON.stringify($arr));
    return $arr;
    },
    /*
  • 求两个集合的并集
    /
    union: function(a, b) {
    var newArr = a.concat(b);
    return ListUtil.unique2(newArr);
    },
    /*
  • 求两个集合的补集
    /
    complement: function(a, b) {
    return ListUtil.minus(ListUtil.union(a, b), ListUtil.intersect(a, b));
    },
    /*
  • 求两个集合的交集
    /
    intersect: function(a, b) {
    a = ListUtil.unique(a);
    return ListUtil.each(a, function(o) {
    return b.contains(o) ? o : null;
    });
    },
    /*
  • 求两个集合的差集
    /
    minus: function(a, b) {
    a = ListUtil.unique(a);
    return ListUtil.each(a, function(o) {
    return b.contains(o) ? null : o;
    });
    },
    /*
  • 数组的去重
  • @param: arr
  • @returns: {Array}
    /
    unique: function(arr) {
    var ra = new Array();
    for (var i = 0; i < arr.length; i++) {
    if (!ra.contains(arr[i])) {
    //if(this.contains(ra,arr[i])){
    ra.push(arr[i]);
    }
    }
    return ra;
    },
    /*
  • 数组的去重复
  • @param :arr
  • @returns: {*}
    /
    unique2: function(arr) {
    for (var i = 0; i < arr.length; i++) {
    for (var j = i + 1; j < arr.length;) {
    if (arr[j] == arr[i]) {
    arr.splice(j, 1);
    } else {
    j++;
    }
    }
    }
    return arr;
    },
    /*
  • 数组去除重复的(根据对象来)
  • @param: {Object} ary
    /
    unique3: function(ary) {
    var result = [],
    hash = {};
    for (var i = 0, elem;
    (elem = arr[i]) != null; i++) {
    if (!hash[elem]) {
    result.push(elem);
    hash[elem] = true;
    }
    }
    return result;
    },
    /*
  • 获取数组的下标
  • @param :arr
  • @param: val
  • @returns :{number}
    /
    indexOf: function(arr, val) {
    for (var i = 0; i < arr.length; i++) {
    if (arr[i] == val) {
    return i;
    }
    }
    return -1;
    },
    /*
  • 判断一个元素是否在一个数组中
  • @param: arr
  • @param :val
  • @returns :{boolean}
    /
    contains: function(arr, val) {
    return this.indexOf(arr, val) != -1 ? true : false;
    },
    /*
  • 数组中删除一个元素
  • @param: arr
  • @param: indexs
  • @returns: {*}
    /
    remove: function(arr, indexs) {
    var index = this.indexOf(arr, indexs);
    if (index > -1) {
    arr.splice(index, 1);
    }
    return arr;
    },
    removeObject: function(arr, item) {
    for (var i = 0; i < arr.length; i++) {
    var jsonData = arr[i];
    for (var key in jsonData) {
    if (jsonData[key] == item) {
    arr.splice(i, 1);
    }
    }
    }
    return arr;
    },
    /*
  • 求数组中最大值
  • @param :arr
  • @returns: {number|Number}
    /
    arrMax: function(arr) {
    return Math.max.apply(null, arr);
    },
    /*
  • 求数组中最小值
  • @param: arr
  • @returns :{number|Number}
    /
    arrMin: function(arr) {
    return Math.min.apply(null, arr);
    },
    /*
  • 删除数组元素的方法
    /
    removeAry: function(ary, ele) {
    ary.splice(ary.indexOf(ele), 1);
    },
    /*
  • 将类数组转换为数组的方法
  • @param: ary
  • @returns: {Array}
    /
    formArray: function(ary) {
    var arr = [];
    if (Array.isArray(ary)) {
    arr = ary;
    } else {
    arr = Array.prototype.slice.call(ary);
    };
    return arr;
    },
    /*
  • 定义一个数组排序的方法
  • 默认为升序排序asc,
  • 如果传递是参数是一个的话，那么就是是升序，如果传递的参数是两个的话，如果第一个参数不能转换为数组的话，也直接退出
  • 参数:acs:表示升序
  • 参数:desc:表示降序
  • @returns: {*}
    /
    // arrySort: function(arguments, ) {
    // var arg = arguments;
    // var len = arg.length;
    // var ary = this.arryList(arg[0]);
    // //如果没传递参数，或者传递的不能转换为数组的话就直接返回
    // if (!len || Array.isArray(ary) == false) {
    // return false;
    // };
    // if (len == 1) {
    // return ary.sort(function(a, b) {
    // return a - b;
    // });
    // } else {
    // return ary.sort(function(a, b) {
    // if (arg[1] == “desc”) {
    // return b - a;
    // } else if (arg[1] == “asc”) {
    // return a - b;
    // } else {
    // return a - b;
    // };
    // });
    // };
    // },
    /*
  • 求和函数
  • @param :arr
  • @returns: {number}
    */
    arySum: function(arr) {
    var ary = [];
    var result = 0;
    if (arr instanceof Array) {
    ary = arr;
    } else {
    ary = this.formArray(arr);
    };
    for (var i = 0; i < ary.length; i++) {
    result += parseFloat(ary[i]);
    };
    return result;
    },

  /**

  • 数组随机排列

  • @param: {Object} ary
    /
    shuffle: function(ary) {
    var input = this;
    for (var i = input.length - 1; i >= 0; i–) {
    var randomIndex = Math.floor(Math.random() * (i + 1));
    var itemAtIndex = input[randomIndex];
    input[randomIndex] = input[i];
    input[i] = itemAtIndex;
    }
    return input;
    },
    /*

  • 数组随机排序

  • @param: {Object} target
    */
    shuffle1: function(target) {
    function randomsort(a, b) {
    return Math.random() > .5 ? -1 : 1;
    //用Math.random()函数生成0~1之间的随机数与0.5比较，返回-1或1
    }

    return target.sort(randomsort);
    },
    /**

  • 判断是不是数组

  • @param: {Object} ary
    /
    isArray: function(ary) {
    var objectToStringFn = Object.prototype.toString;
    var arrayToStringResult = objectToStringFn.call([]);
    return function(subject) {
    return objectToStringFn.call(subject) === arrayToStringResult;
    };
    },
    /*

  • 随机返回数组中一个元素

  • @param: {Object} ary
    /
    randomItem: function(ary) {
    return ary[Math.ceil(Math.random() * ary.length)];
    },
    /*

  • 判断数组中是否包含某一项

  • @param: arr

  • @returns: {number|Number}

  • 调用方法：var max = utils.arrContains([],"",false) flag 如果为true，则判断字符串 false则判断字符
    /
    arrContains: function(arr, str, flag) {
    if (flag) {
    if (arr.length > 0 && this.isNotEmpty(str)) {
    for (var i = 0; i < arr.length; i++) {
    if (arr[i] == str) {
    return true;
    } else {
    return false;
    }
    }
    }
    } else {
    for (var i = 0; i < arr.length; i++) {
    for (var j = 0; j < arr[i].length; j++) {
    if (arr[i].charAt(j) == str) {
    return true;
    } else {
    false;
    }
    }
    }
    }
    },
    /*

  • 判断数组是否有重复的项

  • @param: {Object} arr
    */
    isRepeat: function(arr) { //arr是否有重复元素
    var hash = {};
    for (var i in arr) {
    if (hash[arr[i]]) return true;
    hash[arr[i]] = true;
    }
    return false;
    },
    _numAscSort: function(a, b) {
    // console.log(“a=”+JSON.stringify(a.DISTANCE));
    // var a1=a.DISTANCE.toString().substr(0,a.DISTANCE.toString().length-2);
    // var b1=a.DISTANCE.toString().substr(0,a.DISTANCE.toString().length-2);
    // console.log(‘a1=’+a1);
    // console.log(‘b1=’+b1);
    return a.DISTANCE - b.DISTANCE
    },
    _numDescSort: function(a, b) {

    return b - a;
    },
    /**

  • 比较两个数的大小

  • @param {number} x

  • @param {number} y

  • @return {true}
    */
    _NumberSort: function(x, y) {
    if (Number(x) > Number(y)) {
    return true;
    } else {
    return false;
    }
    },
    // _sortDesc: function(x, y) {
    // if (x > y) {
    // return -1;
    // } else {
    // return 1;
    // }
    // }

}