common-utils-kit 1.1.5 → 1.1.19

package/src/format.js

@@ -1,246 +0,0 @@
-/**
- * 获取对象属性值，支持可选链操作符的形式
- * @param {Object} obj - 要获取属性值的对象
- * @param {string} key - 属性路径，可以包含点号（'.'）表示深层嵌套属性
- * @returns {*} - 返回属性值，如果属性不存在则返回 undefined
- * @example
- * const data = {
- *   parent: {
- *     child: {
- *       value: 'Hello, World!'
- *     }
- *   }
- * };
- * const nestedValue = getProperty(data, 'parent.child.value');
- * console.log(nestedValue); // 输出: Hello, World!
- */
-export function getProperty(obj, key) {
-  if (!obj) { return }
-  if (typeof key !== 'string' || key === '') {
-    return ''
-  }
-  if (key.indexOf('.') !== -1) {
-    const keys = key.split('.')
-    let firstObj = obj[keys[0]] || {}
-    for (let i = 1; i < keys.length; i++) {
-      if (firstObj) {
-        firstObj = firstObj[keys[i]]
-      }
-    }
-    return firstObj
-  }
-  return obj[key]
-}
-
-/**
- * @description 数组对象去重
- * @param {array} data 需要去重的原数组对象
- * @param {string} parameter 去重数组的唯一码(关键字)
- * @returns {Array} - 返回去重后的数组对象
- * @example
- * // 使用示例
- * const data = [{ id: 1, name: 'John' },{ id: 2, name: 'Jane' },{ id: 1, name: 'John' },{ id: 3, name: 'Doe' }];
- * const uniqueData = unrepeated(data, 'id');
- * console.log(uniqueData); // 输出: [{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }, { id: 3, name: 'Doe' }]
- */
-export function unrepeated(data, parameter) {
-  var temp = {};
-  var tempData = JSON.parse(JSON.stringify(data)); // 深拷贝原来的数据
-  var newData = tempData.reduce((pre, cur) => {
-    if (!temp[cur[parameter]] && cur[parameter]) {
-      temp[cur[parameter]] = true;
-      pre.push(cur);
-    }
-    return pre;
-  }, []);
-  return newData;
-}
-
-/**
- * @description 将树形数据转化为一维数组
- * @param {Array} previous - 树形结构数据
- * @param {string} bind - 树形结构中下级节点的绑定属性，默认为 'children'
- * @returns {Array} - 一维数组
- * @example
- * const treeData = [{ id: 1,
- *     label: 'parent 1',
- *     children: [{ id: 2, label: 'child 1' },{ id: 3, label: 'child 2' }]
- *   },{id: 4,
- *     label: 'parent 2',
- *     children: [{ id: 5, label: 'child 3' },{ id: 6, label: 'child 4' }]
- *   }];
- * const flatArray = treeToFlat(treeData,'children');
- * console.log(flatArray);
- * // 输出：[ { id: 1, label: 'parent 1' },{ id: 2, label: 'child 1' }, { id: 3, label: 'child 2' }, { id: 4, label: 'parent 2' },{ id: 5, label: 'child 3' },{ id: 6, label: 'child 4' }]
- */
-export function treeToFlat(previous=[], bind = 'children') {
-  const result = []
-  previous.forEach(item => {
-    const clonedItem = { ...item };
-    if (clonedItem[bind]) {
-      result.push(clonedItem)
-      if (Array.isArray(previous) && clonedItem[bind].length > 0) {
-        result.push(...treeToFlat(clonedItem[bind]))
-      }
-    } else {
-      result.push(clonedItem)
-    }
-  })
-  return result
-}
-
-/**
- * @description 将一维数组转树形结构
- * @param {Array} flatArray - 树形结构数据
- * @param {string} [rootValue=null] - 树形结构一级父 id，默认为 null
- * @param {string} [bind="pid"] - 父 id 的属性，默认为 "pid"
- * @returns {Array} - 树形结构
- * @example
- * const flatArray = [
- *   { id: 1, label: 'Node 1', pid: null },
- *   { id: 2, label: 'Node 2', pid: 1 },
- *   { id: 3, label: 'Node 3', pid: 1 },
- *   { id: 4, label: 'Node 4', pid: 2 },
- *   { id: 5, label: 'Node 5', pid: 2 },
- *   { id: 6, label: 'Node 6', pid: 3 },
- *   { id: 7, label: 'Node 7', pid: null },
- *   { id: 8, label: 'Node 8', pid: 3 },
- * ];
- * const treeData = flatToTree(flatArray);
- * console.log(treeData);
- * // 输出: [
- * //   {
- * //     id: 1,
- * //     label: 'Node 1',
- * //     pid: null,
- * //     children: [
- * //       { id: 2, label: 'Node 2', pid: 1, children: [ { id: 4, label: 'Node 4', pid: 2 }, { id: 5, label: 'Node 5', pid: 2 } ] },
- * //       { id: 3, label: 'Node 3', pid: 1, children: [ { id: 6, label: 'Node 6', pid: 3, children: [ { id: 8, label: 'Node 8', pid: 6 } ] } ] },
- * //     ],
- * //   },
- * //   { id: 7, label: 'Node 7', pid: null },
- * // ]
- */
-export function flatToTree(flatArray, rootValue = null, bind = "pid") {
-  const tree = [];
-  flatArray.forEach(item => {
-    if (item[bind] === rootValue) {
-      const children = flatToTree(flatArray, item.id);
-      item.children = children && children.length ? children : []
-      tree.push(item);
-    }
-  });
-  return tree.length > 0 ? tree : null; // 处理不存在的根节点
-}
-
-/**
- * 递归封装
- * @param {Array} data - 待处理的数据
- * @param {Function} funName - 处理每个节点的方法
- * @param {string} [bind="children"] - 子节点绑定属性的名称，默认为 "children"
- * @returns {Array} - 处理后的树形结构数据
- * @example
- * // 数据结构
- * const treeData = [{ id: 1,
- *     label: 'parent 1',
- *     children: [{ id: 2, label: 'child 1' },{ id: 3, label: 'child 2' }]
- *   },{id: 4,
- *     label: 'parent 2',
- *     children: [{ id: 5, label: 'child 3' },{ id: 6, label: 'child 4' }]
- *   }];
- *
- * // 处理逻辑函数，
- * function processFunction(node) {
- *   return { label: node.label.toUpperCase() };
- * }
- * // 使用递归封装方法
- * const processedTree = recursionFunction(treeData, processFunction);
- */
-export function recursionFunction(data, processFunction, bind = 'children') {
-  function internalRecursion(previous=[], initial) {
-    return previous.map((element, i) => {
-      const menus = initial[i] ? processFunction(initial[i]) : {};
-      const children = element[bind] && Array.isArray(element[bind]) && element[bind].length > 0
-        ? internalRecursion(element[bind], initial[i][bind])
-        : [];
-      return { ...menus,[bind]: children };
-    });
-  }
-  return internalRecursion(data, data);
-}
-
-/**
- *  解析给定函数中switch case语句中的数据并返回提取出值的数组对象。
- * @param {function} filterMethod - 包含带有条件和标签的 case 的函数。
- * @returns {Array} - 包含提取出的值和标签的对象数组。
- * @example
- * const filterMethod = (item) => {
- *   switch (item) {
- *     case 1://若是字符串请使用单引号
- *       return "是";
- *     case 2://若是字符串请使用单引号
- *       return "否";
- *     default:
- *       return "数据异常";
- *   }
- * };
- * 使用
- * filterData(filterMethod)//[{label:"是"，value:1},{label:"否"，value:2}]
- */
-export function filterData(filterMethod) {
-  const funStrArr = filterMethod.toString().split("case");
-  if (funStrArr.length < 1) return []
-  const list = [];
-  for (let i = 1; i < funStrArr.length; i++) {
-    const condition = funStrArr[i].split(":")[0].replace(/\s*/g, "").replace(/(\"*)/g, "");
-    const value = JSON.parse(condition.replace(/'/g, '"'))
-    const label = funStrArr[i].split("return")[1].split(";")[0].replace(/\s*/g, "").replace(/(\"*)/g, "");
-    if (value || value === 0 || value === false) {
-      list.push({ value, label });
-    }
-  }
-  return list;
-}
-/**
- * @description 计算时间差(单位：天)
- * @param {Date} startDate 开始时间 默认当前时间
- * @param {Date} endDate 结束时间 默认当前时间
- * @returns {number} 时间差（天）
- * @example DateDiff(开始时间,结束时间)
- */
-export function dateDiff(startDate = new Date(), endDate = new Date()) {
-  const MS_PER_DAY = 24 * 60 * 60 * 1000; // 一天的毫秒数
-  const startTimestamp = new Date(startDate).setHours(0, 0, 0, 0);
-  const endTimestamp = new Date(endDate).setHours(0, 0, 0, 0);
-  const timeDiff = endTimestamp - startTimestamp;
-  const daysDiff = Math.floor(timeDiff / MS_PER_DAY);
-  return daysDiff;
-}
-/**
- * @description 获取当前时间（年月日）
- * @returns {string} 当前时间字符串，格式为 "YYYY-MM-DD"
- * @example getNowDate()
- */
-export function getNowDate() {
-  const timeOne = new Date();
-  const year = timeOne.getFullYear();
-  const month = String(timeOne.getMonth() + 1).padStart(2, '0');
-  const day = String(timeOne.getDate()).padStart(2, '0');
-  return `${year}-${month}-${day}`;
-}
-
-/**
- * @description form的下拉框  级联选择器等数据赋值
- * @param {Array} columns - form的columns数据
- * @param {String} targetLabel - 需要赋值的columns[i]的label
- * @param {Array} newData - 想要赋值的数据
- * @returns {Array} 包含data的Columns数据
- * @example  setFormColumnsData(this.columns, '下单医生', result.data)
- */
-export function setFormColumnsData(columns, targetLabel, newData) {
-  var targetIndex = columns.findIndex(item => item.label === targetLabel);
-  if (targetIndex !== -1) {
-    columns[targetIndex].data = newData;
-  }
-  return columns;
-}

package/src/test.js

@@ -1,153 +0,0 @@
-
-/**
- * 验证是否有值，除了 0、undefined、''、false、null、{}、[] 为空，其他都属于有值
- * @param {*} value - 要验证的值
- * @param {string} type - 类型检查（可选），当类型为 'number' 时会将 0 视为有值
- * @returns {boolean} - 如果有值返回 true，否则返回 false
- * @example
- * // 使用示例
- * console.log(hasValue('   Hello   ')); // 输出: true
- * console.log(hasValue(0, 'number'),hasValue(0)); // 传入类型number，0也是有值 输出: true  false
- * console.log(hasValue(true)); // 输出: true
- * console.log(hasValue([1, 2, 3]),hasValue([])); // 输出: true  false
- * console.log(hasValue({ key: 'value' }),hasValue({})); // 输出: true false
- * console.log(hasValue(undefined)); // 输出: false
- * console.log(hasValue(null)); // 输出: false
- */
-export function hasValue(value, type) {
-  switch (typeof value) {
-    case 'undefined':
-      return false;
-    case 'string':
-      return (type === 'string' || !type) && value.trim().length > 0;
-    case 'boolean':
-      return (type === 'boolean' || !type) && !!value;
-    case 'number':
-      return (type === 'number' || !type) && ((type === 'number' || value !== 0) && !isNaN(value));
-    case 'object':
-      if (value === null) return false;
-      if (Array.isArray(value)) return (type === 'array' || !type) && value.length > 0;
-      return (type === 'object' || !type) && Object.keys(value).length > 0;
-  }
-  return false;
-}
-
-/**
- * 获取值的数据类型
- * @param {*} value - 要获取类型的值
- * @returns {string} - 返回值的数据类型，包括 'string'、'number'、'boolean'、'function'、'array'、'object'、'null' 等
- * @example
- * // 使用示例
- * console.log(valueType('Hello')); // 输出: 'string'
- * console.log(valueType(42)); // 输出: 'number'
- * console.log(valueType(true)); // 输出: 'boolean'
- * console.log(valueType(function () {})); // 输出: 'function'
- * console.log(valueType([1, 2, 3])); // 输出: 'array'
- * console.log(valueType({ key: 'value' })); // 输出: 'object'
- * console.log(valueType(null)); // 输出: 'null'
- */
-export function valueType(value) {
-  const type = typeof value;
-  switch (type) {
-    case 'string':
-    case 'number':
-    case 'boolean':
-    case 'function':
-      return type;
-    case 'object':
-      if (value === null) {
-        return 'null';
-      } else if (Array.isArray(value)) {
-        return 'array';
-      } else if (Object.prototype.toString.call(value) === '[object Object]') {
-        return 'object';
-      }
-      break;
-  }
-}
-
-/**
- * 验证电子邮箱格式
- */
-export function email(value) {
-  return /^\w+((-\w+)|(\.\w+))*\@[A-Za-z0-9]+((\.|-)[A-Za-z0-9]+)*\.[A-Za-z0-9]+$/.test(value)
-}
-
-/**
- * 验证手机格式
- */
-export function mobile(value) {
-  return /^1[23456789]\d{9}$/.test(value)
-}
-
-/**
- * 验证URL格式
- */
-export function url(value) {
-  return /^((https|http|ftp|rtsp|mms):\/\/)(([0-9a-zA-Z_!~*'().&=+$%-]+: )?[0-9a-zA-Z_!~*'().&=+$%-]+@)?(([0-9]{1,3}.){3}[0-9]{1,3}|([0-9a-zA-Z_!~*'()-]+.)*([0-9a-zA-Z][0-9a-zA-Z-]{0,61})?[0-9a-zA-Z].[a-zA-Z]{2,6})(:[0-9]{1,4})?((\/?)|(\/[0-9a-zA-Z_!~*'().;?:@&=+$,%#-]+)+\/?)$/
-    .test(value)
-}
-
-/**
- * 验证身份证号码
- */
-export function idCard(value) {
-  return /^[1-9]\d{5}[1-9]\d{3}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{3}([0-9]|X)$/.test(
-    value
-  )
-}
-
-/**
- * 是否车牌号
- */
-export function carNo(value) {
-  // 新能源车牌
-  const xreg = /^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领A-Z]{1}[A-Z]{1}(([0-9]{5}[DF]$)|([DF][A-HJ-NP-Z0-9][0-9]{4}$))/
-  // 旧车牌
-  const creg = /^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领A-Z]{1}[A-Z]{1}[A-HJ-NP-Z0-9]{4}[A-HJ-NP-Z0-9挂学警港澳]{1}$/
-  if (value.length === 7) {
-    return creg.test(value)
-  } if (value.length === 8) {
-    return xreg.test(value)
-  }
-  return false
-}
-
-/**
- * 金额,只允许2位小数
- */
-export function amount(value) {
-  // 金额，只允许保留两位小数
-  return /^[1-9]\d*(,\d{3})*(\.\d{1,2})?$|^0\.\d{1,2}$/.test(value)
-}
-
-/**
- * 中文
- */
-export function chinese(value) {
-  const reg = /^[\u4e00-\u9fa5]+$/gi
-  return reg.test(value)
-}
-
-/**
- * 只能输入字母
- */
-export function letter(value) {
-  return /^[a-zA-Z]*$/.test(value)
-}
-
-/**
- * 是否固定电话
- */
-export function landline(value) {
-  const reg = /^\d{3,4}-\d{7,8}(-\d{3,4})?$/
-  return reg.test(value)
-}
-
-/**
- * 是否短信验证码
- */
-export function code(value, len = 6) {
-  return new RegExp(`^\\d{${len}}$`).test(value)
-}
-

package/src/tool.js

@@ -1,84 +0,0 @@
-
-
-let timeout = null
-/**
- * 函数防抖
- * @param {number} time - 防抖间隔时间，单位毫秒
- * @returns {Promise<boolean>} - 返回一个 Promise，在防抖时间内触发 resolve(true)
- * @example
- * debounce(time).then(res => {
- *  执行方法
- * })
- */
-export function debounce(time = 500) {
-  return new Promise((resolve) => {
-    if (timeout !== null) clearTimeout(timeout);
-    timeout = setTimeout(() => {
-      resolve(true)
-    }, time)
-  })
-}
-
-/**
-* @description 节流
-* @param {number} time 每time秒调用一次 默认0.5秒
-* @param {boolean} immediately 是否立即执行一次 默认true
-* @example
-* throttle(time,immediately).then(res => {
-*  执行方法
-* })
-*/
-
-let wait = null;
-export function throttle(time = 500, immediately=true) {
-  return new Promise((resolve) => {
-    if (immediately && (!wait || Date.now() - wait >= time)) {
-      resolve(true);
-      wait = Date.now();
-      setTimeout(() => {
-        wait = null;
-      }, time);
-    }
-    if (!immediately && !wait) {
-      wait = setTimeout(() => {
-        resolve(true);
-        wait = null;
-      }, time);
-    }
-  });
-}
-
-
-// /**
-// * @description 节流
-// * @param {number} time 每time秒调用一次 默认0.5秒
-// * @example
-// * throttle(time).then(res => {
-// *  执行方法
-// * })
-// */
-// let wait = null
-// export function throttle(time = 500) { //防抖  // 默认0.2秒后执行事件
-//   return new Promise((resolve) => {
-//     if (wait) { return }
-//     wait = setTimeout(() => {
-//       resolve(true)
-//       wait = null
-//     }, time)
-//   })
-// }
-
-/**
- * @description 进行阻塞延时，以达到可以简写代码的目的
- * @param {number} value 堵塞时间 单位ms 毫秒
- * @returns {Promise} 返回promise
- * @example
- * await sleep(1000);
- */
-export function sleep(value = 100) {
-	return new Promise((resolve) => {
-		setTimeout(() => {
-			resolve()
-		}, value)
-	})
-}