@syzlm/function 1.0.0

package/src/numbers/numberUtils.ts

@@ -0,0 +1,121 @@
+/**
+ * 数字范围生成函数
+ * @param start 起始数字
+ * @param end 结束数字
+ * @param step 步长
+ * @returns 生成的数字数组
+ */
+export function range(start: number, end: number, step: number = 1): number[] {
+  const result: number[] = [];
+  for (let i = start; i <= end; i += step) {
+    result.push(i);
+  }
+  return result;
+}
+
+/**
+ * 数字四舍五入函数
+ * @param num 需要四舍五入的数字
+ * @param decimals 保留小数位数
+ * @returns 四舍五入后的数字
+ */
+export function round(num: number, decimals: number = 0): number {
+  const factor = Math.pow(10, decimals);
+  return Math.round(num * factor) / factor;
+}
+
+/**
+ * 数字在指定范围内的限制函数
+ * @param num 需要限制的数字
+ * @param min 最小值
+ * @param max 最大值
+ * @returns 限制后的数字
+ */
+export function clamp(num: number, min: number, max: number): number {
+  return Math.min(Math.max(num, min), max);
+}
+
+/**
+ * 精确的数字toFixed函数
+ * @param num 需要处理的数字
+ * @param digits 保留小数位数
+ * @returns 格式化后的字符串
+ */
+export function toFixed(num: number, digits: number = 0): string {
+  // 转换为字符串以避免浮点数精度问题
+  let numStr = String(num);
+  let isNegative = numStr.startsWith('-');
+  if (isNegative) {
+    numStr = numStr.slice(1);
+  }
+
+  // 处理科学计数法
+  if (numStr.includes('e') || numStr.includes('E')) {
+    const [base, exponent] = numStr.split(/[eE]/);
+    let exp = parseInt(exponent);
+    let [intPart, decPart] = base.split('.');
+    decPart = decPart || '';
+    
+    if (exp >= 0) {
+      // 科学计数法表示的是整数
+      numStr = intPart + decPart.padEnd(exp, '0');
+    } else {
+      // 科学计数法表示的是小数
+      numStr = '0.' + '0'.repeat(-exp - 1) + intPart + decPart;
+    }
+  }
+
+  // 分割整数和小数部分
+  let [integerPart, decimalPart] = numStr.split('.');
+  decimalPart = decimalPart || '';
+
+  // 处理保留小数位数
+  if (digits < 0) {
+    digits = 0;
+  }
+
+  // 四舍五入处理
+  if (decimalPart.length > digits) {
+    // 需要四舍五入
+    let roundDigit = parseInt(decimalPart[digits]);
+    let newDecimalPart = decimalPart.slice(0, digits);
+    
+    // 如果下一位大于等于5，则进位
+    if (roundDigit >= 5) {
+      // 将小数部分转换为数字加1
+      let carry = 1;
+      const newDecimalArray = newDecimalPart.split('');
+      
+      // 从小数部分的最后一位开始处理进位
+      for (let i = newDecimalArray.length - 1; i >= 0 && carry > 0; i--) {
+        let digit = parseInt(newDecimalArray[i]) + carry;
+        if (digit === 10) {
+          newDecimalArray[i] = '0';
+          carry = 1;
+        } else {
+          newDecimalArray[i] = digit.toString();
+          carry = 0;
+        }
+      }
+      
+      newDecimalPart = newDecimalArray.join('');
+      
+      // 如果小数部分全部进位了，则整数部分加1
+      if (carry > 0) {
+        integerPart = (parseInt(integerPart) + 1).toString();
+      }
+    }
+    
+    decimalPart = newDecimalPart;
+  } else {
+    // 不足位数补零
+    decimalPart = decimalPart.padEnd(digits, '0');
+  }
+
+  // 拼接结果
+  if (digits === 0) {
+    return (isNegative ? '-' : '') + integerPart;
+  } else {
+    return (isNegative ? '-' : '') + integerPart + '.' + decimalPart;
+  }
+}

package/src/objects/index.ts

@@ -0,0 +1,2 @@
+// 对象工具函数目录入口
+export * from './objectUtils';

package/src/objects/objectUtils.ts

