博客

/*
 * @Author: YX
 * @Date: 2022-05-24 13:50:21
 * @LastEditTime: 2022-05-24 14:06:10
 */

/**
 * 判断数据类型
 * @param {any} params 要判断的数据
 * @param {any} type 要判断的数据类型
 * @return  Boolean
 */
function type(params, type) {
  return Object.prototype.toString.call(params) == `[object ${type}]`
    ? true
    : false;
}
/**
 * string类型转换为number类型
 * @param {string} params 要转换的字符串
 * @return Number
 */
function number(params) {
  return +params;
}
/**
 * 过滤掉假值的新数组
 * @param {array} params 要过滤的数组
 * @return Array
 */
function compact(params) {
  return params.filter((item) => Boolean(item));
}

/**
 * 数组去重
 * @param {array} params 数组
 * @return Array
 */
function set(params) {
  return [...new Set(params)];
}
/**
 * 数组对象去重
 * @param {array} params 数组
 * @param {string} name 对象的属性名
 * @returns Array
 *
 */
function map(params, name) {
  const map = new Map();
  return params.filter(
    (item) => !map.has(item[name]) && map.set(item[name], item)
  );
}
/**
 *  数组合并
 * @param {array} arr 要合并的数组
 * @param {array} newArr 要合并的数组
 * @return Array
 */
function concat(arr, newArr) {
  return [...arr, ...newArr];
}
/**
 *  对象合并
 * @param {object} obj 要合并的对象
 * @param {object} newObj 要合并的对象
 * @return Object
 */
function assign(obj, newObj) {
  //  return Object.assign({},obj, newObj);
  return { ...obj, ...newObj };
}
/**
 *  对象深拷贝
 * @param {object} params 要拷贝的对象
 * @return Object
 */
function deepObject(params) {
  // let cloneObj = type(params, "Array") ? [] : {};
  // for (let k in params) {
  //   cloneObj[k] = type(params[k], "Object") ? deepObject(params[k]) : params[k];
  // }
  // return cloneObj;
  return JSON.parse(JSON.stringify(params));
}

/**
 * 时间处理
 * @param {Date} data 默认为当前时间
 * @param {string} format 时间格式
 * @param {boolean} isRepair 是否补0
 * @return String
 */
function formatDate(
  data = Date.now(),
  format = "YYYY-MM-DD HH:mm:ss",
  isRepair = true
) {
  let date = new Date(data);
  const config = {
    YYYY: date.getFullYear(),
    MM: repair(date.getMonth() + 1),
    DD: repair(date.getDate()),
    HH: repair(date.getHours()),
    mm: repair(date.getMinutes()),
    ss: repair(date.getSeconds()),
  };
  //补0操作
  function repair(param) {
    return isRepair ? (param < 10 ? "0" + param : param) : param;
  }
  for (const key in config) {
    format = format.replace(key, config[key]);
  }
  return format;
}

/**
 * 数组求和
 * @param {array} params 要求和的数组
 * @return Number
 */
function sum(params) {
  return params.reduce((cut, next) => cut + next, 0);
}

/**
 * 防抖
 * @param {function} fn 要执行的函数
 * @param {number} timeout 要延迟的时间
 * @return Function
 */
function debounce(fn, timeout = 1000) {
  let isTimeout = null;
  return function () {
    if (isTimeout) clearTimeout(isTimeout);
    isTimeout = setTimeout(fn, timeout);
  };
}
/**
 * 节流
 * @param {function} fn 要执行的函数
 * @param {number} timeout 要延迟的时间
 * @return Function
 */
function throttle(fn, timeout) {
  let isTimeout = null;
  return function () {
    if (isTimeout) return;
    isTimeout = setTimeout(() => {
      fn();
      isTimeout = null;
    }, timeout);
  };
}

/**
 * 查找数组的属性值
 * @param {array} params
 * @param {number|string} v
 * @return Number|String
 */
function find(params, v) {
  return params.find((item) => item == v);
}
/**
 *  查找对象
 * @param {array} params
 * @param {string} findV 要查找的字段
 * @param {number|string} v 要查找的值
 * @return Object
 */
function findObj(params, findV, v) {
  return params.find((item) => item[findV] == v);
}
/**
 *  判断在数组中是否存在
 * @param {array} params
 * @param {string|number} v
 * @return Boolean
 */
function includes(params, v) {
  return params.includes(v);
}
/**
 * 扁平化数组
 * @param {array} params
 * @return Array
 */
function flat(params) {
  return params.flat(Infinity);
}


/**
 *async await 错误封装
 * @param {Promise} promise
 * @returns [err,data]
 */
const awaitWrap = (promise) => {
  return promise.then((data) => [null, data]).catch((err) => [err, null]);
};
 let data = await awaitWrap(getUserInfo());
  console.log(data);