@yoooloo42/bean 1.0.0 → 1.0.2

package/index.js

@@ -1,6 +1,8 @@
-import dateFormat from './src/dateFormat.js';
+import libs from './src/libs/index.js'
+import utils from './src/utils/index.js';
 
 const bean = {
-    dateFormat
+    libs,
+    utils
 }
 export default bean

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yoooloo42/bean",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -16,5 +16,10 @@
   "bugs": {
     "url": "https://github.com/13993193075/bean/issues"
   },
-  "homepage": "https://github.com/13993193075/bean#readme"
+  "homepage": "https://github.com/13993193075/bean#readme",
+  "dependencies": {
+    "file-saver": "^2.0.5",
+    "nodemailer": "^7.0.10",
+    "xlsx": "^0.18.5"
+  }
 }

package/src/libs/Email.js

@@ -0,0 +1,128 @@
+import nodemailer from 'nodemailer';
+
+/**
+ * Node.js 项目中发送电子邮件的函数
+ * @param {string} to - 收件人邮箱地址
+ * @param {string} subject - 邮件主题
+ * @param {string} htmlContent - 邮件的 HTML 内容（正文）
+ * @param {string} [textContent] - 邮件的纯文本内容（可选，作为 HTML 无法显示的备用）
+ */
+async function sendEmail(to, subject, htmlContent, textContent = '') {
+    // ⚠️ 1. 配置 Transporter (SMTP 服务器设置)
+    // 
+    // 如果使用 Gmail：
+    // - 您需要启用“两步验证”并生成一个“应用专用密码”（App Password），而不是使用您的主账户密码。
+    // - 否则，Google 可能会阻止登录。
+    const transporter = nodemailer.createTransport({
+        // host: 'smtp.exmail.qq.com', // 替换为你的 SMTP 服务器地址 (例如: 'smtp.gmail.com', 'smtp-mail.outlook.com')
+        // port: 465, // 常用端口: 465 (安全连接) 或 587 (TLS)
+        // secure: true, // true 为 465 端口, false 为其它端口
+        service: '126',
+        auth: {
+            // user: 'your_email@example.com', // 替换为你的发件箱地址
+            user: 'lyxdrwhy000@126.com',
+            // pass: 'your_app_password' // 替换为你的邮箱密码或“应用专用密码”
+            pass: 'JSQNIEMQCCPCVSJW'
+        }
+    });
+
+    // 2. 构造邮件内容对象
+    const mailOptions = {
+        // from: '"Your Name" <your_email@example.com>', // 发件人信息 (会显示在收件箱中)
+        from: `"Stellarium - 企业应用集成平台" <lyxdrwhy000@126.com>`,
+        to: to, // 收件人地址
+        subject: subject,  // 邮件主题
+        html: htmlContent, // 邮件 HTML 正文
+        text: textContent  // 邮件纯文本正文 (可选)
+        // 附件可以在这里添加:
+        /* attachments: [
+            {
+                filename: 'report.pdf',
+                path: '/path/to/your/report.pdf' 
+            }
+        ] */
+    };
+
+    try {
+        // 3. 发送邮件
+        let info = await transporter.sendMail(mailOptions);
+
+        console.log('邮件发送成功:');
+        console.log('  收件人:', to);
+        console.log('  主题:', subject);
+        console.log('  Message ID:', info.messageId);
+        
+        return { success: true, messageId: info.messageId };
+        
+    } catch (error) {
+        console.error('邮件发送失败:', error);
+        return { success: false, error: error.message };
+    }
+}
+
+/**
+ * 生成指定长度的随机数字验证码
+ * @param {number} length - 验证码长度 (默认 6 位)
+ * @returns {string} - 随机数字字符串
+ */
+function vercode(length = 6) {
+    let code = '';
+    // 确保第一位不是 0，除非长度只有一位
+    code += Math.floor(Math.random() * 9) + 1; 
+
+    for (let i = 1; i < length; i++) {
+        code += Math.floor(Math.random() * 10);
+    }
+    return code;
+}
+
+/**
+ * 发送包含验证码的邮件
+ * * @param {string} recipientEmail - 收件人邮箱地址
+ * @param {number} [codeLength=6] - 验证码长度
+ * @param {number} [expirationMinutes=5] - 验证码有效时间（分钟）
+ * @returns {Promise<{success: boolean, code?: string, error?: string}>} - 包含发送结果和生成的验证码
+ */
+async function sendEmailVercode(recipientEmail, codeLength = 6, expirationMinutes = 5) {
+    
+    // 1. 生成验证码
+    const verificationCode = vercode(codeLength);
+
+    // 2. 构造邮件内容
+    const subject = `您的验证码：${verificationCode}，请注意妥善保管，切勿泄露`;
+    
+    const htmlContent = `
+        <div style="font-family: Arial, sans-serif; max-width: 600px; margin: auto; border: 1px solid #ddd; padding: 20px;">
+            <h2 style="color: #333;">验证码通知</h2>
+            <p>您正在进行Email验证码操作，请在页面中输入以下验证码：</p>
+            <div style="background-color: #f5f5f5; padding: 15px; text-align: center; border-radius: 5px; margin: 20px 0;">
+                <span style="font-size: 30px; font-weight: bold; color: #007bff;">${verificationCode}</span>
+            </div>
+            <p style="color: #e44d26;">请注意：该验证码将在 ${expirationMinutes} 分钟内失效。</p>
+            <p style="font-size: 12px; color: #999;">如果不是您本人操作，请忽略此邮件。</p>
+        </div>
+    `;
+
+    // 3. 调用核心发送函数
+    const sendResult = await sendEmail(recipientEmail, subject, htmlContent);
+
+    // 4. 返回结果和验证码
+    if (sendResult.success) {
+        return { 
+            success: true, 
+            vercode: verificationCode 
+        };
+    } else {
+        return { 
+            success: false, 
+            error: sendResult.error || '邮件发送失败' 
+        };
+    }
+}
+
+const bean = {
+    sendEmail,
+    vercode,
+    sendEmailVercode
+}
+export default bean

