常用的前端的方法函数（还在更新中）

/**
 * 字符串时间转化成时间戳
 * @param {*} str 字符串时间 2022-04-29 00:00:00
 * @returns 时间戳
 */
export function getDateFromString(str) {
  var reg = /^(\d+)-(\d+)-(\d+) (\d+):(\d+):(\d+)/;
  var s = str.match(reg);
  var result = "";
  if (s) {
    result = new Date(s[1], s[2] - 1, s[3], s[4], s[5], s[6]);
  }
  return result;
}

/**
 * 时间戳转日期字符串
 * @param {*} timestamp 时间戳
 * @param {*} formats 时间格式 formats格式包括
 * 1. Y-m-d
 * 2. Y-m-d H:i:s
 * 3. Y年m月d日
 * 4. Y年m月d日 H时i分
 * @returns 日期字符串
 */
export function getMyDate(timestamp, formats) {
  formats = formats || "Y-m-d";
  var zero = function(value) {
    if (value < 10) {
      return "0" + value;
    }
    return value;
  };

  var myDate = timestamp ? new Date(timestamp) : new Date();
  var year = myDate.getFullYear();
  var month = zero(myDate.getMonth() + 1);
  var day = zero(myDate.getDate());
  var hour = zero(myDate.getHours());
  var minite = zero(myDate.getMinutes());
  var second = zero(myDate.getSeconds());

  return formats.replace(/Y|m|d|H|i|s/gi, function(matches) {
    return {
      Y: year,
      m: month,
      d: day,
      H: hour,
      i: minite,
      s: second,
    }[matches];
  });
}

/**
 * 时间戳转字符串
 * @param {*} timeStamp 时间戳
 * @returns yyyy-MM-dd HH:mm:ss 固定格式的日期字符串
 */
export function formatDate(timeStamp) {
  var d = new Date(timeStamp); //创建一个指定的日期对象
  return (
    d.getFullYear() +
    "-" +
    (d.getMonth() + 1) +
    "-" +
    d.getDate() +
    " " +
    d.getHours() +
    ":" +
    d.getMinutes() +
    ":" +
    d.getSeconds()
  );
}

/**
 * 计算日期的天数差
 * @param {*} stime 最小日期
 * @param {*} etime 最大日期
 * @returns 日期的天数差
 */
export function getDayDiff(stime, etime) {
  var begin = getDateFromString(stime);
  var end = getDateFromString(etime);
  var result = (end - begin) / (1000 * 60 * 60 * 24); //计算天
  result = result.toFixed(0);
  return result;
}

/**
 * 获取两日期之间日期数组
 * @param {*} stime 最小日期
 * @param {*} etime 最大日期
 * @returns 两日期之间日期数组
 */
export function getDiffDate(stime, etime) {
  var diffDate = [];
  var i = 0;
  while (stime <= etime) {
    diffDate[i] = stime;
    //获取开始日期时间戳
    var stime_ts = new Date(stime).getTime();
    //增加一天时间戳后的日期
    var next_date = stime_ts + 24 * 60 * 60 * 1000;
    // 时间戳转字符串日期
    stime = getMyDate(next_date);
    i++;
  }
  return diffDate;
}

/**
 * 为空判断
 * @param {*} val 参数
 * @returns 返回true是空/false非空
 */
export function isNull(val) {
  return (
    val === "" ||
    val === null ||
    val === undefined ||
    typeof val === "undefined"
  );
}

/**
 * 通过正则表达式校验参数是否保留小数点后一位
 * @param {*} value 参数
 * @returns 返回true 符合保留小数点后一位/false 不符合
 */
export function checkNumber(value) {
  let reg = new RegExp(/^\d+(\.\d{0,1})?$/);
  if (!isNull(value) && reg.test(value)) {
    return true;
  }
  return false;
}

/**
 * 通过正则表达式校验参数是否为包含0的正整数
 * @param {*} value 参数
 * @returns 返回true 是正整数/false 不是正整数
 */
export function checkNumberInteger(value) {
  let reg = new RegExp(/^([1-9]\d*|[0]{1,1})$/);
  if (!isNull(value) && reg.test(value)) {
    return true;
  }
  return false;
}

/**
 * 16进制转rgb
 * @param {*} value 16进制，#ffffff
 * @returns 颜色的rgb值
 */
