javaScript功能函数封装分享-持续更新

本篇博客是关于常用js功能函数汇总，对你有帮助的话记得点赞➕关注！

1、判断时间戳格式是否是毫秒

/**
 * @param {Number} timeStamp 判断时间戳格式是否是毫秒
 * @returns {Boolean}
 */
const isMillisecond = timeStamp => {
  const timeStr = String(timeStamp);
  return timeStr.length > 10;
};

2、传入的时间戳是否早于当前时间戳

/**
 * @param {Number} timeStamp 传入的时间戳
 * @param {Number} currentTime 当前时间时间戳
 * @returns {Boolean} 传入的时间戳是否早于当前时间戳
 */
const isEarly = (timeStamp, currentTime) => {
  return timeStamp < currentTime;
};

3、如果传入的数值小于10，即位数只有1位，则在前面补充0

/**
 * @param {Number} num 数值
 * @returns {String} 处理后的字符串
 * @description 如果传入的数值小于10，即位数只有1位，则在前面补充0
 */
const getHandledValue = num => {
  return num < 10 ? "0" + num : num;
};

4、判断要查询的数组是否至少有一个元素包含在目标数组中

/**
 * @param {Array} target 目标数组
 * @param {Array} arr 需要查询的数组
 * @description 判断要查询的数组是否至少有一个元素包含在目标数组中
 */
export const hasOneOf = (targetarr, arr) => {
  return targetarr.some(_ => arr.indexOf(_) > -1);
};

5、判断两个对象是否相等，这两个对象的值只能是数字或字符串

/**
 * @param {*} obj1 对象
 * @param {*} obj2 对象
 * @description 判断两个对象是否相等，这两个对象的值只能是数字或字符串
 */
export const objEqual = (obj1, obj2) => {
  const keysArr1 = Object.keys(obj1);
  const keysArr2 = Object.keys(obj2);
  if (keysArr1.length !== keysArr2.length) return false;
  else if (keysArr1.length === 0 && keysArr2.length === 0) return true;
  /* eslint-disable-next-line */
  else
    return !keysArr1.some(key => obj1[key] != obj2[key]);
};

6、 返回 n-m之间随机数

/**
 * @description 返回 n-m之间随机数
 */
export const getRandom = (n, m) => {
  n = Number(n);
  m = Number(m);
  // 确保 m 始终大于 n
  if (n > m) {
    var temp = n;
    n = m;
    m = temp;
  }
  // 下有详细说明
  return Math.floor(Math.random() * (m - n) + n);
};

7、 随机生成校验码

/**
 * @param {*} num 个数
 * @description 随机生成校验码
 */
export const randomCode = num => {
  let codeStr = "abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNOPQRSTUVWXYZ0123456789";
  let str = "";
  // 验证码有几位就循环几次
  for (var i = 0; i < num; i++) {
    var ran = getRandom(0, 60);
    str += codeStr.charAt(ran);
  }
  return str;
};

8、 深度合并数据

/**
 * @description 深度合并数据
 * @param 
 */
export function deepMerge(obj1, obj2) {
  for (let key in obj2) {
    // 如果target(也就是obj1[key])存在，且是对象的话再去调用deepMerge，否则就是obj1[key]里面没这个对象，需要与obj2[key]合并
    // 如果obj2[key]没有值或者值不是对象，此时直接替换obj1[key]
    obj1[key] =
      obj1[key] &&
      obj1[key].toString() === "[object Object]" &&
      obj2[key] && obj2[key].toString() === "[object Object]" ?
      deepMerge(obj1[key], obj2[key]) :
      (obj1[key] = obj2[key]);
  }
  return obj1;
}

9、 格式化日期

/**
 * @description 格式化日期
 * @param date new Date()
 * @param type d日 m月 y年
 * @param next 之前 多少天 多少月 多少年
 * @param format 返回格式
 */
