utils-＞js-＞ecma-＞array

/**
 * set数组去重,不能过滤对象数组
 * @param {Array} arr
 * @returns {Array}
 */
export function uniqueArr_set(arr) {
  return Array.from(new Set(arr))
}

/**
 * indexOf数组去重,不能过滤对象数组
 * @param {Array} arr
 * @returns {Array}
 */
export function uniqueArr_indexOf(arr) {
  var newarr = [];
  for (var i = 0; i < arr.length; i++) {
    if (newarr.indexOf(arr[i]) == -1) {
      newarr.push(arr[i]);
    };
  };

  return newarr
}


//转换成百分比
export function convertPercentage (array = [25, 75]) {
  let result = []
  let total = array.reduce((total, item) => (total + item), 0)
  if (total === 0) {
      return array.map(a => 0)
  }
  array.forEach(item => {
      result.push(Math.round(item / total * 10000) / 100.00)
  })
  return result
}
/**
 * filter indexOf数组去重,不能过滤对象数组
 * @param {Array} arr
 * @returns {Array}
 */
export function uniqueArr_filter_indexOf(arr) {

  var newarr = arr.filter(function (value, index, array) {
    return arr.indexOf(value) == index; //数组项的索引是否等于当前索引,因为只检索一次
  });

  return newarr
}

/**
 * 对象数组根据属性去重
 * @export
 * @param  {any} arr 
 * @param  {any} attributesArr 
 * @return {void}
 */
export function filterArrWithSameAttributes(arr, attributesArr) {
  var newArr = cloneArray(arr);
  var att = ''
  // 创建一个新的属性值att
  if (attributesArr.length > 1) {

    attributesArr.forEach((v, i) => {
      att += (i > 0 ? (separator ? separator : ",") : "") + v + "";
    });
    newArr = newArr.map((v, i) => {
      var attValue = '';
      attributesArr.forEach((attv, i) => {
        if (v.hasOwnProperty(attv)) {
          attValue += v[attv]
        };
      });
      v[att] = attValue
    });
  } else {
    att = attributesArr[0]
  };
  console.log(
    newArr,
    att
  )

  // 过滤掉att属性拥有相同属性值的对象

  return newArr.filter((item, index) => {

    return !newArr.some((ele, ind) => {
      if (index > ind) {
        return ele[att] === item[att]
      } else {
        return false
      };
    })
  })
}

/**
 * 快速排除undefined, null,  0, false, NaN,注意不可排除""
 * @export
 * @param  {any} arr 
 * @return {void}
 */
export function filterArr_empty(arr) {
  return arr.filter(Boolean);
}

/**
 * json对象转Arr对象
 * @param {Object} json
 * @returns {Array}
 */
export function map(json) {
  if (!json) return ''
  return cloneArray(
    Object.keys(json).map(key => {
      if (json[key] === undefined) return ''
      return encodeURIComponent(key) + '=' + encodeURIComponent(json[key])
    })
  ).join('&')
}


/**
 * 拷贝数组
 * @param {Array} actual
 * @returns {Array}
 */
function cloneArray(actual) {
  const newArray = []
  for (let i = 0; i < actual.length; i++) {
    if (actual[i]) {
      newArray.push(actual[i])
    }
  }
  return newArray
}


/**
 * 创建限定长度数组
 */

export function creatArr(num, inner) {
  var resultArr;
  if (typeof (inner) == 'undefined') {
    resultArr = Array.from({
      length: num
    })
    // 或者resultArr= new Array(num);
  } else {
    // 1.push()
    // 2.fill()方法,const arr = new Array(LEN).fill(obj);,将会引用一个实例
    // 3.keys()方法
    // 4.Array.from() 进行映射
    const START = inner,
      num = 5;
    resultArr = Array.from({
      length: num
    }, (x, i) => i + START)
  };
  return resultArr
}

/*
具有与相同属性的项组成新数组
入参：一维数组
arrDealWithSameAtt(customersAndChargesnArr, [
  'chargeItemName',
  'customerID',
]),
type结果类型
separator对象属性用separator分割，合并成str作为结果属性
*/