export function intRgb(value) {
  // 先将#ffffff分割成['ff','ff','ff']
  let list = [value.slice(1, 3), value.slice(3, 5), value.slice(5, 7)];
  list[0] = parseInt(list[0], 16);
  list[1] = parseInt(list[1], 16);
  list[2] = parseInt(list[2], 16);
  return list.join(",");
}

/**
 * rgb转16进制
 * @param {*} value rgb 224,45,71
 * @returns 颜色的rgb值
 */
export function intSex(value) {
  let list = [];
  list[0] = "#";
  list[1] = parseInt(value.split(",")[0], 10).toString(16);
  list[2] = parseInt(value.split(",")[1], 10).toString(16);
  list[3] = parseInt(value.split(",")[2], 10).toString(16);
  return list.join("");
}

/**
 * 计算是否是闰年
 * @param {*} year 2022
 * @returns 返回true 是闰年/false 不是闰年
 */
export function isLeapYear(year) {
  if ((year % 100 != 0 && year % 4 == 0) || year % 400 == 0) {
    return true;
  } else {
    return false;
  }
}

/**
 * 根据长度截取字符串 每个中文字符计为2位
 * @param value 字符串
 * @param len 固定长度
 * @param withOmit 是否填补... false不填补
 * @return 字符串
 */
export function stringLenFunction(str, len, withOmit) {
  var strLen = 0;
  for (var i = 0; i < str.length; i++) {
    var c = str.charCodeAt(i);
    //单字节加1
    if ((c >= 0x0001 && c <= 0x007e) || (0xff60 <= c && c <= 0xff9f)) {
      strLen++;
    } else {
      strLen += 2;
    }
    if (strLen > len) {
      if (withOmit) {
        return str.substr(0, i) + "...";
      } else {
        return str.substr(0, i);
      }
    }
  }
  return str;
}


扁平化数据例子
list: [
  { label: "浙江省", level: 0, PId: 0, code: 330000 },
  { label: "杭州市", level: 1, PId: 330000, code: 330100 },
  { label: "宁波市", level: 1, PId: 330000, code: 330200 },
  { label: "温州市", level: 1, PId: 330000, code: 330300 },
  { label: "嘉兴市", level: 1, PId: 330000, code: 330400 },
  { label: "湖州市", level: 1, PId: 330000, code: 330500 },
  { label: "上城区", level: 2, PId: 330100, code: 330102 },
  { label: "下城区", level: 2, PId: 330100, code: 330103 },
  { label: "江干区", level: 2, PId: 330100, code: 330104 },
  { label: "河南省", level: 0, PId: 0, code: 410000 },
  { label: "郑州市", level: 1, PId: 410000, code: 410100 },
  { label: "开封市", level: 1, PId: 410000, code: 410200 },
  { label: "陕西省", level: 0, PId: 0, code: 715200 },
  { label: "西安市", level: 1, PId: 715200, code: 715201 },
  { label: "咸阳市", level: 1, PId: 715200, code: 715202 },
  { label: "宝鸡市", level: 1, PId: 715200, code: 715203 },
  { label: "铜川市", level: 1, PId: 715200, code: 715204 },
  { label: "渭南市", level: 1, PId: 715200, code: 715205 },
  { label: "延安市", level: 1, PId: 715200, code: 715206 },
  { label: "澄城县", level: 2, PId: 715205, code: 715250 },
  { label: "富平县", level: 2, PId: 715205, code: 715250 },
  { label: "蒲城县", level: 2, PId: 715205, code: 715250 },
]

/**
 * 将扁平化数据处理为树形数据
 * 当前的PId等于父级的code
 * @param data 扁平化数据数组
 * @return 树形数组
 */
export function listToTree(data) {
  return data.filter((parentItem) => {
    // 每一级的数据filterD
    const filterD = data.filter((item) => {
      return parentItem.code === item.PId;
    });
    //
    // 取filterD长度大于0 的
    filterD.length > 0 ? (parentItem.children = filterD) : "";
    // 只取PId为0的,也就是最顶层
    return parentItem.PId === 0;
  });
}

/**
 * 将树形数据处理为扁平化数据(多级) 用递归
 * @param {*} data 树形数组
 * @returns 扁平化数据数组
 */
export function treeToList(data) {
  var list = [];
  const funChild = (childData) => {
    childData.forEach((element) => {
      element.children && element.children.length > 0
        ? funChild(element.children)
        : ""; //子级递归
      delete element.children;//删除children 根据需求看是否需要删除
      list.push(element);
    });
  };
  funChild(data);
  return list;
}