@yoooloo42/bean 1.0.16 → 1.0.18

package/src/unclassified/random.js

@@ -1,117 +0,0 @@
-/**
- * 在指定的字符集内生成一个指定长度的随机字符串。
- *
- * @param {number} length - 随机字符串的所需长度。
- * @param {string} characterSet - 用于生成字符串的字符集（如 '0123456789abcdef'）。
- * @returns {string} - 生成的随机字符串。
- * @throws {Error} - 如果长度不是正数或字符集为空。
- */
-function random(length, characterSet) {
-    // 1. 输入校验
-    if (typeof length !== 'number' || length <= 0) {
-        throw new Error("长度参数必须是一个大于零的数字。");
-    }
-    if (typeof characterSet !== 'string' || characterSet.length === 0) {
-        throw new Error("字符集参数必须是一个非空字符串。");
-    }
-
-    const characterSetLength = characterSet.length;
-    let result = '';
-
-    // 2. 循环 'length' 次，每次随机选择一个字符
-    for (let i = 0; i < length; i++) {
-        // 随机选择字符的索引
-        const randomIndex = Math.floor(Math.random() * characterSetLength);
-
-        // 将随机选中的字符添加到结果字符串中
-        result += characterSet.charAt(randomIndex);
-    }
-
-    return result;
-}
-
-/**
- * 随机生成一个符合常见验证码规则（4-8位，数字+大小写字母）的字符串。
- * @returns {string} - 随机生成的验证码字符串。
- */
-function vercode() {
-    // 定义所有允许的字符集 (数字 0-9, 小写字母 a-z, 大写字母 A-Z)
-    const characterSet = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
-    const characterSetLength = characterSet.length;
-
-    // 随机确定验证码的长度，范围在 [4, 8] 之间
-    // Math.random() * (max - min + 1) + min
-    const minLength = 4;
-    const maxLength = 8;
-    const length = Math.floor(Math.random() * (maxLength - minLength + 1)) + minLength;
-
-    let result = '';
-
-    // 循环 'length' 次，每次随机从 characterSet 中选择一个字符
-    for (let i = 0; i < length; i++) {
-        // 随机选择字符的索引
-        const randomIndex = Math.floor(Math.random() * characterSetLength);
-
-        // 将随机选中的字符添加到结果字符串中
-        result += characterSet.charAt(randomIndex);
-    }
-
-    return result;
-}
-
-/**
- * 随机生成一个固定 6 位长度、包含数字和大小写字母的验证码字符串。
- * @returns {string} - 随机生成的 6 位验证码字符串。
- */
-function vercode6(length = 6) {
-    // 定义所有允许的字符集 (数字 0-9, 小写字母 a-z, 大写字母 A-Z)
-    const characterSet = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
-    const characterSetLength = characterSet.length;
-
-    let result = '';
-    // 循环 6 次，每次随机从 characterSet 中选择一个字符
-    for (let i = 0; i < length; i++) {
-        // 随机选择字符的索引
-        const randomIndex = Math.floor(Math.random() * characterSetLength);
-
-        // 将随机选中的字符添加到结果字符串中
-        result += characterSet.charAt(randomIndex);
-    }
-
-    return result;
-}
-
-/**
- * 随机生成一个固定 6 位长度、只包含数字的验证码字符串。
- * @returns {string} - 随机生成的 6 位验证码字符串。
- */
-function vercode6N(length = 6) {
-    // 定义所有允许的字符集 (数字 0-9, 小写字母 a-z, 大写字母 A-Z)
-    const characterSet = '0123456789';
-    const characterSetLength = characterSet.length;
-
-    let result = '';
-    // 循环 6 次，每次随机从 characterSet 中选择一个字符
-    for (let i = 0; i < length; i++) {
-        // 随机选择字符的索引
-        const randomIndex = Math.floor(Math.random() * characterSetLength);
-
-        // 将随机选中的字符添加到结果字符串中
-        result += characterSet.charAt(randomIndex);
-    }
-
-    return result;
-}
-
-export {
-    random,
-    vercode,
-    vercode6,
-    vercode6N
-}
-export default {
-    random,
-    vercode,
-    vercode6,
-    vercode6N
-}

package/src/unclassified/regexp.js

@@ -1,175 +0,0 @@
-/**
- * 校验字符串是否为有效的中国大陆手机号码（宽松校验）
- * 规则：以 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;
-}
-
-/**
- * 验证一个字符串是否符合常见的验证码规则。
- * 规则：长度在 4 到 8 位之间，内容只包含数字和大小写字母。
- * * @param {string} str - 需要验证的字符串。
- * @returns {boolean} - 如果符合规则返回 true，否则返回 false。
- */
-function vercode(str) {
-    // 1. 检查输入是否为字符串
-    if (typeof str !== 'string') {
-        return false;
-    }
-
-    // 2. 正则表达式解释：
-    // ^ 表示字符串的开始
-    // [0-9a-zA-Z] 表示字符必须是数字（0-9）或大小写字母（a-z, A-Z）
-    // {4,8} 表示字符的长度必须在 4 到 8 位之间（包含 4 和 8）
-    // $ 表示字符串的结束
-    const Regex = /^[0-9a-zA-Z]{4,8}$/;
-
-    // 3. 执行匹配
-    return Regex.test(str);
-}
-
-/**
- * 验证一个字符串是否符合固定的 6 位验证码规则。
- * 规则：长度必须是 6 位，内容只包含数字和大小写字母。
- * @param {string} str - 需要验证的字符串。
- * @param {number} length - 验证码必须具备的固定长度
- * @returns {boolean} - 如果符合规则返回 true，否则返回 false。
- */
-function vercode6(str, length=6) {
-    // 1. 检查输入是否为字符串（可选，但推荐）
-    if (typeof str !== 'string') {
-        return false;
-    }
-
-    // 2. 正则表达式解释：
-    // ^ 表示字符串的开始
-    // [0-9a-zA-Z] 表示字符必须是数字（0-9）或大小写字母（a-z, A-Z）
-    // {6} 表示字符的长度必须恰好是 6 位
-    // $ 表示字符串的结束
-    const Regex = new RegExp('^[0-9a-zA-Z]{' + length + '}$');
-
-    // 3. 执行匹配
-    return Regex.test(str);
-}
-
-export {
-    cellphone,
-    email,
-    password,
-    vercode,
-    vercode6
-}
-export default {
-    cellphone,
-    email,
-    password,
-    vercode,
-    vercode6
-}

package/src/unclassified/sort.js

@@ -1,243 +0,0 @@
-/**
- * 对一个由简单数据类型的值（数值、字符串、日期等）组成的数组进行排序。
- *
- * @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;
-}
-
-export {
-    sortSimpleArray,
-    sortObjectArrayMultiLevel,
-    uniqueSimpleArray,
-    uniqueObjectArrayByFields
-}
-export default {
-    sortSimpleArray,
-    sortObjectArrayMultiLevel,
-    uniqueSimpleArray,
-    uniqueObjectArrayByFields
-}