web-component-gallery 2.3.6 → 2.3.8

package/utils/Filter.js

@@ -1,65 +1,121 @@
-
 /**
- *
- * @param {*} day 传入天数
- * 距离现在n天前的日期
+ * 获取 n 天前的时间
+ * @param {number} n - 数量
+ * @param {string|Date} baseTime - 基准时间（可选）
+ * @param {string} cFormat - 格式化模板
+ * @returns {string} 格式化日期
  */
-
-export function getDay(day) {
-    return getNDaysBefore(day, null, "{y}-{m}-{d}")
-}
-
-// 获取n天前的时间
 export function getNDaysBefore(n, baseTime = null, cFormat) {
     const base = baseTime ? new Date(baseTime) : new Date()
     const targetTime = new Date(base.getTime() - n * 24 * 60 * 60 * 1000)
     return formatDate(targetTime, cFormat)
 }
 
-// 获取n小时前的时间
+/**
+ * 获取 n 小时前的时间
+ * @param {number} n - 小时数
+ * @param {string|Date} baseTime - 基准时间（可选）
+ * @param {string} cFormat - 格式化模板
+ * @returns {string} 格式化日期
+ */
 export function getNHoursBefore(n, baseTime = null, cFormat) {
     const base = baseTime ? new Date(baseTime) : new Date()
     const targetTime = new Date(base.getTime() - n * 60 * 60 * 1000)
     return formatDate(targetTime, cFormat)
 }
 
-// 获取n分钟前的时间
+/**
+ * 获取 n 分钟前的时间
+ * @param {number} n - 分钟数
+ * @param {string|Date} baseTime - 基准时间（可选）
+ * @param {string} cFormat - 格式化模板
+ * @returns {string} 格式化日期
+ */
 export function getNMinutesBefore(n, baseTime = null, cFormat) {
     const base = baseTime ? new Date(baseTime) : new Date()
     const targetTime = new Date(base.getTime() - n * 60 * 1000)
     return formatDate(targetTime, cFormat)
 }
 