package/src/libs/FileSaver.js

@@ -0,0 +1,49 @@
+import * as XLSX from 'xlsx';
+import FileSaver from 'file-saver';
+
+/**
+ * 将 JSON 数组数据导出为 Excel 文件
+ * @param {Array<Object>} json - 要导出的数据数组 (el-table 的 :data 绑定的数据)
+ * @param {Array<string>} header - 表格的表头（中文名）
+ * @param {Array<string>} keys - 对应表头的数据字段名（英文键名）
+ * @param {string} filename - 导出的文件名
+ */
+function jsonToExcel({
+  json,
+  header,
+  keys,
+  filename = 'excel-file',
+}) {
+  // 1. 转换数据格式
+  const data = json.map(item => keys.map(key => item[key]));
+  
+  // 2. 将表头和数据组合
+  const aoa = [header, ...data];
+
+  // 3. 创建工作簿和工作表
+  const ws = XLSX.utils.aoa_to_sheet(aoa);
+  const wb = XLSX.utils.book_new();
+  XLSX.utils.book_append_sheet(wb, ws, 'Sheet1');
+
+  // 4. 生成 Excel 文件
+  const wbout = XLSX.write(wb, {
+    bookType: 'xlsx',
+    bookSST: true,
+    type: 'array'
+  });
+
+  // 5. 保存文件
+  try {
+    FileSaver.saveAs(
+      new Blob([wbout], { type: 'application/octet-stream' }),
+      `${filename}.xlsx`
+    );
+  } catch (e) {
+    if (typeof console !== 'undefined') console.log(e, wbout);
+  }
+}
+
+const bean = {
+    jsonToExcel
+}
+export default bean

package/src/libs/index.js

@@ -0,0 +1,8 @@
+import Email from "./Email.js"
+import FileSaver from "./FileSaver.js";
+
+const bean = {
+    Email,
+    FileSaver
+}
+export default bean

package/src/utils/deepClone.js

