wzy-warehouse
262 lines
8.1 KiB
TypeScript
262 lines
8.1 KiB
TypeScript
/**
|
||
* 工具类集合
|
||
* 包含防抖等通用工具函数
|
||
*/
|
||
export const Utils = {
|
||
/**
|
||
* 防抖函数
|
||
* @param func - 需要防抖的函数
|
||
* @param delay - 延迟时间（毫秒），默认500ms
|
||
* @param immediate - 是否立即执行，默认false
|
||
* @returns 防抖处理后的函数
|
||
*/
|
||
debounce: function <This, T extends unknown[], R = void>(
|
||
func: (this: This, ...args: T) => R,
|
||
delay: number = 500,
|
||
immediate: boolean = false
|
||
) {
|
||
let timer: number | null = null;
|
||
|
||
// 用泛型This指定this类型
|
||
return function (this: This, ...args: T): void {
|
||
if (timer) clearTimeout(timer);
|
||
|
||
// 立即执行逻辑
|
||
if (immediate && !timer) {
|
||
func.apply(this, args);
|
||
}
|
||
|
||
// 重新设置定时器
|
||
timer = window.setTimeout(() => {
|
||
if (!immediate) {
|
||
func.apply(this, args);
|
||
}
|
||
timer = null;
|
||
}, delay);
|
||
};
|
||
},
|
||
|
||
/**
|
||
* 日期格式化函数
|
||
* @param format - 格式化字符串（支持YYYY、MM、DD、HH、mm、ss等）
|
||
* @param date - 日期对象，默认为当前时间
|
||
* @returns 格式化后的日期字符串
|
||
*/
|
||
formatDate: (format: string, date: Date = new Date()): string => {
|
||
// 基础时间数据
|
||
const year = date.getFullYear();
|
||
const month = date.getMonth() + 1; // 月份0-11，需+1
|
||
const day = date.getDate();
|
||
const hours24 = date.getHours();
|
||
const hours12 = hours24 % 12 || 12; // 12小时制处理（0→12）
|
||
const minutes = date.getMinutes();
|
||
const seconds = date.getSeconds();
|
||
const weekNum = date.getDay(); // 星期0-6（0=周日）
|
||
|
||
// 星期映射配置
|
||
const weekMaps = {
|
||
ddd: ['日', '一', '二', '三', '四', '五', '六'].map(
|
||
(day) => `星期${day}`
|
||
),
|
||
dd: ['日', '一', '二', '三', '四', '五', '六'].map((day) => `周${day}`),
|
||
d: [0, 1, 2, 3, 4, 5, 6],
|
||
};
|
||
|
||
// 占位符替换规则（顺序：长占位符优先，避免冲突）
|
||
const replaceRules = [
|
||
{ regex: /YYYY/g, value: year.toString() },
|
||
{ regex: /YY/g, value: year.toString().slice(-2) },
|
||
{ regex: /MM/g, value: month.toString().padStart(2, '0') },
|
||
{ regex: /M/g, value: month.toString() },
|
||
{ regex: /DD/g, value: day.toString().padStart(2, '0') },
|
||
{ regex: /D/g, value: day.toString() },
|
||
{ regex: /HH/g, value: hours24.toString().padStart(2, '0') },
|
||
{ regex: /H/g, value: hours24.toString() },
|
||
{ regex: /hh/g, value: hours12.toString().padStart(2, '0') },
|
||
{ regex: /h/g, value: hours12.toString() },
|
||
{ regex: /mm/g, value: minutes.toString().padStart(2, '0') },
|
||
{ regex: /m/g, value: minutes.toString() },
|
||
{ regex: /ss/g, value: seconds.toString().padStart(2, '0') },
|
||
{ regex: /s/g, value: seconds.toString() },
|
||
{ regex: /ddd/g, value: weekMaps.ddd[weekNum] },
|
||
{ regex: /dd/g, value: weekMaps.dd[weekNum] },
|
||
{ regex: /d/g, value: weekMaps.d[weekNum] },
|
||
];
|
||
|
||
// 执行替换
|
||
return replaceRules.reduce((result, { regex, value }) => {
|
||
return result.replace(regex, String(value ?? ''));
|
||
}, format);
|
||
},
|
||
|
||
/**
|
||
* 深拷贝函数
|
||
* 支持类型：原始类型、数组、对象、Date、RegExp、Map、Set、ArrayBuffer等
|
||
* @param source 要拷贝的数据源
|
||
* @param hash 用于解决循环引用的哈希表，内部使用
|
||
* @returns 深拷贝后的新数据
|
||
*/
|
||
deepClone: <T>(source: T, hash = new WeakMap<object, unknown>()): T => {
|
||
// 处理 null 或 undefined
|
||
if (source === null || source === undefined) {
|
||
return source;
|
||
}
|
||
|
||
// 处理原始类型（string, number, boolean, symbol, bigint, function）
|
||
if (typeof source !== 'object' && typeof source !== 'function') {
|
||
return source;
|
||
}
|
||
|
||
// 处理函数 - 直接返回原函数引用（通常不需要克隆函数）
|
||
if (typeof source === 'function') {
|
||
return source;
|
||
}
|
||
|
||
// 解决循环引用
|
||
if (hash.has(source)) {
|
||
return hash.get(source) as T;
|
||
}
|
||
|
||
// 处理 Date 对象
|
||
if (source instanceof Date) {
|
||
const cloned = new Date(source.getTime()) as T;
|
||
hash.set(source, cloned);
|
||
return cloned;
|
||
}
|
||
|
||
// 处理 RegExp 对象
|
||
if (source instanceof RegExp) {
|
||
const cloned = new RegExp(source.source, source.flags);
|
||
cloned.lastIndex = source.lastIndex; // 安全访问
|
||
return cloned as unknown as T;
|
||
}
|
||
// 处理 Map 对象
|
||
if (source instanceof Map) {
|
||
const cloned = new Map();
|
||
hash.set(source, cloned);
|
||
source.forEach((value, key) => {
|
||
cloned.set(Utils.deepClone(key, hash), Utils.deepClone(value, hash));
|
||
});
|
||
return cloned as T;
|
||
}
|
||
|
||
// 处理 Set 对象
|
||
if (source instanceof Set) {
|
||
const cloned = new Set<unknown>();
|
||
hash.set(source, cloned);
|
||
for (const value of source.values()) {
|
||
cloned.add(Utils.deepClone(value, hash));
|
||
}
|
||
return cloned as T;
|
||
}
|
||
|
||
// 处理 ArrayBuffer
|
||
if (source instanceof ArrayBuffer) {
|
||
const cloned = source.slice(0) as T;
|
||
hash.set(source, cloned);
|
||
return cloned;
|
||
}
|
||
|
||
// 处理数组
|
||
if (Array.isArray(source)) {
|
||
const cloned: T[] = [];
|
||
hash.set(source, cloned);
|
||
for (let i = 0; i < source.length; i++) {
|
||
cloned[i] = Utils.deepClone(source[i], hash);
|
||
}
|
||
return cloned as T;
|
||
}
|
||
|
||
// 处理普通对象
|
||
if (typeof source === 'object') {
|
||
// 处理 Error 对象
|
||
if (source instanceof Error) {
|
||
const cloned = new Error(source.message);
|
||
cloned.stack = source.stack;
|
||
cloned.name = source.name;
|
||
hash.set(source, cloned);
|
||
return cloned as T;
|
||
}
|
||
|
||
// 处理其他对象
|
||
const cloned: { [key: string | symbol]: unknown } = {};
|
||
hash.set(source, cloned);
|
||
|
||
// 获取对象的所有属性（包括不可枚举的属性和 Symbol）
|
||
const keys = [
|
||
...Object.getOwnPropertyNames(source),
|
||
...Object.getOwnPropertySymbols(source),
|
||
];
|
||
|
||
for (const key of keys) {
|
||
const descriptor = Object.getOwnPropertyDescriptor(source, key);
|
||
|
||
// 如果是访问器属性
|
||
if (descriptor && descriptor.get) {
|
||
Object.defineProperty(cloned, key, descriptor);
|
||
} else {
|
||
// 如果是数据属性
|
||
cloned[key] = Utils.deepClone(
|
||
(source as { [key: string | symbol]: unknown })[key],
|
||
hash
|
||
);
|
||
}
|
||
}
|
||
|
||
// 处理原型链
|
||
const proto = Object.getPrototypeOf(source);
|
||
if (proto && proto !== Object.prototype) {
|
||
Object.setPrototypeOf(cloned, proto);
|
||
}
|
||
|
||
return cloned as T;
|
||
}
|
||
|
||
// 对于其他无法处理的情况，返回原值
|
||
return source;
|
||
},
|
||
|
||
/**
|
||
* 调整元素位置，确保其不超出屏幕可视区域边界
|
||
* @param {number} offsetX - 元素左上角原 X 坐标（相对于视口）
|
||
* @param {number} offsetY - 元素左上角原 Y 坐标（相对于视口）
|
||
* @param {number} width - 元素的宽度
|
||
* @param {number} height - 元素的高度
|
||
* @returns {[number, number]} 调整后的 [newX, newY]
|
||
*/
|
||
keepWithinScreen: (
|
||
offsetX: number,
|
||
offsetY: number,
|
||
width: number,
|
||
height: number
|
||
) => {
|
||
const viewportW = window.innerWidth;
|
||
const viewportH = window.innerHeight;
|
||
|
||
// 计算允许的 X 范围：最小 0，最大 (视口宽度 - 元素宽度)
|
||
// 如果元素宽度大于视口宽度，允许范围为 [0, 0]（即只能左对齐）
|
||
const maxX = Math.max(0, viewportW - width);
|
||
const newX = Math.min(Math.max(offsetX, 0), maxX);
|
||
|
||
// 计算允许的 Y 范围
|
||
const maxY = Math.max(0, viewportH - height);
|
||
const newY = Math.min(Math.max(offsetY, 0), maxY);
|
||
|
||
return [newX, newY];
|
||
},
|
||
|
||
/**
|
||
* 将数组拆分为指定大小的子数组
|
||
* @param {T[]} arr - 要拆分的数组
|
||
* @param {number} [size=2] - 子数组的大小
|
||
* @returns {T[][]} 拆分后的子数组
|
||
*/
|
||
chunkArray: <T>(arr: T[], size: number = 2): T[][] => {
|
||
const result = [];
|
||
for (let i = 0; i < arr.length; i += size) {
|
||
result.push(arr.slice(i, i + size));
|
||
}
|
||
return result;
|
||
},
|
||
};
|