+/**
+ * 获取 n 秒前的时间
+ * @param {number} n - 秒数
+ * @param {string|Date} baseTime - 基准时间（可选）
+ * @param {string} cFormat - 格式化模板
+ * @returns {string} 格式化日期
+ */
+export function getNSecondsBefore(n, baseTime = null, cFormat) {
+    const base = baseTime ? new Date(baseTime) : new Date()
+    const targetTime = new Date(base.getTime() - n * 1000)
+    return formatDate(targetTime, cFormat)
+}
+
+/**
+ * 获取 n 天后的日期
+ * @param {number} n - 天数
+ * @param {string|Date} baseTime - 基准时间（可选）
+ * @param {string} cFormat - 格式化模板
+ * @returns {string} 格式化日期
+ */
+export function getNDaysAfter(n, baseTime = null, cFormat) {
+    const base = baseTime ? new Date(baseTime) : new Date()
+    const targetTime = new Date(base.getTime() + n * 24 * 60 * 60 * 1000)
+    return formatDate(targetTime, cFormat)
+}
+
+/**
+ * 获取 n 小时后的时间
+ * @param {number} n - 小时数
+ * @param {string|Date} baseTime - 基准时间（可选）
+ * @param {string} cFormat - 格式化模板
+ * @returns {string} 格式化日期
+ */
+export function getNHoursAfter(n, baseTime = null, cFormat) {
+    const base = baseTime ? new Date(baseTime) : new Date()
+    const targetTime = new Date(base.getTime() + n * 60 * 60 * 1000)
+    return formatDate(targetTime, cFormat)
+}
 
 /**
- *
- * @param {*} time 传入时间
- * @param {*} cFormat 可不传。格式化结构 默认 年-月-日 时:分:秒
- * {y}年 {m}月 {d}日 {h}时 {i}分 {s}秒 {a}星期
+ * 格式化日期
+ * @param {string|number|Date} time - 时间
+ * @param {string} cFormat - 格式化模板
+ * {y}年 {m}月 {d}日 {h}时 {i}分 {s}秒 {a}星期 {q}季度
+ * @returns {string|null} 格式化后的日期字符串
  */
 export function formatDate(time, cFormat) {
-    if (arguments.length === 0 || !time) {
-        return null;
-    }
-    const format = cFormat || "{y}-{m}-{d} {h}:{i}:{s}";
-    let date;
+    if (arguments.length === 0 || !time) return null
+
+    const format = cFormat || "{y}-{m}-{d} {h}:{i}:{s}"
+    let date
+
+    // 处理不同类型的输入
     if (typeof time === "object") {
-        date = time;
+        date = time
     } else {
-        let times = time;
-        times = new Date(time).getTime();
-        if ((typeof times === "string")) {
-            if ((/^[0-9]+$/.test(times))) {
-                times = parseInt(times);
-            } else {
-                times = times.replace(new RegExp(/-/g), "/");
-            }
+        let timestamp = time
+
+        // 字符串处理
+        if (typeof timestamp === "string") {
+            timestamp = /^[0-9]+$/.test(timestamp)
+                ? parseInt(timestamp)
+                : timestamp.replace(/-/g, "/")
         }
-        if ((typeof times === "number") && (times.toString().length === 10)) {
-            times *= 1000;
+
+        // 10 位时间戳转毫秒
+        if (typeof timestamp === "number" && timestamp.toString().length === 10) {
+            timestamp *= 1000
         }
-        date = new Date(times);
+
+        date = new Date(timestamp)
+    }
+
+    // 验证日期有效性
+    if (isNaN(date.getTime())) {
+        console.warn('无效的日期格式')
+        return null
     }
+
     const formatObj = {
         y: date.getFullYear(),
         m: date.getMonth() + 1,
@@ -68,172 +124,573 @@ export function formatDate(time, cFormat) {
         i: date.getMinutes(),
         s: date.getSeconds(),
         a: date.getDay(),
-    };
-    const timeStr = format.replace(/\{([ymdhisa])+\}/g, (result, key) => {
-        const value = formatObj[key];
-        // Note: getDay() returns 0 on Sunday
+        q: Math.floor((date.getMonth() + 3) / 3), // 季度
+    }
+
+    const timeStr = format.replace(/{([ymdhisaq])+}/g, (result, key) => {
+        const value = formatObj[key]
+
+        // 星期处理
         if (key === "a") {
-            return ["日", "一", "二", "三", "四", "五", "六"][value];
+            return ["日", "一", "二", "三", "四", "五", "六"][value]
         }
-        if (!String.prototype.padStart) return padStart(2, value.toString());
-        return value.toString()
-            .padStart(2, "0"); // 返回替换的字符串，padStart用于头部补全
-    });
-    return timeStr;
+
+        // 补零处理
+        return String(value).padStart(2, "0")
+    })
+
+    return timeStr
+}
+
+/**
+ * 时间戳转格式化日期
+ * @param {number} timestamp - 时间戳（秒或毫秒）
+ * @param {string} format - 格式化模板
+ * @returns {string|null} 格式化日期
+ */
+export function formatTimestamp(timestamp, format) {
+    if (!timestamp) return null
+
+    // 10 位时间戳转毫秒
+    if (String(timestamp).length === 10) {
+        timestamp *= 1000
+    }
+
+    return formatDate(new Date(timestamp), format)
+}
+
+/**
+ * 计算两个日期之间的差异
+ * @param {string|Date} date1 - 日期 1
+ * @param {string|Date} date2 - 日期 2
+ * @returns {Object} 差异对象 {days, hours, minutes, seconds, milliseconds}
+ */
+export function dateDiff(date1, date2) {
+    const d1 = new Date(date1)
+    const d2 = new Date(date2)
+    const diff = Math.abs(d2 - d1)
+
+    return {
+        milliseconds: diff,
+        seconds: Math.floor(diff / 1000),
+        minutes: Math.floor(diff / (1000 * 60)),
+        hours: Math.floor(diff / (1000 * 60 * 60)),
+        days: Math.floor(diff / (1000 * 60 * 60 * 24)),
+        weeks: Math.floor(diff / (1000 * 60 * 60 * 24 * 7)),
+        months: Math.floor(diff / (1000 * 60 * 60 * 24 * 30)),
+        years: Math.floor(diff / (1000 * 60 * 60 * 24 * 365))
+    }
+}
+
+/**
+ * 判断是否为闰年
+ * @param {number} year - 年份
+ * @returns {boolean} 是否为闰年
+ */
+export function isLeapYear(year) {
+    return (year % 4 === 0 && year % 100 !== 0) || (year % 400 === 0)
+}
+
+/**
+ * 获取某月的天数
+ * @param {number} year - 年份
+ * @param {number} month - 月份（1-12）
+ * @returns {number} 天数
+ */
+export function getDaysInMonth(year, month) {
+    return new Date(year, month, 0).getDate()
 }
 
 /**
- * JS颜色十六进制转换为rgb或rgba,返回的格式为 rgba（255，255，255，0.5）字符串
- * sHex为传入的十六进制的色值
- * alpha为rgba的透明度
+ * 颜色十六进制转 RGB/RGBA
+ * @param {string} sHex - 十六进制色值
+ * @param {number} alpha - 透明度
+ * @returns {string} rgba(r,g,b,a) 格式字符串
  */
 export function colorRgba(sHex, alpha) {
-    // 十六进制颜色值的正则表达式
-    const reg = /^#([0-9a-fA-f]{3}|[0-9a-fA-f]{6})$/;
-    /* 16进制颜色转为RGB格式 */
-    let sColor = sHex.toLowerCase();
+    const reg = /^#([0-9a-fA-f]{3}|[0-9a-fA-f]{6})$/
+    let sColor = sHex.toLowerCase()
+
     if (sColor && reg.test(sColor)) {
+        // 简写形式转为完整形式 #fff -> #ffffff
         if (sColor.length === 4) {
-            var sColorNew = "#";
-            for (let i = 1; i < 4; i += 1) {
-                sColorNew += sColor.slice(i, i + 1)
-                    .concat(sColor.slice(i, i + 1));
-            }
-            sColor = sColorNew;
+            sColor = "#" + [1, 2, 3].map(i =>
+                sColor.slice(i, i + 1).repeat(2)
+            ).join("")
         }
-        // 处理六位的颜色值
-        const sColorChange = [];
+
+        // 提取 RGB 值
+        const rgbValues = []
         for (let i = 1; i < 7; i += 2) {
-            sColorChange.push(parseInt(`0x${sColor.slice(i, i + 2)}`));
+            rgbValues.push(parseInt(`0x${sColor.slice(i, i + 2)}`))
         }
-        // return sColorChange.join(',')
-        return `rgba(${sColorChange.join(",")},${alpha})`;
+
+        return alpha !== undefined
+            ? `rgba(${rgbValues.join(",")},${alpha})`
+            : `rgb(${rgbValues.join(",")})`
+    }
+
+    return sColor
+}
+
+/**
+ * RGB 转十六进制颜色
+ * @param {number} r - 红色值 (0-255)
+ * @param {number} g - 绿色值 (0-255)
+ * @param {number} b - 蓝色值 (0-255)
+ * @returns {string} 十六进制色值
+ */
+export function rgbToHex(r, g, b) {
+    const toHex = (c) => {
+        const hex = Math.max(0, Math.min(255, c)).toString(16)
+        return hex.length === 1 ? "0" + hex : hex
     }
-    return sColor;
+    return "#" + toHex(r) + toHex(g) + toHex(b)
 }
 
 /**
- * segment: 分段 7段
- * tatalpercent: 百分比 100
- * basevalue: 基础值 200
-*/
-export function produceDataSeriesEx(segment, tatal, basevalue) {
-    //需要产生segment个随机数，且segment个随机数之和等于tatal
-    let arrpercent = new Array(segment).fill(0);
-    for (let i = 0; i < tatal; i++) {
-        //parseInt接收string，所以需要转一趟
-        /**
-         * 换成生活中的场景，就是一百个苹果分给十个人，我们可以一个一个的取出，随机分给某个人，直到分完
-         * 在js里面，十个人即是一个长度为十的数组，每次数组随机一个位置加一，执行一百次
-         */
-        var num = parseInt((Math.random() * segment).toString());
-        arrpercent[num]++;
+ * 生成随机颜色
+ * @param {boolean} full - 是否使用全色系（默认 false，使用柔和色系）
+ * @returns {string} 十六进制色值
+ */
+export function randomColor(full = false) {
+    if (full) {
+        return '#' + Math.floor(Math.random() * 16777215).toString(16).padStart(6, '0')
     }
-    //console.log(arr.length)
 
-    let arrvalue = new Array(segment).fill(0);
-    for (let i = 0; i < segment; i++) {
-        arrvalue[i] = parseInt(arrpercent[i] / 100 * basevalue);
+    // 生成柔和的彩色
+    const hue = Math.floor(Math.random() * 360)
+    const saturation = 70 + Math.floor(Math.random() * 20)
+    const lightness = 60 + Math.floor(Math.random() * 20)
+
+    return hslToHex(hue, saturation, lightness)
+}
+
+/**
+ * HSL 转十六进制颜色
+ * @param {number} h - 色相 (0-360)
+ * @param {number} s - 饱和度 (0-100)
+ * @param {number} l - 亮度 (0-100)
+ * @returns {string} 十六进制色值
+ */
+export function hslToHex(h, s, l) {
+    s /= 100
+    l /= 100
+
+    const c = (1 - Math.abs(2 * l - 1)) * s
+    const x = c * (1 - Math.abs(((h / 60) % 2) - 1))
+    const m = l - c / 2
+
+    let r = 0, g = 0, b = 0
+
+    if (0 <= h && h < 60) { r = c; g = x; b = 0 }
+    else if (60 <= h && h < 120) { r = x; g = c; b = 0 }
+    else if (120 <= h && h < 180) { r = 0; g = c; b = x }
+    else if (180 <= h && h < 240) { r = 0; g = x; b = c }
+    else if (240 <= h && h < 300) { r = x; g = 0; b = c }
+    else if (300 <= h && h < 360) { r = c; g = 0; b = x }
+
+    return rgbToHex(
+        Math.round((r + m) * 255),
+        Math.round((g + m) * 255),
+        Math.round((b + m) * 255)
+    )
+}
+
+/**
+ * 产生数据系列（分段随机数据）
+ * @param {number} segment - 分段数
+ * @param {number} total - 总百分比（通常 100）
+ * @param {number} baseValue - 基础值
+ * @returns {Array} [百分比数组，数值数组]
+ */
+export function produceDataSeriesEx(segment, total, baseValue) {
+    // 生成分段百分比
+    const percentArray = new Array(segment).fill(0)
+    for (let i = 0; i < total; i++) {
+        const randomIndex = Math.floor(Math.random() * segment)
+        percentArray[randomIndex]++
     }
 
-    return [arrpercent, arrvalue];
+    // 计算对应数值
+    const valueArray = percentArray.map(percent =>
+        Math.floor(percent / 100 * baseValue)
+    )
+
+    return [percentArray, valueArray]
 }
 
 /**
  * 深拷贝
- * obj为原始数据
- * 适用场景：数组套对象、对象套数组、混合嵌套等
+ * @param {*} obj - 要拷贝的对象
+ * @returns {*} 深拷贝后的结果
  */
 export function deepClone(obj) {
     if (obj === null || typeof obj !== 'object') {
-      return obj
+        return obj
     }
-   
+
     if (obj instanceof Date) {
-      return new Date(obj.getTime())
+        return new Date(obj.getTime())
     }
-   
+
     if (obj instanceof Array) {
-      return obj.reduce((arr, item, i) => {
-        arr[i] = deepClone(item)
-        return arr
-      }, [])
+        return obj.reduce((arr, item) => {
+            arr.push(deepClone(item))
+            return arr
+        }, [])
     }
-   
+
     if (obj instanceof Object) {
-      return Object.keys(obj).reduce((newObj, key) => {
-        newObj[key] = deepClone(obj[key])
-        return newObj
-      }, {})
+        return Object.keys(obj).reduce((newObj, key) => {
+            newObj[key] = deepClone(obj[key])
+            return newObj
+        }, {})
     }
 }
 
 /**
- * 数据转换
- * data为原始数据
- * 适用场景：根据要求格式来转换当前属性值 (转化失败则初始化为默认格式
+ * 数据类型转换工具函数
+ * @param {*} data - 原始数据
+ * @param {string|Object|null} format - 目标类型或转换配置对象
+ *        - 字符串：'String'|'Number'|'Boolean'|'Array'|'Object'
+ *        - 对象：转换映射配置 {key: type}
+ *        - null/undefined：智能自动转换
+ * @param {Object} options - 配置选项
+ * @param {boolean} options.useDefault - 转换不成功是否返回默认值（默认 true）
+ * @param {*} options.defaultValue - 自定义默认值（可选）
+ * @returns {*} 转换后的数据
+ * 
+ * @example
+ * // 智能转换（不传 format）
+ * transferData('123')           // 123 (自动推断为 Number)
+ * transferData('true')          // true (自动推断为 Boolean)
+ * transferData('[1,2]')         // [1,2] (自动推断为 Array)
+ * transferData('hello')         // 'hello' (保持 String)
+ * 
+ * // 字符串模式：基本类型转换
+ * transferData('123', 'Number') // 123
+ * transferData(null, 'Array')   // []
+ * 
+ * // 对象模式：根据 key 批量转换
+ * transferData({a:'1', b:'2'}, {a: 'Number', b: 'Number'}) 
+ * // {a: 1, b: 2}
+ * 
+ * // 配置选项
+ * transferData('abc', 'Number') // NaN
+ * transferData('abc', 'Number', { defaultValue: -1 })  // -1
  */
-export function transferData(data, format = 'String') {
-    
-    const defaultData = {
-        Number: 0,
-        Boolean: false,
-        String: '',
-        Array: [],
+export function transferData(data, format, options = {}) {
+    // 智能转换模式
+    if (!format) return autoTransferDataInternal(data, options)
+
+    const { defaultValue } = options
+
+    // 数组模式：支持两种形式
+    // 1. ['a', 'b', 'c'] - 转换为 Number
+    // 2. [['a', 'b'], 'Number'] - 指定类型
+    // 3. [{ fields: ['a', 'b'], type: 'Number' }] - 对象配置
+    if (Array.isArray(format)) return transferDataByFields(data, format, options)
+
+    // 对象映射模式
+    if (typeof format === 'object') return transferDataByMap(data, format, options)
+
+    // 默认值配置
+    const defaults = { 
+        Number: 0, 
+        Boolean: false, 
+        String: '', 
+        Array: [], 
         Object: {}
     }
-   
-    if (format === 'Array' || format === 'Object') {
 
-        let parsed
+    const defaultVal = defaultValue ?? defaults[format]
+
+    // 空值处理
+    if (data == null) return defaultVal
+
+    // 复杂类型处理 (Array/Object)
+    if (format === 'Array' || format === 'Object') {
+        const isTargetType = (format === 'Array' && Array.isArray(data)) ||
+                             (format === 'Object' && typeof data === 'object' && !Array.isArray(data))
+        
+        if (isTargetType) return format === 'Array' ? [...data] : { ...data }
 
         try {
-            parsed = JSON.parse(data)
-        } catch (error) { parsed = data }
+            return JSON.parse(data)
+        } catch (e) {
+            console.error(`JSON 解析失败：${e.message}`)
+            return defaultVal
+        }
+    }
 
-        if (parsed && ( parsed instanceof Array || parsed instanceof Object )) {
-          return parsed
+    // 基础类型转换
+    try {
+        switch (format) {
+            case 'Number': {
+                const num = Number(data)
+                return isNaN(num) ? defaultVal : num
+            }
+            case 'Boolean': {
+                if (typeof data === 'boolean') return data
+                const lower = String(data).toLowerCase()
+                if (['true', '1', 'yes', 'ok'].includes(lower)) return true
+                if (['false', '0', 'no', 'cancel'].includes(lower)) return false
+                return Boolean(data)
+            }
+            case 'String': {
+                // 对象/数组转为 JSON 字符串
+                if (typeof data === 'object') {
+                    try {
+                        return JSON.stringify(data)
+                    } catch (e) {
+                        console.error(`对象转字符串失败：${e.message}`)
+                    }
+                }
+                return String(data)
+            }
+            default:
+                return data
         }
+    } catch {
+        return defaultVal
+    }
+}
+
+/**
+ * 根据字段数组批量转换数据
+ * @param {*} data - 原始数据
+ * @param {Array} format - 格式配置
+ *        - ['a', 'b', 'c'] - 默认转为 Number
+ *        - [['a', 'b'], 'Number'] - 指定类型
+ *        - [{ fields: ['a', 'b'], type: 'Number' }] - 对象配置
+ * @param {Object} options - 配置选项
+ * @returns {*} 转换后的数据
+ */
+function transferDataByFields(data, format, options) {
+    if (data == null || typeof data !== 'object') {
+        return data ?? options.defaultValue
+    }
 
-        return defaultData[format]
+    let fields = []
+    let type = 'Number' // 默认转为 Number
+
+    // 解析数组配置
+    if (format.length === 0) return data
+
+    // 形式 1: ['a', 'b', 'c'] - 默认转 Number
+    if (typeof format[0] === 'string') {
+        fields = format
+    }
+    // 形式 2: [['a', 'b'], 'Number'] - [fields, type]
+    else if (Array.isArray(format[0])) {
+        fields = format[0]
+        if (format[1]) type = format[1]
     }
-    else {
-        return data ?? defaultData[format]
+    // 形式 3: [{ fields: ['a', 'b'], type: 'Number' }] - 对象配置
+    else if (typeof format[0] === 'object') {
+        const config = format[0]
+        fields = config.fields || []
+        type = config.type || 'Number'
+    }
+
+    // 如果是数组，递归处理每个元素
+    if (Array.isArray(data)) {
+        return data.map(item => transferDataByFields(item, format, options))
+    }
+
+    // 对象处理：转换指定字段
+    const result = { ...data }
+    
+    for (const field of fields) {
+        if (field in result) {
+            result[field] = transferData(result[field], type, options)
+        }
     }
+
+    return result
 }
 
+/**
+ * 智能数据类型转换（内部函数）
+ * @param {*} data - 原始数据
+ * @param {Object} options - 配置选项
+ * @returns {*} 转换后的数据
+ */
+function autoTransferDataInternal(data, options) {
+    if (data == null || typeof data !== 'string') return data ?? options.defaultValue
+
+    const trimmed = data.trim()
+    if (!trimmed) return options.defaultValue
+
+    try {
+        if (/^true$/i.test(trimmed)) return true
+        if (/^false$/i.test(trimmed)) return false
+
+        if (/^[+-]?\d*\.?\d+(?:[eE][+-]?\d+)?$/.test(trimmed)) {
+            const num = Number(trimmed)
+            if (!isNaN(num)) return num
+        }
+
+        if (/^[\[{]/.test(trimmed)) {
+            return JSON.parse(trimmed)
+        }
+    } catch {}
+
+    return data
+}
+
+/**
+ * 根据映射对象批量转换数据
+ * @param {*} data - 原始数据（对象或数组）
+ * @param {Object} formatMap - 转换映射对象 {key: type}
+ * @param {Object} options - 配置选项
+ * @returns {*} 转换后的数据
+ */
+function transferDataByMap(data, formatMap, options) {
+    // 数据为空，返回空对象或原数据
+    if (data === null || data === undefined) {
+        return options.defaultValue ?? {}
+    }
+    
+    // 数组处理：对每个元素应用转换映射
+    if (Array.isArray(data)) {
+        return data.map(item => {
+            if (typeof item !== 'object') return item
+            return transferDataByMap(item, formatMap, options)
+        })
+    }
+    
+    // 对象处理：根据 formatMap 的 key 进行转换
+    const result = {}
+    
+    // 遍历映射表进行类型转换
+    for (const key in formatMap) {
+        if (Object.hasOwn(formatMap, key)) {
+            result[key] = transferData(data[key], formatMap[key], options)
+        }
+    }
+
+    // 保留未在映射表中定义的其他属性
+    for (const key in data) {
+        if (Object.hasOwn(data, key) && !Object.hasOwn(result, key)) {
+            result[key] = data[key]
+        }
+    }
+    
+    return result
+}
 
 /**
- * 查找字符串
- * str为字符串
- * charToFind为查找字符
- * n为次数
- * 适用场景：查找某个字符在字符串当中某一次的位置
+ * 查找字符串中第 n 次出现的位置
+ * @param {string} str - 源字符串
+ * @param {string} charToFind - 查找字符
+ * @param {number} n - 第几次出现
+ * @returns {number} 位置索引，未找到返回 -1
  */
 export function findNthOccurrence(str, charToFind, n) {
-    let count = 0;
-    let index = str.indexOf(charToFind);
+    let count = 0
+    let index = str.indexOf(charToFind)
    
     while (count < n && index !== -1) {
-      index = str.indexOf(charToFind, index + 1);
-      count++;
+      index = str.indexOf(charToFind, index + 1)
+      count++
     }
    
-    return index === -1 ? -1 : index;
-} 
+    return index
+}
 
 /**
- * object转化为formData
- * @object 转化对象
+ * 对象转 FormData
+ * @param {Object} object - 要转换的对象
+ * @returns {FormData} FormData 对象
  */
 export function setFormData(object) {
-
     const formData = new FormData()
 
     for (const key in object) {
-        formData.append(key, object[key])
+        if (Object.prototype.hasOwnProperty.call(object, key)) {
+            const value = object[key]
+
+            // 处理嵌套对象和数组
+            value instanceof Object || Array.isArray(value)
+                ? formData.append(key, JSON.stringify(value))
+                : formData.append(key, value)
+        }
     }
 
     return formData
+}
+
+/**
+ * 防抖函数
+ * @param {Function} func - 要执行的函数
+ * @param {number} wait - 等待时间（毫秒）
+ * @returns {Function} 防抖后的函数
+ */
+export function debounce(func, wait = 300) {
+    let timeout
+    return function (...args) {
+        clearTimeout(timeout)
+        timeout = setTimeout(() => func.apply(this, args), wait)
+    }
+}
+
+/**
+ * 节流函数
+ * @param {Function} func - 要执行的函数
+ * @param {number} delay - 延迟时间（毫秒）
+ * @returns {Function} 节流后的函数
+ */
+export function throttle(func, delay = 300) {
+    let lastTime = 0
+    return function (...args) {
+        const now = Date.now()
+        if (now - lastTime >= delay) {
+            lastTime = now
+            func.apply(this, args)
+        }
+    }
+}
+
+/**
+ * 数组去重
+ * @param {Array} arr - 要去重的数组
+ * @param {string} key - 对象去重的键（可选）
+ * @returns {Array} 去重后的数组
+ */
+export function uniqueArray(arr, key) {
+    if (!Array.isArray(arr)) return []
+
+    if (key) {
+        const seen = new Set()
+        return arr.filter(item => {
+            const value = item[key]
+            if (seen.has(value)) return false
+            seen.add(value)
+            return true
+        })
+    }
+
+    return [...new Set(arr)]
+}
+
+/**
+ * 数组按指定字段排序
+ * @param {Array} arr - 要排序的数组
+ * @param {string} key - 排序字段
+ * @param {boolean} ascending - 是否升序（默认降序）
+ * @returns {Array} 排序后的数组
+ */
+export function sortByKey(arr, key, ascending = false) {
+    if (!Array.isArray(arr)) return []
+
+    return arr.sort((a, b) => {
+        const valA = a[key]
+        const valB = b[key]
 
-} 
+        if (valA < valB) return ascending ? -1 : 1
+        if (valA > valB) return ascending ? 1 : -1
+        return 0
+    })
+}