export function formatDate({
  date = new Date(),
  format = "yyyy-MM-dd",
  type,
  next
}) {
  const opt = {
    "y+": date.getFullYear(), // 年
    "M+": date.getMonth() + 1, // 月
    "d+": date.getDate(), // 日
    "h+": date.getHours(), // 时
    "m+": date.getMinutes(), // 分
    "s+": date.getSeconds() // 秒
  };
  if (type && next) {
    switch (type) {
      case "y":
        opt["y+"] = opt["y+"] - next;
        break;
      case "m":
        opt["y+"] = opt["y+"] - parseInt(next / 12);
        if (next % 12 < opt["M+"]) {
          opt["M+"] = opt["M+"] - (next % 12);
        } else {
          //当大于当前月
          opt["y+"] = opt["y+"] - parseInt(next / 12) - 1;
          opt["M+"] = 12 + opt["M+"] - (next % 12);
        }
        break;
      case "d":
        let timer = 1000 * 60 * 60 * 24 * next;
        let newDate = new Date(date.getTime() - timer);
        opt["y+"] = newDate.getFullYear();
        opt["M+"] = newDate.getMonth() + 1;
        opt["d+"] = newDate.getDate();
        break;
      default:
        break;
    }
  }
  for (var k in opt) {
    if (k == "y+") {
      if (/(y+)/.test(format))
        format = format.replace(
          RegExp.$1,
          (opt[k] + "").substr(4 - RegExp.$1.length)
        );
    } else {
      if (new RegExp("(" + k + ")").test(format)) {
        format = format.replace(
          RegExp.$1,
          RegExp.$1.length == 1 ?
          opt[k] :
          ("00" + opt[k]).substr(("" + opt[k]).length)
        );
      }
    }
  }
  return format;
}

10、 函数防抖

/**
 * @description 函数防抖
 * @param fn 目标函数
 * @param delay 时间
 */
export function debounce(fn, delay) {
  let timeout = null; // 创建一个标记用来存放定时器的返回值
  return function (e) {
    // 每当用户输入的时候把前一个 setTimeout clear 掉
    clearTimeout(timeout);
    // 然后又创建一个新的 setTimeout, 这样就能保证interval 间隔内如果时间持续触发，就不会执行 fn 函数
    timeout = setTimeout(() => {
      fn.apply(this, arguments);
    }, delay);
  };
}

11、 函数截流

/**
 * @description 截流
 * @param handler 目标函数
 * @param wait 时间
 */
export function throttle(handler, wait) {
  // handler为函数  wait为时间
  var lastTime = 0;
  return function () {
    var nowTime = new Date().getTime(); //获取时间
    if (nowTime - lastTime > wait) {
      // 判断当前单击和上次单击的时间是否超过规定的时间
      handler();
      lastTime = nowTime; // 执行后将上次时间进行更新
    }
  };
}

12、 判断是否为对象

/**
 * @description 判断是否为对象
 * @param 
 */
function isObject(obj) {
  return Object.prototype.toString.call(obj) === "[object Object]";
}

13、 判断是否数组

/**
 * @description 判断是否数组
 * @param 
 */
function isArray(arr) {
  return Object.prototype.toString.call(arr) === "[object Array]";
}

14、 数组扁平化

/**
 * @description 数组扁平化
 * @param {arr, childKey, selKey, onlyChild} 扁平类数组, 子节点的字段, 获取字段的键子对, 是否获取最底层的键值
 */
export function flatten(arr, childKey, selKey, onlyChild = false) {
  if (!Array.isArray(arr)) return arr;
  return arr.reduce((pre, cur) => {
    if (childKey && Array.isArray(cur[childKey]) && cur[childKey].length > 0) {
      if (!onlyChild && selKey) pre.push(cur[selKey]);
      return pre.concat(flatten(cur[childKey], childKey, selKey, onlyChild))
    } else {
      return pre.concat(cur[selKey])
    }
  }, [])
}