方法随笔

//数组去重，挑选出非重复项
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
    }
  }
}

//过滤空字符串
function delEmptyData(arr) {
  var r = arr.filter((s) => {
    return s && s.trim();     // 注：IE9(不包含IE9)以下的版本没有trim()方法
  });
  return r
}

//时间戳格式化为yyyy-MM-dd hh:mm:ss格式，其他格式也可自行更改
export const formateDate = (timeStamp) => {
  if (failList.includes(timeStamp)) return
  let time = new Date(timeStamp),
    y = time.getFullYear(),
    m = time.getMonth() + 1,
    d = time.getDate(),
    h = time.getHours(),
    mm = time.getMinutes(),
    s = time.getSeconds();

  return (
    y +
    "-" +
    add0(m) +
    "-" +
    add0(d) +
    " " +
    add0(h) +
    ":" +
    add0(mm) +
    ":" +
    add0(s)
  );
}
function add0(m) {
  return m < 10 ? "0" + m : m
}

// 产生随机ID
export function makeRandomID() {
  let randomNum = new Date().getTime();
  let randomInt = Math.round(Math.random() * 10000000);
  return randomNum + randomInt;
}