@@ -0,0 +1,356 @@
+/**
+ * 深度拷贝函数
+ *
+ * @param {any} obj 需要拷贝的对象、数组或基本类型值
+ * @param {WeakMap} [cache=new WeakMap()] 用于处理循环引用的缓存
+ * @returns {any} 深度拷贝后的新对象/新值
+ */
+function deepClone(obj, cache = new WeakMap()) {
+    // 1. 基本类型值（包括 null）和函数，直接返回
+    if (obj === null || typeof obj !== 'object') {
+        return obj;
+    }
+    // 处理函数（尽管技术上函数是对象，但我们通常不克隆它，而是直接引用）
+    if (typeof obj === 'function') {
+        return obj;
+    }
+
+    // 2. 检查循环引用
+    // 如果缓存中已存在该对象，说明遇到了循环引用，直接返回缓存中的克隆对象
+    if (cache.has(obj)) {
+        return cache.get(obj);
+    }
+
+    // 3. 处理特定内置对象（Date 和 RegExp）
+    if (obj instanceof Date) {
+        return new Date(obj.getTime());
+    }
+    if (obj instanceof RegExp) {
+        // g: global, i: ignoreCase, m: multiline, u: unicode, y: sticky
+        const flags = obj.global ? 'g' : ''
+                    + obj.ignoreCase ? 'i' : ''
+                    + obj.multiline ? 'm' : ''
+                    + obj.unicode ? 'u' : ''
+                    + obj.sticky ? 'y' : '';
+        return new RegExp(obj.source, flags);
+    }
+
+    // 4. 初始化克隆对象
+    // 如果是数组，则初始化为空数组；否则初始化为空对象
+    const clone = Array.isArray(obj) ? [] : {};
+
+    // 将克隆对象放入缓存，以处理接下来的递归调用中可能遇到的循环引用
+    cache.set(obj, clone);
+
+    // 5. 递归拷贝属性
+    for (const key in obj) {
+        // 确保只处理对象自身的属性，排除原型链上的属性
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            clone[key] = deepClone(obj[key], cache);
+        }
+    }
+
+    // 6. 拷贝 Symbol 属性 (ES6/ES2015+)
+    if (typeof Object.getOwnPropertySymbols === 'function') {
+        Object.getOwnPropertySymbols(obj).forEach(sym => {
+            clone[sym] = deepClone(obj[sym], cache);
+        });
+    }
+
+    return clone;
+}
+
+/**
+ * 深度拷贝函数，并在拷贝叶节点值时应用一个转换函数。
+ *
+ * @param {any} obj - 需要拷贝的对象、数组或基本类型值。
+ * @param {function} valueMapper - 接收叶节点值作为参数，并返回新值的转换函数。
+ * @param {WeakMap} [cache=new WeakMap()] - 用于处理循环引用的缓存。
+ * @returns {any} 深度拷贝并转换后的新对象/新值。
+ */
+function deepCloneAndMap(obj, valueMapper, cache = new WeakMap()) {
+    // 1. 基本类型值（包括 null）和函数，**应用 valueMapper**
+    
+    // 如果是基本类型值（包括 null），则认为是叶节点，应用 valueMapper
+    if (obj === null || typeof obj !== 'object') {
+        // 对基本类型值应用转换函数
+        return valueMapper(obj);
+    }
+    
+    // 如果是函数，通常我们不克隆它，也不转换它的值，直接返回
+    if (typeof obj === 'function') {
+        return obj;
+    }
+
+    // 2. 检查循环引用 (与原函数逻辑相同)
+    if (cache.has(obj)) {
+        return cache.get(obj);
+    }
+
+    // 3. 处理特定内置对象（Date 和 RegExp），**应用 valueMapper**
+    
+    // 对于 Date 和 RegExp 这种对象实例，我们通常将它们的**值**视为叶节点，
+    // 克隆实例本身后，再对这个克隆实例应用 valueMapper。
+    let clone;
+    
+    if (obj instanceof Date) {
+        clone = new Date(obj.getTime());
+    } else if (obj instanceof RegExp) {
+        // 提取 flags
+        const flags = (obj.global ? 'g' : '')
+                    + (obj.ignoreCase ? 'i' : '')
+                    + (obj.multiline ? 'm' : '')
+                    + (obj.unicode ? 'u' : '')
+                    + (obj.sticky ? 'y' : '');
+        clone = new RegExp(obj.source, flags);
+    } 
+    
+    // 检查是否是内置对象（Date/RegExp），如果是，对克隆后的实例应用转换
+    if (clone) {
+        return valueMapper(clone);
+    }
+
+    // 4. 初始化克隆对象 (普通对象和数组)
+    clone = Array.isArray(obj) ? [] : {};
+
+    // 将克隆对象放入缓存
+    cache.set(obj, clone);
+
+    // 5. 递归拷贝属性
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            // 递归调用自身，对子属性进行深拷贝和转换
+            clone[key] = deepCloneAndMap(obj[key], valueMapper, cache);
+        }
+    }
+
+    // 6. 拷贝 Symbol 属性
+    if (typeof Object.getOwnPropertySymbols === 'function') {
+        Object.getOwnPropertySymbols(obj).forEach(sym => {
+            // 递归调用自身，对 Symbol 属性的值进行深拷贝和转换
+            clone[sym] = deepCloneAndMap(obj[sym], valueMapper, cache);
+        });
+    }
+
+    // 7. 返回深度克隆并转换后的对象/数组
+    return clone;
+}
+
+/**
+ * 健壮的数据类型判断函数
+ *
+ * @param {any} value 需要判断类型的值
+ * @returns {string} 小写的类型字符串，例如：'string', 'number', 'array', 'function', 'object', 'null', 'undefined'
+ */
+function typeOfValue(value) {
+    // 1. 处理基本类型值（typeof 准确的部分）
+    const type = typeof value;
+
+    // 'string', 'number', 'boolean', 'symbol', 'bigint', 'function', 'undefined'
+    if (type !== 'object') {
+        return type;
+    }
+
+    // 2. 处理 null (typeof 的缺陷：typeof null === 'object')
+    if (value === null) {
+        return 'null';
+    }
+
+    // 3. 处理对象类型值 (使用 Object.prototype.toString.call() 获取内部 [[Class]] 属性)
+    // 结果格式为：[object Class]
+    const classString = Object.prototype.toString.call(value);
+
+    // 提取 'Array', 'Date', 'RegExp', 'Map', 'Set', 'Object' 等 Class 名称
+    const className = classString.slice(8, -1);
+
+    // 4. 特殊处理 Array.isArray() 
+    // 虽然 className 已经是 'Array'，但 Array.isArray 更快且明确
+    if (className === 'Array') {
+        return 'array';
+    }
+
+    // 5. 将其他内置对象和普通对象名称转为小写返回
+    return className.toLowerCase();
+}
+
+/**
+ * 判断一个字符串是否是有效的 JSON 格式
+ *
+ * @param {string} strValue - 要检查的字符串值
+ * @returns {boolean} 如果字符串是有效的 JSON 格式则返回 true，否则返回 false
+ */
+function isJsonString(strValue) {
+    // 1. 确保输入是一个字符串，如果不是，则直接返回 false
+    // JSON 格式只能是字符串
+    if (typeof strValue !== 'string') {
+        return false;
+    }
+
+    // 2. 尝试解析字符串
+    try {
+        // 使用 JSON.parse() 尝试解析。
+        // 如果解析成功，它就会返回解析后的对象或值。
+        // 如果解析失败，就会抛出 SyntaxError 错误。
+        JSON.parse(strValue);
+        
+        // 3. 额外的检查 (可选但推荐): 
+        // 确保解析结果不是原始类型值，例如 "123" 或 "true"
+        // 某些场景下，用户希望 JSON 字符串必须是对象或数组的字符串表示
+        // const parsed = JSON.parse(strValue);
+        // if (typeof parsed !== 'object' || parsed === null) {
+        //     // 如果你想排除 "123", "null", "true" 这些原始值的 JSON 字符串，可以取消注释
+        //     // return false; 
+        // }
+
+    } catch (e) {
+        // 捕获任何解析错误（通常是 SyntaxError），表示格式不符合 JSON 规范
+        return false;
+    }
+
+    // 4. 解析成功，返回 true
+    return true;
+}
+
+/**
+ * 遍历树形结构（对象或数组）的所有叶节点，将叶节点的值收集到数组中。
+ *
+ * 叶节点被定义为：值不是普通对象或数组的节点。
+ *
+ * @param {object|Array} tree - 要扁平化处理的树形结构对象或数组。
+ * @param {Array<any>} [result=[]] - 存储叶节点值的数组（递归内部使用）。
+ * @returns {Array<any>} 包含所有叶节点值的数组。
+ */
+function flattenTreeValues(tree, result = []) {
+    // 确保输入是对象或数组。如果不是，或者为 null，则直接返回结果数组。
+    if (typeof tree !== 'object' || tree === null) {
+        return result;
+    }
+
+    // 遍历对象的键（如果是数组，键就是索引）
+    for (const key in tree) {
+        // 确保只处理对象自身的属性，排除原型链上的属性
+        if (Object.prototype.hasOwnProperty.call(tree, key)) {
+            const value = tree[key];
+
+            // 判断当前值是否为“叶节点”
+            // 检查：值不是对象，且值不是 null
+            if (typeof value !== 'object' || value === null) {
+                // 1. 如果是基本类型值（叶节点），则将其压入结果数组
+                result.push(value);
+            } else {
+                // 2. 如果是对象或数组（非叶节点），则进行递归调用
+                // 注意：这里没有处理 Date, RegExp, Set, Map 等特殊对象，
+                // 默认将它们视为非叶节点，直到它们内部的值被遍历完（这通常是不对的）
+                // 
+                // 为了更精确地实现“叶节点”概念，我们将 Date, RegExp 等内置对象视为叶节点：
+                const isArray = Array.isArray(value);
+                const isPlainObject = !isArray && Object.prototype.toString.call(value) === '[object Object]';
+                
+                if (isArray || isPlainObject) {
+                    // 如果是普通数组或普通对象，则递归
+                    flattenTreeValues(value, result);
+                } else {
+                    // 如果是像 Date, RegExp, Map, Set 等特殊内置对象，
+                    // 我们将其视为叶节点的值（而不是继续遍历其内部结构）
+                    result.push(value);
+                }
+            }
+        }
+    }
+
+    return result;
+}
+
+/**
+ * 将扁平化的对象数组转换为树形结构数据，并在每个节点中保留原始数据。
+ *
+ * @param {Object[]} flatArray 待转化的扁平数组。
+ * @param {Object} inputFields 描述输入数组中字段名的对象。
+ * @param {string} inputFields.idField 节点代码字段名。
+ * @param {string} inputFields.textField 节点文本字段名。
+ * @param {string} inputFields.parentField 父节点代码字段名。
+ * @param {Object} outputFields 描述输出树形结构中字段名的对象。
+ * @param {string} outputFields.idField 输出节点代码字段名 (接收 inputFields.idField 的值)。
+ * @param {string} outputFields.textField 输出节点文本字段名 (接收 inputFields.textField 的值)。
+ * @param {string} outputFields.childrenField 子节点数组字段名。
+ * @param {string} outputFields.originDataField 原始数据字段名 (用于存储原始的 item 对象)。
+ * @returns {Object[]} 转换后的树形结构数组。
+ */
+function arrayToTree(flatArray, inputFields, outputFields) {
+    // 1. 参数校验和字段提取
+    if (!Array.isArray(flatArray) || flatArray.length === 0) {
+        return [];
+    }
+
+    // 提取输入字段名
+    const {
+        idField: inputId,
+        textField: inputText,
+        parentField: inputParent
+    } = inputFields;
+
+    // 提取输出字段名
+    const {
+        idField: outputId,
+        textField: outputText,
+        childrenField: outputChildren,
+        originDataField: outputRawData // 新增：用于存储原始数据的字段名
+    } = outputFields;
+
+    // 2. 初始化辅助数据结构
+    const tree = [];
+    const childrenMap = new Map(); // 存储所有节点，键为节点ID
+    const rootCandidates = new Set(); // 存储所有可能的根节点ID
+
+    // 3. 第一次遍历：创建所有节点并建立 ID-Node 映射
+    for (const item of flatArray) {
+        // 关键：创建一个只包含转换后字段和子节点的结构
+        const newNode = {
+            // 映射输入字段到输出字段
+            [outputId]: item[inputId],
+            [outputText]: item[inputText],
+            [outputChildren]: [], // 初始化子节点数组
+            [outputRawData]: item // 新增：存储原始数据对象
+        };
+        
+        childrenMap.set(newNode[outputId], newNode);
+        rootCandidates.add(newNode[outputId]); // 假设所有节点都是根节点
+    }
+
+    // 4. 第二次遍历：连接父子关系
+    for (const node of childrenMap.values()) {
+        const parentId = node[outputRawData][inputParent]; // 从原始数据中获取父ID
+
+        // 查找父节点
+        const parentNode = childrenMap.get(parentId);
+
+        if (parentNode) {
+            // 如果找到了父节点，则将当前节点添加到父节点的子节点列表中
+            parentNode[outputChildren].push(node);
+
+            // 如果当前节点有父节点，它就不是根节点，从根节点候选中移除
+            rootCandidates.delete(node[outputId]);
+        }
+    }
+    
+    // 5. 组装最终树结构
+    // 最终的树结构由所有仍在 rootCandidates 列表中的节点组成
+    for (const rootId of rootCandidates) {
+        const rootNode = childrenMap.get(rootId);
+        if (rootNode) {
+             tree.push(rootNode);
+        }
+    }
+
+    return tree;
+}
+
+const bean = {
+    deepClone,
+    deepCloneAndMap,
+    typeOfValue,
+    isJsonString,
+    flattenTreeValues,
+    arrayToTree
+}
+export default bean

