common-utils-kit 1.0.0 → 1.0.5

package/README.md

@@ -1,33 +1,17 @@
-# fullstack-admin-serve
 
-## 开发
-```
-# 查看配置是否为npm源
-npm config get registry
-# 配置为npm源
-npm config set registry https://registry.npmjs.org/
-#登录npm账号
-npm adduser
-例：如果报错为request to https://registry.npmjs.org/-/v1/login failed, reason: connect ETIMEDOUT 104.16.0.35:443
-切换为：npm config set registry https://registry.npmmirror.com/后
-再次切换到：npm config set registry https://registry.npmjs.org/
-
-
-# 启动服务
-npm run dev
+## Common Utils Kit
 
-# 预览发布环境效果
-npm run preview
+`common-utils-kit`是一个包含常用函数的npm包，提供了一系列验证、防抖节流、数据格式化等功能
 
-# 预览发布环境效果 + 静态资源分析
-npm run preview -- --report
-
-# 构建生产环境
-npm run build:prod
+## 使用
+```
+# 安装
+npm i common-utils-kit
+# 引入
+import {test,format,tool} from "common-utils-kit/src/test";
+# 使用
+test //验证数据类型 例：test.number(1)
+format  // 格式化数据 例：
+tool //工具函数
 ```
-浏览器访问 [http://localhost:9528](http://localhost:9528)
 
-## 依赖
-1. ```depcheck``` 检查依赖是否使用。
-2. https://gitee.com/panjiachen/vue-element-admin/
-2.

package/index.js

@@ -1,5 +1,11 @@
-import test from './src/test.js'
-export {
-  test
+
+import * as test from './src/test.js';
+import * as format from './src/format.js';
+import * as tool from './src/tool.js';
+console.log(' ', tool.antiShake())
+export default {
+  test: { test },
+  format: { format },
+  tool: { tool }
 }
 // https://www.cnblogs.com/oldCode/p/learnjts.html

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "common-utils-kit",
-  "version": "1.0.0",
+  "version": "1.0.5",
   "description": "",
   "main": "index.js",
   "type": "module",

package/src/format.js

@@ -0,0 +1,85 @@
+/**
+* 获取对象属性值，支持可选链操作符的形式
+* @param {Object} obj - 要获取属性值的对象
+* @param {string} key - 属性路径，可以包含点号（'.'）表示深层嵌套属性
+* @returns {*} - 返回属性值，如果属性不存在则返回 undefined
+*/
+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} - 返回去重后的数组对象
+ */
+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} - 一维数组
+ */
+export function treeToFlat(previous, bind = 'children') {
+  const result = []
+  previous.forEach(item => {
+    const clonedItem = { ...item };
+    if (clonedItem[bind]) {
+      result.push(clonedItem)
+      if (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} - 树形结构
+ */
+export function flatToTree(flatArray, rootValue = null, bind = "pid") {
+  const tree = [];
+  flatArray.forEach(item => {
+    if (item[bind] === rootValue) {
+      const children = flatToTree(flatArray, item.id);
+      if (children.length) {
+        item.children = children;
+      }
+      tree.push(item);
+    }
+  });
+  return tree.length > 0 ? tree : null; // 处理不存在的根节点
+}

package/src/test.js

@@ -1,249 +1,306 @@
+
+/**
+ * 验证是否有值，除了 0、undefined、''、false、null、{}、[] 为空，其他都属于有值
+ * @param {*} value - 要验证的值
+ * @param {string} type - 类型检查（可选），当类型为 'number' 时会将 0 视为有值
+ * @returns {boolean} - 如果有值返回 true，否则返回 false
+ */
+export function hasValue(value, type) {
+  switch (typeof value) {
+    case 'undefined':
+      return false;
+    case 'string':
+      return value.replace(/(^[ \t\n\r]*)|([ \t\n\r]*$)/g, '').length > 0;
+    case 'boolean':
+      return !!value;
+    case 'number':
+      return (type === 'number' || value !== 0) && !isNaN(value);
+    case 'object':
+      if (value === null || value.length === 0) return false;
+      for (const i in value) {
+        return true; // 只要对象有属性就认为有值
+      }
+      return false;
+  }
+  return false;
+}
+
+/**
+ * 获取值的数据类型
+ * @param {*} value - 要获取类型的值
+ * @returns {string} - 返回值的数据类型，包括 'string'、'number'、'boolean'、'function'、'array'、'object'、'null' 等
+ */
+export function valueType(value) {
+  switch (typeof value) {
+    case 'string':
+      return 'string';
+    case 'number':
+      return 'number';
+    case 'boolean':
+      return 'boolean';
+    case 'function':
+      return 'function';
+    case 'object':
+      if (value === null) {
+        return 'null';
+      } else if (typeof Array.isArray === 'function' && Array.isArray(value)) {
+        return 'array';
+      } else if (Object.prototype.toString.call(value) === '[object Array]') {
+        return 'array';
+      } else if (Object.prototype.toString.call(value) === '[object Object]') {
+        return 'object';
+      }
+      break;
+  }
+}
+
 /**
  * 验证电子邮箱格式
  */
-function email(value) {
-    return /^\w+((-\w+)|(\.\w+))*\@[A-Za-z0-9]+((\.|-)[A-Za-z0-9]+)*\.[A-Za-z0-9]+$/.test(value)
+export function email(value) {
+  return /^\w+((-\w+)|(\.\w+))*\@[A-Za-z0-9]+((\.|-)[A-Za-z0-9]+)*\.[A-Za-z0-9]+$/.test(value)
 }
 
 /**
  * 验证手机格式
  */
-function mobile(value) {
-    return /^1[23456789]\d{9}$/.test(value)
+export function mobile(value) {
+  return /^1[23456789]\d{9}$/.test(value)
 }
 
 /**
  * 验证URL格式
  */
-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 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)
 }
 
 /**
  * 验证日期格式
  */
-function date(value) {
-    if (!value) return false
-    // 判断是否数值或者字符串数值(意味着为时间戳)，转为数值，否则new Date无法识别字符串时间戳
-    if (number(value)) value = +value
-    return !/Invalid|NaN/.test(new Date(value).toString())
+export function date(value) {
+  if (!value) return false
+  // 判断是否数值或者字符串数值(意味着为时间戳)，转为数值，否则new Date无法识别字符串时间戳
+  if (number(value)) value = +value
+  return !/Invalid|NaN/.test(new Date(value).toString())
 }
 
 /**
  * 验证ISO类型的日期格式
  */
-function dateISO(value) {
-    return /^\d{4}[\/\-](0?[1-9]|1[012])[\/\-](0?[1-9]|[12][0-9]|3[01])$/.test(value)
+export function dateISO(value) {
+  return /^\d{4}[\/\-](0?[1-9]|1[012])[\/\-](0?[1-9]|[12][0-9]|3[01])$/.test(value)
 }
 
 /**
  * 验证十进制数字
  */
-function number(value) {
-    return /^[\+-]?(\d+\.?\d*|\.\d+|\d\.\d+e\+\d+)$/.test(value)
+export function number(value) {
+  return /^[\+-]?(\d+\.?\d*|\.\d+|\d\.\d+e\+\d+)$/.test(value)
 }
 
 /**
  * 验证字符串
  */
-function string(value) {
-    return typeof value === 'string'
+export function string(value) {
+  return typeof value === 'string'
 }
 
 /**
  * 验证整数
  */
-function digits(value) {
-    return /^\d+$/.test(value)
+export function digits(value) {
+  return /^\d+$/.test(value)
 }
 
 /**
  * 验证身份证号码
  */
-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 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
+  )
 }
 
 /**
  * 是否车牌号
  */
-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
+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位小数
  */
-function amount(value) {
-    // 金额，只允许保留两位小数
-    return /^[1-9]\d*(,\d{3})*(\.\d{1,2})?$|^0\.\d{1,2}$/.test(value)
+export function amount(value) {
+  // 金额，只允许保留两位小数
+  return /^[1-9]\d*(,\d{3})*(\.\d{1,2})?$|^0\.\d{1,2}$/.test(value)
 }
 
 /**
  * 中文
  */
-function chinese(value) {
-    const reg = /^[\u4e00-\u9fa5]+$/gi
-    return reg.test(value)
+export function chinese(value) {
+  const reg = /^[\u4e00-\u9fa5]+$/gi
+  return reg.test(value)
 }
 
 /**
  * 只能输入字母
  */
-function letter(value) {
-    return /^[a-zA-Z]*$/.test(value)
+export function letter(value) {
+  return /^[a-zA-Z]*$/.test(value)
 }
 
 /**
  * 只能是字母或者数字
  */
-function enOrNum(value) {
-    // 英文或者数字
-    const reg = /^[0-9a-zA-Z]*$/g
-    return reg.test(value)
+export function enOrNum(value) {
+  // 英文或者数字
+  const reg = /^[0-9a-zA-Z]*$/g
+  return reg.test(value)
 }
 
 /**
  * 验证是否包含某个值
  */
-function contains(value, param) {
-    return value.indexOf(param) >= 0
+export function contains(value, param) {
+  return value.indexOf(param) >= 0
 }
 
 /**
  * 验证一个值范围[min, max]
  */
-function range(value, param) {
-    return value >= param[0] && value <= param[1]
+export function range(value, param) {
+  return value >= param[0] && value <= param[1]
 }
 
 /**
  * 验证一个长度范围[min, max]
  */
-function rangeLength(value, param) {
-    return value.length >= param[0] && value.length <= param[1]
+export function rangeLength(value, param) {
+  return value.length >= param[0] && value.length <= param[1]
 }
 
 /**
  * 是否固定电话
  */
-function landline(value) {
-    const reg = /^\d{3,4}-\d{7,8}(-\d{3,4})?$/
-    return reg.test(value)
+export function landline(value) {
+  const reg = /^\d{3,4}-\d{7,8}(-\d{3,4})?$/
+  return reg.test(value)
 }
 
 /**
  * 判断是否为空
  */
-function empty(value) {
-    switch (typeof value) {
+export function empty(value) {
+  console.log(' ', (isNaN(value)))
+  switch (typeof value) {
     case 'undefined':
-        return true
+      return true
     case 'string':
-        if (value.replace(/(^[ \t\n\r]*)|([ \t\n\r]*$)/g, '').length == 0) return true
-        break
+      if (value.replace(/(^[ \t\n\r]*)|([ \t\n\r]*$)/g, '').length == 0) return true
+      break
     case 'boolean':
-        if (!value) return true
-        break
+      if (!value) return true
+      break
     case 'number':
-        if (value === 0 || isNaN(value)) return true
-        break
+      if (value === 0 || isNaN(value)) return true
+      break
     case 'object':
-        if (value === null || value.length === 0) return true
-        for (const i in value) {
-            return false
-        }
-        return true
-    }
-    return false
+      if (value === null || value.length === 0) return true
+      for (const i in value) {
+        return false
+      }
+      return true
+  }
+  return false
 }
 
 /**
  * 是否json字符串
  */
-function jsonString(value) {
-    if (typeof value === 'string') {
-        try {
-            const obj = JSON.parse(value)
-            if (typeof obj === 'object' && obj) {
-                return true
-            }
-            return false
-        } catch (e) {
-            return false
-        }
+export function jsonString(value) {
+  if (typeof value === 'string') {
+    try {
+      const obj = JSON.parse(value)
+      if (typeof obj === 'object' && obj) {
+        return true
+      }
+      return false
+    } catch (e) {
+      return false
     }
-    return false
+  }
+  return false
 }
 
 /**
  * 是否数组
  */
-function array(value) {
-    if (typeof Array.isArray === 'function') {
-        return Array.isArray(value)
-    }
-    return Object.prototype.toString.call(value) === '[object Array]'
+export function array(value) {
+  if (typeof Array.isArray === 'function') {
+    return Array.isArray(value)
+  }
+  return Object.prototype.toString.call(value) === '[object Array]'
 }
 
 /**
  * 是否对象
  */
-function object(value) {
-    return Object.prototype.toString.call(value) === '[object Object]'
+export function object(value) {
+  return Object.prototype.toString.call(value) === '[object Object]'
 }
 
 /**
  * 是否短信验证码
  */
-function code(value, len = 6) {
-    return new RegExp(`^\\d{${len}}$`).test(value)
+export function code(value, len = 6) {
+  return new RegExp(`^\\d{${len}}$`).test(value)
 }
 
 /**
  * 是否函数方法
  * @param {Object} value
  */
-function func(value) {
-    return typeof value === 'function'
+export function func(value) {
+  return typeof value === 'function'
 }
 
 /**
  * 是否promise对象
  * @param {Object} value
  */
-function promise(value) {
-    return object(value) && func(value.then) && func(value.catch)
+export function promise(value) {
+  return object(value) && func(value.then) && func(value.catch)
 }
 
 /** 是否图片格式
  * @param {Object} value
  */
-function image(value) {
-    const newValue = value.split('?')[0]
-    const IMAGE_REGEXP = /\.(jpeg|jpg|gif|png|svg|webp|jfif|bmp|dpg)/i
-    return IMAGE_REGEXP.test(newValue)
+export function image(value) {
+  const newValue = value.split('?')[0]
+  const IMAGE_REGEXP = /\.(jpeg|jpg|gif|png|svg|webp|jfif|bmp|dpg)/i
+  return IMAGE_REGEXP.test(newValue)
 }
 
 /**
  * 是否视频格式
  * @param {Object} value
  */
-function video(value) {
-    const VIDEO_REGEXP = /\.(mp4|mpg|mpeg|dat|asf|avi|rm|rmvb|mov|wmv|flv|mkv|m3u8)/i
-    return VIDEO_REGEXP.test(value)
+export function video(value) {
+  const VIDEO_REGEXP = /\.(mp4|mpg|mpeg|dat|asf|avi|rm|rmvb|mov|wmv|flv|mkv|m3u8)/i
+  return VIDEO_REGEXP.test(value)
 }
 
 /**
@@ -251,38 +308,6 @@ function video(value) {
  * @param {Object}
  * @return {Boolean}
  */
-function regExp(o) {
-    return o && Object.prototype.toString.call(o) === '[object RegExp]'
-}
-
-export default {
-    email,
-    mobile,
-    url,
-    date,
-    dateISO,
-    number,
-    digits,
-    idCard,
-    carNo,
-    amount,
-    chinese,
-    letter,
-    enOrNum,
-    contains,
-    range,
-    rangeLength,
-    empty,
-    isEmpty: empty,
-    jsonString,
-    landline,
-    object,
-    array,
-    code,
-    func,
-    promise,
-    video,
-    image,
-    regExp,
-    string
+export function regExp(o) {
+  return o && Object.prototype.toString.call(o) === '[object RegExp]'
 }

package/src/tool.js

@@ -0,0 +1,40 @@
+
+
+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)
+  })
+}
+
+
+let wait = null
+/**
+* @description 节流
+* @param {number} time 每time秒调用一次 默认0.5秒
+* @example
+* throttle(time).then(res => {
+*  执行方法
+* })
+*/
+export function throttle(time = 500) { //防抖  // 默认0.2秒后执行事件
+  return new Promise((resolve) => {
+    if (wait) { return }
+    wait = setTimeout(() => {
+      resolve(true)
+      wait = null
+    }, time)
+  })
+}