uitls

点击查看代码

/**当前星期几
 * @params 无
 * @returns String
 */
export function getWeekDate() {
  var now = new Date();
  var day = now.getDay();
  var weeks = new Array("周日", "周一", "周二", "周三", "周四", "周五", "周六");
  var week = weeks[day];
  return week;
}

/**
 * 当前时间
 * @param { date } // new Date() 2022-12-20T02:42:56.883Z
 * @param { str } // 日期格式 yyyy-MM-dd hh:mm:ss
 * @returns { String } // 2022-12-20 10:42:18
 */
export function formatDate(date, str) {
  date = new Date(date);
  str = str ? str : "yyyy/MM/dd hh:mm:ss";
  if (/(y+)/.test(str)) {
    str = str.replace(RegExp.$1, String(date.getFullYear()).substr(4 - RegExp.$1.length));
  }
  let o = {
    "M+": date.getMonth() + 1,
    "d+": date.getDate(),
    "h+": date.getHours(),
    "m+": date.getMinutes(),
    "s+": date.getSeconds(),
  };
  for (let k in o) {
    if (new RegExp(`(${k})`).test(str)) {
      let stry = String(o[k]);
      str = str.replace(RegExp.$1, RegExp.$1.length === 1 ? stry : ("00" + stry).substr(stry.length));
    }
  }
  return str;
}

/**
 * 去重数组
 * @param { 去重数组 } Array
 * @returns Array 去重后的数组
 */
export function List(params) {
  let arr = [];
  let obj = {};
  arr = params.reduce(function (prev, cur) {
    if (!obj.hasOwnProperty(cur.id)) {
      prev.push(cur);
    }
    obj[cur.id] = true;
    return prev;
  }, []);
  return arr;
}

/**
 * 去重数组
 * @param { 去重数组 } Array
 * @param { 去重依赖的属性 } key
 * @returns  Array 去重后的数组
 */
export function unique(arr, key) {
  var res = new Map();
  return arr.filter(function (a) {
    return !res.has(a[key]) && res.set(a[key], 1);
  });
}

/**
 * 去重数组
 * @param { 去重数组 } Array
 * @param { 去重依赖的属性 } key
 * @returns  Array 去重后的数组
 */
export function uniqueArray(arr = [], key) {
  const keyValues = new Set();
  let val;
  return arr.filter((obj) => {
    val = obj[key];
    if (keyValues.has(val)) {
      return false;
    }
    keyValues.add(val);
    return true;
  });
}

/**
 * 复杂List排序
 * @param 需要依赖sort() // 例如 ——>  const res = arr.sort(sortBy("id", false));
 * @param { 排序依赖的属性 } attr
 * @param { true为正序，false为倒叙 } rev
 * @returns
 */
export function sortBy(attr, rev) {
  if (rev == undefined) {
    rev = 1;
  } else {
    rev = rev ? 1 : -1;
  }
  return function (a, b) {
    a = Number(a[attr]);
    b = Number(b[attr]);
    if (a < b) {
      return rev * -1;
    }
    if (a > b) {
      return rev * 1;
    }
    return 0;
  };
}

/**
 * 检查数据类型
 * @param { 检查的对象 } obj
 * @returns
 */
export function dataType(obj) {
  var toString = Object.prototype.toString;
  var map = {
    "[object Boolean]": "boolean",
    "[object Number]": "number",
    "[object String]": "string",
    "[object Function]": "function",
    "[object Array]": "array",
    "[object Date]": "date",
    "[object RegExp]": "regExp",
    "[object Undefined]": "undefined",
    "[object Null]": "null",
    "[object Object]": "object",
  };
  return map[toString.call(obj)];
}

/**
 * 表单数据添加
 * @param { Object } form
 * @returns { Object }
 */
export const fromInit = (form) => {
  let formData = new FormData();
  for (const key in form) {
    if (form[key] instanceof Array) {
      form[key].forEach((val) => {
        formData.append(key, val);
      });
    } else {
      formData.append(key, form[key]);
    }
  }
  return formData;
};

/**
 * //拆分数组为二维数组
 * @param { Array } data 普通数组
 * @param { Number } number 二维数组长度
 * @returns { Array } 二维数组
 */
export function spliceData(data, number = 24) {
  let num = Math.ceil(data.length / number);
  let remainder = data.length % number;
  let newData = [];
  for (let i = 0; i < num; i++) {
    if (i === 2 && remainder !== 0) continue;
    if (i < 1) {
      newData.push(data.slice(i, i + number));
      continue;
    }
    newData.push(data.slice(i * number, (i + 1) * number));
  }
  return newData;
}

/**
 * 扁平化数组 （树型结构的List【包含 Children】）
 * @param { Array } arr
 * @returns { Array } 一层的数组
 */
export function isrecursion(arr) {
  let res = []; // 用于存储递归结果（扁平数据）
  // 递归函数
  let fn = (source) => {
    source.forEach((el) => {
      res.push(el);
      el.Children && el.Children.length > 0 ? fn(el.Children) : ""; // 子级递归
    });
  };
  fn(arr);
  return res;
}

/**
 * 防抖
 * @param { Function } fn 要执行的函数
 * @param { number } delay 延时时间
 * @returns
 */
export function debounce(fn, delay = 2000) {
  let time = null; //time用来控制事件的触发
  return function () {
    if (time !== null) {
      clearTimeout(time);
    }
    time = setTimeout(() => {
      fn.call(this);
      //利用call(),让this的指针从指向window 转成指向input
    }, delay);
  };
}

/**
 *
 * @param { List - 表格数据 } json
 * @param { Object - 导出的列名称以及对应的表格字段 } forma
 * @returns
 */
export function excelDataFormat(json, forma) {
  //处理一下导出数据
  let data = [];
  for (let i = 0; i < json.length; i++) {
    const jd = json[i];
    let obj = {};
    for (const key in forma) {
      if (forma[key] == "Results") {
        obj[key] = jd[forma[key]] ? "达标" : "未达标";
      } else if (forma[key] == "AnswerType") {
        obj[key] =
          jd[forma[key]] == "1"
            ? "纯文本"
            : jd[forma[key]] == "2"
            ? "URL链接"
            : jd[forma[key]] == "3"
            ? "图片信息"
            : jd[forma[key]] == "4"
            ? "视频音频信息"
            : "链接与描述";
      } else if (forma[key] == "I") {
        obj[key] = jd[forma[key]] == "-1" ? "--" : jd[forma[key]];
      } else {
        obj[key] = jd[forma[key]] ? jd[forma[key]] : "";
      }
    }
    data.push(obj);
  }
  return data;
}

/**
 * 将树形结构数据打平成一维数组
 * @param { Array - 树形结构数组 } treeData
 * @returns
 */
export function tree(treeData) {
  let result = [];
  treeData.forEach((item) => {
    // 先克隆一份数据作为第一层级的填充
    let res = JSON.parse(JSON.stringify(item));
    delete res.children;
    result.push(res);
    if (item.children && item.children.length > 0) {
      // 如果当前children为数组并且长度大于0，才可进入flatTree()方法
      result = result.concat(flatTree(item.children));
    }
  });
  return result;
}

/**
 * 深拷贝
 * @param { 所需要克隆数据 } data
 * @param { boolean 是否深克隆 } isDeep
 * @returns
 */
export function deepClone(data, isDeep) {
  let obj = {};

  if (data instanceof Array) {
    obj = [];
  }
  for (const key in data) {
    let value = data[key];
    obj[key] = !!isDeep && typeof value === "object" && value !== null ? deepClone(value, isDeep) : value;
  }
  return obj;
}