package/src/utils/index.js

@@ -0,0 +1,12 @@
+import dateFormat from './dateFormat.js';
+import deepClone from './deepClone.js';
+import regex from './regex.js'
+import sort from './sort.js';
+
+const bean = {
+    dateFormat,
+    deepClone,
+    regex,
+    sort
+}
+export default bean

package/src/utils/regex.js

@@ -0,0 +1,119 @@
+/**
+ * 校验字符串是否为有效的中国大陆手机号码（宽松校验）
+ * 规则：以 1 开头，后面跟 10 个数字，共 11 位。
+ *
+ * @param {string} str - 需要校验的字符串
+ * @returns {boolean} - 如果是有效的手机号格式，返回 true；否则返回 false。
+ */
+function cellphone(str) {
+    if (typeof str !== 'string' || str.length === 0) {
+        return false;
+    }
+    
+    // 正则表达式：
+    // ^      -> 匹配字符串的开始
+    // 1      -> 匹配数字 1
+    // \d{10} -> 匹配任何数字 (0-9) 十次
+    // $      -> 匹配字符串的结束
+    const regex = /^1\d{10}$/;
+    
+    return regex.test(str);
+}
+
+/**
+ * 校验字符串是否为有效的电子邮件地址格式。
+ * * 这个正则是一个常用的、相对宽松但有效的校验模式。
+ * 它覆盖了：
+ * 1. 局部部分（@符号之前）：允许字母、数字、点号(.)、下划线(_)、连字符(-)。
+ * 2. 域名部分（@符号之后）：至少包含一级域名和顶级域名，允许字母、数字、连字符。
+ * 3. 顶级域名（最后一段）：必须是至少两位字母（如 .com, .cn, .co.uk）。
+ *
+ * @param {string} str - 需要校验的字符串
+ * @returns {boolean} - 如果是有效的电子邮箱格式，返回 true；否则返回 false。
+ */
+function email(str) {
+    if (typeof str !== 'string' || str.length === 0) {
+        return false;
+    }
+
+    // 正则表达式解释：
+    // ^                           -> 匹配字符串的开始
+    // [a-zA-Z0-9._-]+             -> 局部部分：匹配一个或多个字母、数字、点(.)、下划线(_)或连字符(-)
+    // @                           -> 必须包含 @ 符号
+    // [a-zA-Z0-9.-]+              -> 域名部分：匹配一个或多个字母、数字、点(.)或连字符(-)
+    // \.                          -> 必须包含一个点号（用于分隔域名和顶级域名）
+    // [a-zA-Z]{2,6}               -> 顶级域名：匹配 2 到 6 个字母 (如 com, cn, info, museum)
+    // (?:\.[a-zA-Z]{2,6})?        -> (可选) 匹配二级或多级域名（如 .co.uk）
+    // $                           -> 匹配字符串的结束
+    
+    const emailRegex = /^[a-zA-Z0-9._-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,6}(?:\.[a-zA-Z]{2,6})?$/;
+    
+    return emailRegex.test(str);
+}
+
+/**
+ * 校验字符串是否符合中等强度的登录密码要求。
+ * 规则：
+ * 1. 长度在 8 到 16 位之间。
+ * 2. 必须包含大小写字母、数字、特殊符号 (@ $ ! % * # ? &) 中的至少两种组合。
+ *
+ * @param {string} str - 需要校验的密码字符串
+ * @returns {boolean} - 如果符合密码要求，返回 true；否则返回 false。
+ */
+function password(str) {
+    if (typeof str !== 'string' || str.length === 0) {
+        return false;
+    }
+
+    // --- 1. 长度校验 ---
+    // 匹配 8 到 16 位任何非换行符的字符
+    const lengthRegex = /^.{8,16}$/;
+    if (!lengthRegex.test(str)) {
+        // console.log("密码长度不符合要求（需 8-16 位）。");
+        return false;
+    }
+
+    // --- 2. 字符组合校验（使用正向预查 Lookaheads） ---
+    
+    // 正向预查的定义：
+    // (?=.*[a-z]) : 必须包含小写字母
+    // (?=.*[A-Z]) : 必须包含大写字母
+    // (?=.*\d)    : 必须包含数字
+    // (?=.*[@$!%*#?&]) : 必须包含特殊符号
+    
+    // 构造四个组合的正则，只要满足任意两个即可
+
+    let count = 0;
+
+    // 检查是否包含小写字母
+    if (/(?=.*[a-z])/.test(str)) {
+        count++;
+    }
+
+    // 检查是否包含大写字母
+    if (/(?=.*[A-Z])/.test(str)) {
+        count++;
+    }
+
+    // 检查是否包含数字
+    if (/(?=.*\d)/.test(str)) {
+        count++;
+    }
+
+    // 检查是否包含特殊符号
+    if (/(?=.*[@$!%*#?&])/.test(str)) {
+        count++;
+    }
+    
+    // 最终判断：至少包含两种类型的字符
+    const isCombinationValid = count >= 2;
+
+    // console.log(`满足的字符类型数量: ${count}`);
+    return isCombinationValid;
+}
+
+const bean = {
+    cellphone,
+    email,
+    password
+}

package/src/utils/sort.js

@@ -0,0 +1,238 @@
+/**
+ * 对一个由简单数据类型的值（数值、字符串、日期等）组成的数组进行排序。
+ *
+ * @param {Array<any>} arr 待排序的简单数据类型数组。
+ * @param {'asc' | 'desc'} direction 排序方向：'asc'（升序）或 'desc'（降序）。
+ * @param {'locale' | 'natural'} sortType 排序类型：
+ * - 'locale': 字典顺序排序。
+ * - 'natural': 自然顺序排序。
+ * @returns {Array<any>} 排序后的新数组。
+ */
+function sortSimpleArray(arr, direction, sortType) {
+    // 1. 参数校验 (简化)
+    if (!Array.isArray(arr)) {
+        console.error("第一个参数必须是一个数组。");
+        return [];
+    }
+    const validDirections = ['asc', 'desc'];
+    const validSortTypes = ['locale', 'natural'];
+
+    if (!validDirections.includes(direction) || !validSortTypes.includes(sortType)) {
+        console.error("排序方向或排序类型参数无效。");
+        return [...arr];
+    }
+
+    // 2. 创建数组副本
+    const sortedArr = arr.slice();
+
+    // 3. 定义类型处理和排序分组规则
+    // JavaScript 的 sort() 方法会将 undefined 和 null 移到末尾，
+    // 但为了确保排序稳定性和一致性，我们在这里显式处理它们。
+    const comparator = (a, b) => {
+        const isNullA = (a === null || typeof a === 'undefined');
+        const isNullB = (b === null || typeof b === 'undefined');
+
+        // 规则 A: 将 null/undefined 分组到末尾（默认行为）
+        if (isNullA && !isNullB) return 1;
+        if (!isNullA && isNullB) return -1;
+        if (isNullA && isNullB) return 0;
+
+        // 规则 B: 统一转换为字符串进行比较
+        // Date 对象会转为 ISO 字符串，Boolean 会转为 'true'/'false'
+        const strA = String(a);
+        const strB = String(b);
+
+        let comparison = 0;
+
+        // --- 内部比较逻辑 ---
+        if (sortType === 'locale') {
+            // 字典顺序
+            if (strA < strB) {
+                comparison = -1;
+            } else if (strA > strB) {
+                comparison = 1;
+            }
+        } else if (sortType === 'natural') {
+            // 自然顺序 (处理数字串和字母数字串)
+            comparison = strA.localeCompare(strB, undefined, { numeric: true, sensitivity: 'base' });
+        }
+
+        // 4. 根据排序方向调整结果
+        return direction === 'asc' ? comparison : -comparison;
+    };
+
+    // 5. 执行排序
+    sortedArr.sort(comparator);
+
+    return sortedArr;
+}
+
+/**
+ * 对一个由对象组成的数组进行多级排序。
+ *
+ * @param {Object[]} arr 待排序的对象数组。
+ * @param {Array<{field: string, direction: 'asc'|'desc', sortType: 'locale'|'natural'}>} sortRules 排序规则数组。
+ * - field: 用于排序的对象属性名称（字符串）。
+ * - direction: 排序方向，'asc'（升序）或 'desc'（降序）。
+ * - sortType: 排序类型，'locale'（字典/字母顺序）或 'natural'（自然顺序）。
+ * @returns {Object[]} 排序后的新数组。
+ */
+function sortObjectArrayMultiLevel(arr, sortRules) {
+    // 1. 参数校验
+    if (!Array.isArray(arr) || !Array.isArray(sortRules) || sortRules.length === 0) {
+        // 如果数组无效或规则为空，则返回数组副本
+        return [...arr];
+    }
+
+    // 2. 创建数组副本，以确保函数是纯函数（不修改原始数组）
+    const sortedArr = arr.slice();
+
+    // 3. 定义多级比较器
+    const multiLevelComparator = (a, b) => {
+        // 遍历所有排序规则，按顺序进行比较
+        for (const rule of sortRules) {
+            const { field, direction, sortType } = rule;
+
+            // 检查规则的有效性
+            if (!field || !['asc', 'desc'].includes(direction) || !['locale', 'natural'].includes(sortType)) {
+                console.warn(`跳过无效的排序规则: ${JSON.stringify(rule)}`);
+                continue; // 跳过当前规则，尝试下一个
+            }
+            
+            // 获取待比较的字段值
+            const valA = a[field];
+            const valB = b[field];
+
+            let comparison = 0;
+            
+            // --- 核心比较逻辑 ---
+            
+            // 为了实现自然排序和字典排序的一致性，我们将值统一转换为字符串进行比较
+            const strA = String(valA);
+            const strB = String(valB);
+            
+            if (sortType === 'locale') {
+                // 字典顺序 (Lexicographical Order)
+                if (strA < strB) {
+                    comparison = -1;
+                } else if (strA > strB) {
+                    comparison = 1;
+                }
+            } else if (sortType === 'natural') {
+                // 自然顺序 (Natural Sort Order)
+                // 使用 localeCompare 配合 { numeric: true } 选项
+                comparison = strA.localeCompare(strB, undefined, { numeric: true, sensitivity: 'base' });
+            }
+
+            // --- 调整排序结果并返回 ---
+            
+            // 如果 comparison 不为 0，说明在当前字段上找到了差异，可以直接返回结果
+            if (comparison !== 0) {
+                // 根据排序方向调整比较结果
+                return direction === 'asc' ? comparison : -comparison;
+            }
+
+            // 如果 comparison 为 0 (值相等)，则继续循环，使用下一个规则进行比较
+        }
+
+        // 如果所有规则都比较完了，值仍然相等，则认为它们的相对顺序不重要
+        return 0;
+    };
+
+    // 4. 执行排序
+    sortedArr.sort(multiLevelComparator);
+
+    return sortedArr;
+}
+
+/**
+ * 对一个由简单数据类型组成的数组进行去重。
+ * 使用 Set 对象，这是现代 JavaScript 中最推荐和最简洁的方法。
+ *
+ * @param {Array<any>} arr 待去重的数组（可包含数值、字符串、布尔值、null、undefined 等）。
+ * @returns {Array<any>} 包含唯一元素的新数组。
+ */
+const uniqueSimpleArray = (arr) => {
+    // 1. 检查输入是否为数组
+    if (!Array.isArray(arr)) {
+        console.error("输入必须是一个数组。");
+        return [];
+    }
+
+    // 2. 创建一个 Set 对象，Set 会自动过滤重复的值
+    // 3. 使用扩展运算符 (...) 将 Set 转换回数组
+    return [...new Set(arr)];
+}
+
+/**
+ * 对一个由对象组成的数组进行去重，根据多个指定的字段判断重复。
+ * 优化：在判断重复时，同时考虑字段的值和数据类型。
+ *
+ * @param {Object[]} arr 待去重的对象数组。
+ * @param {string[]} fields 用于判断重复的字段名数组。当所有指定字段的值和类型都相同时，视为重复。
+ * @returns {Object[]} 包含唯一元素的新数组，保留第一次出现的记录。
+ */
+function uniqueObjectArrayByFields(arr, fields) {
+    // 1. 参数校验
+    if (!Array.isArray(arr) || arr.length === 0) {
+        return [];
+    }
+    if (!Array.isArray(fields) || fields.length === 0) {
+        console.warn("未指定用于判断重复的字段，将返回原始数组副本。");
+        return [...arr];
+    }
+
+    // 用于存储已见过的唯一键
+    const seenKeys = new Set();
+    const uniqueArray = [];
+    const DELIMITER = "|||";
+
+    // 2. 遍历原始数组
+    for (const item of arr) {
+        // 3. 构建唯一键 (同时包含值和类型)
+        const keyParts = [];
+        
+        for (const field of fields) {
+            const value = item[field];
+            const type = typeof value;
+
+            let valueString;
+            
+            // 确保复杂类型（如对象、日期）也能被正确且唯一地表示
+            if (type === 'object' && value !== null) {
+                // 对于对象/数组/日期，使用 JSON 序列化
+                valueString = JSON.stringify(value);
+            } else if (type === 'undefined' || value === null) {
+                // 明确区分 undefined 和 null
+                valueString = String(value);
+            } else {
+                // 对于简单类型（string, number, boolean），直接转换为字符串
+                valueString = String(value);
+            }
+
+            // 键结构: [值字符串] + [DELIMITER] + [数据类型]
+            // 例如： '1|||number' 或 '1|||string'
+            keyParts.push(valueString + DELIMITER + type);
+        }
+        
+        // 最终键由所有字段的键结构连接而成
+        const uniqueKey = keyParts.join(DELIMITER);
+
+        // 4. 检查是否重复
+        if (!seenKeys.has(uniqueKey)) {
+            // 如果这个键是第一次出现，则保留
+            seenKeys.add(uniqueKey);
+            uniqueArray.push(item);
+        }
+    }
+
+    return uniqueArray;
+}
+
+const bean = {
+    sortSimpleArray,
+    sortObjectArrayMultiLevel,
+    uniqueSimpleArray,
+    uniqueObjectArrayByFields
+}
+export default bean

package/test.js

@@ -0,0 +1 @@
+import bean from './index.js';