export function arrDealWithSameAtt(data, strArr, type, separator) {
  if (type && type == "Object") {
    var listObj = {};
    if (strArr.length > 1) {
      var str = "";
      strArr.forEach((v, i) => {
        str += (i > 0 ? (separator ? separator : ",") : "") + value[v] + "";
      });
    } else {
      var str = value[strArr[0]];
    };
    data.forEach(function (value, index) {

      if (listObj[str]) {
        listObj[str].push(data[index]);
      } else {
        var arr = [];
        arr.push(data[index]);
        listObj[str] = arr; //
      }
    });
    return listObj;
  } else {
    var listArr = [];
    data.forEach(function (value, index) {
      var obj = [];
      for (var i = 0; i < listArr.length; i++) {
        debugger
        var allMatch = strArr.every((v, index) => {
          return listArr[i][0][v] == value[v];
        });
        if (allMatch) {
          listArr[i].push(value);
          return;
        }
      }
      obj.push(value);
      listArr.push(obj);
    });
    return listArr;
  }
}

// 转换数组为对象
export function arrToObj(arr) {
  return {
    ...arr
  }
};

/**
 * 全排列函数
 * 1,2=>["2,1", "21,", ",12", ",21", "12,", "1,2"]
 * @export
 * @param  {any} str 
 * @return 
 */
export function permutate(str) {
  var array = str.split('');

  function loop(array, pre = []) {
    if (array.length == 1) {
      return [pre.concat(array).join('')];
    }
    let res = [];
    for (let index = 0; index < array.length; index++) {
      var first = array.pop();
      res = res.concat(loop(array, [...pre, first]));
      array.unshift(first);
    }
    return res;
  }
  return Array.from(new Set(loop(array)))
};

/**
 * 二分搜素，返回索引，一维数组搜索
 * @export
 * @param  {any} arr 
 * @param  {any} target 
 * @return 
 */
export function binary_search(arr, target) {

  function search(arr, target, from, to) {
    if (from > to) {
      return -1
    }
    const mid = Math.floor((from + to) / 2)
    if (arr[mid] > target) {
      return search(arr, target, from, mid - 1)
    } else if (arr[mid] < target) {
      return search(arr, target, mid + 1, to)
    } else {
      return mid
    }
  }
  return search(arr, target, 0, arr.length - 1)


}

/**
     * 宗谱关系，找出所有子孙部分，或者不包含这部分子孙，且不包含自身的部分
     * @param  {any} arr 
     * @param  {any} parents 
     * @param  {any} pattribute 
     * @param  {any} cattribute 
     * @param  {any} type 1--所有子孙，2--不包含这部分子孙的部分
     * @return 
     */
    export function  filterChildByAttribute(arr,parents,pattribute,cattribute,type){
      var _this=this;
      // 宗谱中排除自己
      arr=arr.filter((v,i)=>{
        if(parents[pattribute]!=v[pattribute]){
          return v
        }else{
        };
      });
      
       // 取得childArr--是子对象组成的数组，newArr--排除了childArr的arr部分
      var newArr=[];
      var childArr=arr.filter((v,i)=>{
        if(parents[pattribute]==v[cattribute]){
          return v
        }else{
          newArr.push(v)
        };
      });
       // result--是所有子对象组成的数组，
      var result=[];
      if(childArr.length>0){
        result=result.concat(childArr);
        
        childArr.forEach((v,i)=>{
          result=result.concat(filterChildByAttribute(newArr,v,pattribute,cattribute))
        });
        
        if(type==1||!type){
          return result;
        }else if(type==2){

          var othorResult=arr.filter((v,i)=>{
            return result.filter((subv,subi)=>{
              return subv[pattribute]==v[pattribute]
            }).length==0;
          });
          return othorResult;
        };
       
      }else{
        if(type==1||!type){
          return []
        }else{
          return arr
        };
          
      };
      
     
    }