方法随笔

//数组去重，挑选出非重复项
export function chooseNonRepeatingData(ar1, ar2) {
  const _arr1 = ar1.filter(item1 => !ar2.includes(item1));
  const _arr2 = ar2.filter(item2 => !ar1.includes(item2));

  return [
    ..._arr1,
    ..._arr2
  ]
}

/**
   * @method 对象数组去重
   * @param  {Array} ary  需要去重的数组  
   * @param  {Any} dataTemplateId  去重的参考值  
   * @return {Array} tableData  去重后的数组
  */
export function delRepeatData(ary) {
  let obj = {};
  let tableData = [];
  tableData = ary.reduce((cur, next) => {
    obj[next.dataTemplateId] ? "" : obj[next.dataTemplateId] = true && cur.push(next);
    return cur;
  }, [])
  return tableData;
}


/**
 * @method 数组去重
 * @param  {Array} arr 需要去重的数组
 * @return {Array} 去除后的数组
 */

export function removeDuplicate(arr) {
  const newArr = []
  arr.forEach((item) => {
    if (newArr.indexOf(item) === -1) {
      newArr.push(item)
    }
  })
  return newArr
}


/**
 * @method 两个数组去重【单个数字】 arr1：[1,2,3]  arr2：[1,2,3,4]
 * @param  {Array} arr1 原始权限数组
 * @param  {Array} arr2 选择过的权限数组
 * @return {String} 去重后的字符串
 */

export function unique(arr1, arr2) {
  if (!Array.isArray(arr1) || !Array.isArray(arr2)) {
    console.error('type error!')
    return
  }
  let keys = [...arr1, ...arr2]
  let array = []
  for (let i = 0; i < keys.length; i++) {
    if (array.indexOf(keys[i]) === -1) {
      array.push(keys[i])
    }
  }
  return array.join(',')
}


/**
 * @method 深拷贝
 * @param  {Any} source
 * @return {Array} 深拷贝后的数组
 */
export function deepClone(source) {
  const sourceCopy = source instanceof Array ? [] : {}
  for (let item in source) {
    sourceCopy[item] =
      typeof source[item] === 'object' && source[item]
        ? deepClone(source[item])
        : source[item]
  }
  return sourceCopy
}


/**
 * @method 去除树形结构最后一层权限
 * @param  {Array} data 原始权限数组
 * @return {Array} 去除按钮权限的数组
 */

export function filterData(data) {
  // 到叶子节点了，返回,递归出口
  if (data == undefined || data == null || data.length == 0) {
    return
  } else {
    // 对每一层，遍历这个数组，调用filterData方法对每个元素下的数组进行同样的操作
    // 筛掉当前层的status为2的对象
    myFilter(data)
    for (let index in data) {
      filterData(data[index].menuChildren)
    }
  }
  return data
}


/**
 * @method 判断两个数组中是否有重复的数据
 * @param  {String} defaultData 默认选中的数据
 * @param  {String} distributData 可分配选中的数据
 * @return {Boolean} true 有重复的， false 没有重复的
 */
export function getSame(defaultData, distributData) {
  let ary1 = defaultData.split(',')
  let ary2 = distributData.split(',')
  let resultArr = []
  for (let i = 0; i < ary1.length; i++) {
    for (let j = 0; j < ary2.length; j++) {
      if (ary1[i] === ary2[j]) {
        resultArr.push(ary1[i])
      }
    }
  }
  for (let i = 0; i < resultArr.length; i++) {
    if (
      resultArr[i] == ' ' ||
      resultArr[i] == null ||
      typeof resultArr[i] == 'undefined'
    ) {
      array.splice(i, 1)
      i = i - 1
      return resultArr.length < 1 ? false : true
    }
  }
}