@@ -0,0 +1,107 @@
+/**
+ * 对象深拷贝函数
+ * @param obj 需要深拷贝的对象
+ * @returns 深拷贝后的新对象
+ */
+export function deepClone<T>(obj: T): T {
+  if (obj === null || typeof obj !== 'object') {
+    return obj;
+  }
+  
+  if (obj instanceof Date) {
+    return new Date(obj.getTime()) as unknown as T;
+  }
+  
+  if (obj instanceof Array) {
+    return obj.map(item => deepClone(item)) as unknown as T;
+  }
+  
+  if (typeof obj === 'object') {
+    const clonedObj = {} as T;
+    for (const key in obj) {
+      if (obj.hasOwnProperty(key)) {
+        clonedObj[key as keyof T] = deepClone(obj[key as keyof T]);
+      }
+    }
+    return clonedObj;
+  }
+  
+  return obj;
+}
+
+/**
+ * 对象合并函数
+ * @param target 目标对象
+ * @param sources 源对象列表
+ * @returns 合并后的对象
+ */
+export function merge<T extends object>(target: T, ...sources: any[]): T {
+  return Object.assign({}, target, ...sources);
+}
+
+/**
+ * 获取对象属性值（支持路径访问）
+ * @param obj 目标对象
+ * @param path 属性路径，如 'a.b.c'
+ * @param defaultValue 默认值
+ * @returns 属性值或默认值
+ */
+export function get(obj: any, path: string, defaultValue?: any): any {
+  const keys = path.split('.');
+  let result: any = obj;
+  
+  for (const key of keys) {
+    if (result === null || result === undefined) {
+      return defaultValue;
+    }
+    result = result[key];
+  }
+  
+  return result === undefined ? defaultValue : result;
+}
+
+/**
+ * 设置对象属性值（支持路径访问）
+ * @param obj 目标对象
+ * @param path 属性路径，如 'a.b.c'
+ * @param value 要设置的值
+ * @returns 设置后的对象
+ */
+export function set<T extends Record<string, any>>(obj: T, path: string, value: any): T {
+  const keys = path.split('.');
+  let current: Record<string, any> = obj;
+  
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (current[key] === null || current[key] === undefined) {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  
+  current[keys[keys.length - 1]] = value;
+  return obj;
+}
+
+/**
+ * 检查一个值是否是普通对象
+ * @param value 要检查的值
+ * @returns 如果是普通对象返回true，否则返回false
+ */
+export function isPlainObject(value: any): value is object {
+  if (value === null || typeof value !== 'object') {
+    return false;
+  }
+  
+  const proto = Object.getPrototypeOf(value);
+  
+  // 对象的原型应该是null或者Object.prototype
+  return proto === null || proto === Object.prototype;
+}
+
+/**
+ * @description 检测对象是否存在指定属性
+ * @param {object} obj 带检测对象
+ * @param {string} str 属性名称
+ */
+export default (obj: object, str: string) => obj && Object.prototype.hasOwnProperty.call(obj, str);

package/src/storage/index.ts

@@ -0,0 +1 @@
+export * from './storage';

package/src/storage/storage.ts

@@ -0,0 +1,83 @@
+/*
+ * @Description:
+ * @LastEditTime: 2025-10-11 15:51:11
+ * @FilePath: /admin/src/libs/storage.ts
+ */
+import { isPlainObject } from '../objects';
+
+// 重命名为与原代码一致的名称，保持兼容性
+const isStrictObject = isPlainObject;
+
+function getItem(storage: Storage, keys: string, needParse = true) {
+  const name = String(keys);
+  if (!name) {
+    if (process.env.NODE_ENV === 'development') {
+      console.error('请输入getItem方法的name');
+    }
+    return null;
+  }
+  try {
+    const result = storage.getItem(name) || '';
+    const reg = /^(\[|\{)[\s\S]*(\]|\})$/g;
+    if (needParse && reg.test(result as string)) {
+      return JSON.parse(result);
+    }
+    return result;
+  } catch (err) {
+    console.error('getItem:', err);
+  }
+  return null;
+}
+/**
+ * @func 本地存储存数据
+ * @return <Object, String>
+ * @param name <Object, String> 存储名称
+ * @param value <String> 存储值
+ */
+function setItem(
+  storage: Storage,
+  keys: string,
+  value: string | object | object[] | string[] | number[],
+) {
+  const name = String(keys);
+  let storageValue = value;
+  if (!name) {
+    if (process.env.NODE_ENV === 'development') {
+      console.error('请输入setItem方法的key');
+    }
+    return;
+  }
+  if (Array.isArray(storageValue) || isStrictObject(storageValue)) {
+    storageValue = JSON.stringify(value);
+  } else {
+    storageValue = String(value || '');
+  }
+  storage.setItem(name, storageValue);
+}
+/**
+ * 清除本地缓存
+ */
+function removeItem(storage: Storage, keys: string) {
+  const name = String(keys);
+  if (!name) return;
+  storage.removeItem(name);
+}
+
+function clear(storage: Storage) {
+  storage.clear();
+}
+
+export const sessionStorage = {
+  setItem: (k: string, a: any) => setItem(window.sessionStorage, k, a),
+  getItem: (k: string, needParse = true) => getItem(window.sessionStorage, k, needParse),
+  removeItem: (k: string) => removeItem(window.sessionStorage, k),
+  clear: () => clear(window.sessionStorage),
+
+};
+
+export const localStorage = {
+  setItem: (k: string, a: any) => setItem(window.localStorage, k, a),
+  getItem: (k: string, needParse = true) => getItem(window.localStorage, k, needParse),
+  removeItem: (k: string) => removeItem(window.localStorage, k),
+  clear: () => clear(window.localStorage),
+};

package/src/strings/index.ts

@@ -0,0 +1,2 @@
+// 字符串工具函数目录入口
+export * from './stringUtils';

package/src/strings/stringUtils.ts

@@ -0,0 +1,120 @@
+
+
+import { toFixed } from '../numbers/numberUtils';
+
+/**
+ * 字符串驼峰命名转换函数
+ * @param str 需要转换的字符串
+ * @returns 驼峰命名的字符串
+ */
+export function toCamelCase(str: string): string {
+  return str.replace(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : '');
+}
+
+/**
+ * 字符串首字母大写函数
+ * @param str 需要转换的字符串
+ * @returns 首字母大写的字符串
+ */
+export function capitalize(str: string): string {
+  if (!str) return str;
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+/**
+ * 生成随机字符串函数
+ * @param length 字符串长度
+ * @returns 随机字符串
+ */
+export function randomString(length: number): string {
+  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+  let result = '';
+  for (let i = 0; i < length; i++) {
+    result += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return result;
+}
+
+
+/**
+ * 转换字符串，undefined,null等转化为""
+ * @param str 需要转换的字符串
+ * @returns 转换后的字符串
+ */
+export function parseStrEmpty(str: string): string {
+  if (!str || str === 'undefined' || str === 'null') {
+    return '';
+  }
+  return str;
+}
+
+/**
+ * 获取字符串的字体长度
+ * @param str 需要计算长度的字符串
+ * @returns 字符串的字体长度（中文字符算2个长度，英文字符算1个长度）
+ */ 
+export function getFontLength(str: string): number {
+  let len = 0;
+  for (let i = 0; i < str.length; i++) {
+    if (str.charCodeAt(i) > 127 || str.charCodeAt(i) === 94) {
+      len += 2;
+    } else {
+      len += 1;
+    }
+  }
+  return len;
+}
+
+/**
+ * 获取文字宽度
+ * @param str 需要计算宽度的字符串
+ * @param fontStyle 字体样式，可选，默认使用系统默认字体
+ * @returns 文字宽度（像素）
+ */
+export function getFontWidth(str: string, fontStyle?: string): number {
+  let canvas: any | null = typeof document !== 'undefined' ? document.createElement('canvas') : null;
+  const ctx = canvas.getContext('2d') as CanvasRenderingContext2D;
+  ctx.font =
+    fontStyle ||
+    '600 14px / 22px -apple-system, "system-ui", "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji"';
+  const width = ctx.measureText(str).width;
+
+  canvas = null;
+  return width;
+}
+
+/**
+ * 千分位格式化
+ * @param num 需要格式化的数字或字符串
+ * @returns 千分位格式化后的字符串
+ */
+export function thousandSign(num: number | string): string {
+  if (num) {
+    const [integer, decimal] = String(num).split('.');
+    let ret = integer.replace(/\d(?=(\d{3})+$)/g, '$&,');
+    if (decimal) {
+      ret += Number(decimal) > 0 ? `${parseFloat(`0.${decimal}`)}`.replace(/0\./, '.') : '';
+    }
+    return ret;
+  }
+  return String(num || '0').replace(/\d(?=(\d{3})+$)/g, '$&,');
+}
+/**
+ * 千分位格式化 自动补零
+ * @param num 需要格式化的数字或字符串
+ * @param fixed 保留的小数位数，默认2位
+ * @returns 千分位格式化后的字符串
+ */
+export function thousandSignZero(num: number | string, fixed?: number): string {
+  if (num) {
+    // 使用精确的toFixed函数
+    const numStr = toFixed(Number(num), fixed || 2);
+    const [integer, decimal] = numStr.split('.');
+    let ret = integer.replace(/\d(?=(\d{3})+$)/g, '$&,');
+    if (decimal) {
+      ret += `.${decimal}`;
+    }
+    return ret;
+  }
+  return String(num || '0.00').replace(/\d(?=(\d{3})+$)/g, '$&,');
+}

package/src/utils/index.ts

@@ -0,0 +1,2 @@
+// 通用工具函数目录入口
+export * from './utilFunctions';

package/src/utils/utilFunctions.ts

@@ -0,0 +1,45 @@
+/**
+ * 防抖函数
+ * @param func 需要防抖的函数
+ * @param wait 等待时间（毫秒）
+ * @returns 防抖后的函数
+ */
+export function debounce<T extends (...args: any[]) => any>(
+  func: T,
+  wait: number
+): (...args: Parameters<T>) => void {
+  let timeoutId: NodeJS.Timeout;
+  return (...args: Parameters<T>) => {
+    clearTimeout(timeoutId);
+    timeoutId = setTimeout(() => func(...args), wait);
+  };
+}
+
+/**
+ * 节流函数
+ * @param func 需要节流的函数
+ * @param limit 限制时间（毫秒）
+ * @returns 节流后的函数
+ */
+export function throttle<T extends (...args: any[]) => any>(
+  func: T,
+  limit: number
+): (...args: Parameters<T>) => void {
+  let inThrottle: boolean;
+  return (...args: Parameters<T>) => {
+    if (!inThrottle) {
+      func(...args);
+      inThrottle = true;
+      setTimeout(() => inThrottle = false, limit);
+    }
+  };
+}
+
+/**
+ * 延迟函数
+ * @param ms 延迟时间（毫秒）
+ * @returns Promise对象
+ */
+export function delay(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}

package/test-output.txt

@@ -0,0 +1,23 @@
+-------------------|---------|----------|---------|---------|-------------------
+File               | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s 
+-------------------|---------|----------|---------|---------|-------------------
+All files          |   22.07 |    25.61 |    9.52 |   22.59 |                   
+ src               |       0 |        0 |       0 |       0 |                   
+  index.ts         |       0 |      100 |     100 |       0 | 5-17              
+  storage.ts       |       0 |        0 |       0 |       0 | 6-82              
+ src/arrays        |       0 |      100 |       0 |       0 |                   
+  arrayUtils.ts    |       0 |      100 |       0 |       0 | 6-35              
+  index.ts         |       0 |      100 |     100 |       0 | 2                 
+ src/numbers       |   96.07 |    93.93 |     100 |   95.91 |                   
+  index.ts         |       0 |      100 |     100 |       0 | 2                 
+  numberUtils.ts   |      98 |    93.93 |     100 |   97.91 | 61                
+ src/objects       |       0 |        0 |       0 |       0 |                   
+  index.ts         |       0 |      100 |     100 |       0 | 2                 
+  objectUtils.ts   |       0 |        0 |       0 |       0 | 6-99              
+ src/strings       |       0 |        0 |       0 |       0 |                   
+  index.ts         |       0 |      100 |     100 |       0 | 2                 
+  stringUtils.ts   |       0 |        0 |       0 |       0 | 3-115             
+ src/utils         |       0 |        0 |       0 |       0 |                   
+  index.ts         |       0 |      100 |     100 |       0 | 2                 
+  utilFunctions.ts |       0 |        0 |       0 |       0 | 7-44              
+-------------------|---------|----------|---------|---------|-------------------

package/test-tofixed.js

@@ -0,0 +1,36 @@
+// 测试精确的toFixed函数
+const { toFixed } = require('./dist/index.js');
+
+// 测试用例：原生toFixed有问题的小数
+const testCases = [
+  0.1,
+  0.2,
+  0.1 + 0.2,
+  1.005,
+  2.56789,
+  -0.1,
+  -1.005,
+  1234.56789
+];
+
+console.log('测试精确的toFixed函数：');
+console.log('====================================');
+console.log('数字 | 原生toFixed(2) | 精确toFixed(2)');
+console.log('====================================');
+
+testCases.forEach(num => {
+  const nativeResult = num.toFixed(2);
+  const preciseResult = toFixed(num, 2);
+  console.log(`${num} | ${nativeResult} | ${preciseResult}`);
+});
+
+console.log('====================================');
+console.log('\n测试不同小数位数：');
+console.log('====================================');
+
+const num = 1.005;
+for (let i = 1; i <= 5; i++) {
+  const nativeResult = num.toFixed(i);
+  const preciseResult = toFixed(num, i);
+  console.log(`toFixed(${i}) | 原生: ${nativeResult} | 精确: ${preciseResult}`);
+}

package/tests/arrays.test.ts

@@ -0,0 +1,89 @@
+import { unique, shuffle, chunk } from '../src/arrays/arrayUtils';
+
+describe('数组工具函数测试', () => {
+  describe('unique 函数', () => {
+    it('应该正确去重基本类型数组', () => {
+      expect(unique([1, 2, 2, 3, 4, 4, 5])).toEqual([1, 2, 3, 4, 5]);
+      expect(unique(['a', 'b', 'b', 'c'])).toEqual(['a', 'b', 'c']);
+      expect(unique([true, false, true])).toEqual([true, false]);
+    });
+
+    it('应该正确处理空数组', () => {
+      expect(unique([])).toEqual([]);
+    });
+
+    it('应该正确处理没有重复元素的数组', () => {
+      expect(unique([1, 2, 3, 4, 5])).toEqual([1, 2, 3, 4, 5]);
+    });
+
+    it('应该正确处理包含多种类型元素的数组', () => {
+      const arr = [1, '1', 2, '2', true, false, true];
+      const result = unique(arr);
+      expect(result.length).toBe(6);
+      expect(result).toContain(1);
+      expect(result).toContain('1');
+      expect(result).toContain(2);
+      expect(result).toContain('2');
+      expect(result).toContain(true);
+      expect(result).toContain(false);
+    });
+  });
+
+  describe('shuffle 函数', () => {
+    it('应该随机打乱数组元素', () => {
+      const arr = [1, 2, 3, 4, 5];
+      const shuffled = shuffle(arr);
+      
+      // 检查数组长度是否相同
+      expect(shuffled.length).toBe(arr.length);
+      
+      // 检查所有元素是否都在
+      expect(shuffled).toEqual(expect.arrayContaining(arr));
+      
+      // 检查顺序是否被打乱（虽然有极小概率顺序不变，但多次测试应该会通过）
+      const results = new Set();
+      for (let i = 0; i < 10; i++) {
+        results.add(JSON.stringify(shuffle(arr)));
+      }
+      expect(results.size).toBeGreaterThan(1);
+    });
+
+    it('应该不修改原始数组', () => {
+      const arr = [1, 2, 3, 4, 5];
+      const original = [...arr];
+      shuffle(arr);
+      expect(arr).toEqual(original);
+    });
+
+    it('应该正确处理空数组', () => {
+      expect(shuffle([])).toEqual([]);
+    });
+
+    it('应该正确处理单元素数组', () => {
+      expect(shuffle([42])).toEqual([42]);
+    });
+  });
+
+  describe('chunk 函数', () => {
+    it('应该正确将数组分块', () => {
+      expect(chunk([1, 2, 3, 4, 5, 6], 2)).toEqual([[1, 2], [3, 4], [5, 6]]);
+      expect(chunk([1, 2, 3, 4, 5], 2)).toEqual([[1, 2], [3, 4], [5]]);
+    });
+
+    it('应该正确处理空数组', () => {
+      expect(chunk([], 2)).toEqual([]);
+    });
+
+    it('应该正确处理数组长度正好是块大小的倍数', () => {
+      expect(chunk([1, 2, 3, 4, 5, 6], 3)).toEqual([[1, 2, 3], [4, 5, 6]]);
+    });
+
+    it('应该正确处理块大小大于数组长度的情况', () => {
+      expect(chunk([1, 2, 3], 5)).toEqual([[1, 2, 3]]);
+    });
+
+    it('应该正确处理块大小为1的情况', () => {
+      expect(chunk([1, 2, 3, 4, 5], 1)).toEqual([[1], [2], [3], [4], [5]]);
+    });
+  });
+});