import $test from './test';
|
|
/**
|
* @description 去除空格
|
*/
|
export function trim(
|
str: string | number,
|
pos: 'both' | 'left' | 'right' | 'all' = 'both',
|
): string {
|
str = String(str);
|
if (pos == 'both') {
|
return str.replace(/^\s+|\s+$/g, '');
|
}
|
if (pos == 'left') {
|
return str.replace(/^\s*/, '');
|
}
|
if (pos == 'right') {
|
return str.replace(/(\s*$)/g, '');
|
}
|
if (pos == 'all') {
|
return str.replace(/\s+/g, '');
|
}
|
return str;
|
}
|
|
/**
|
* 内部递归克隆函数
|
* @param obj 要克隆的对象
|
* @param visited 已访问对象的映射，用于处理循环引用
|
*/
|
function cloneRecursive<T>(obj: T, visited: WeakMap<any, any>): T {
|
if (obj === null || obj === undefined) {
|
return obj;
|
}
|
|
if (typeof obj !== 'object') {
|
return obj;
|
}
|
|
// 检查循环引用
|
if (visited.has(obj as any)) {
|
return visited.get(obj as any);
|
}
|
|
let cloned: any;
|
|
if (obj instanceof Date) {
|
cloned = new Date(obj.getTime());
|
visited.set(obj as any, cloned);
|
} else if (obj instanceof RegExp) {
|
cloned = new RegExp(obj.source, obj.flags);
|
visited.set(obj as any, cloned);
|
} else if ($test.array(obj)) {
|
cloned = [];
|
visited.set(obj as any, cloned);
|
const arr = obj as any;
|
for (let i = 0; i < arr.length; i++) {
|
cloned[i] = cloneRecursive(arr[i], visited);
|
}
|
} else if ($test.object(obj)) {
|
cloned = {};
|
visited.set(obj as any, cloned);
|
for (const key in obj) {
|
if (Object.prototype.hasOwnProperty.call(obj, key)) {
|
cloned[key] = cloneRecursive((obj as any)[key], visited);
|
}
|
}
|
} else {
|
return obj;
|
}
|
|
return cloned as T;
|
}
|
|
/**
|
* @description 深度克隆对象
|
* @param {T} obj 需要深度克隆的值，可以是任何类型
|
* @returns {T} 克隆后的对象或者原值（原始类型）
|
*
|
* @example
|
* const original = { a: 1, b: { c: 2 }, d: [1, 2, 3] };
|
* const cloned = deepClone(original);
|
* cloned.b.c = 999;
|
* console.log(original.b.c); // 2 (原对象未被修改)
|
*
|
* @example
|
* // 处理循环引用
|
* const obj: any = { a: 1 };
|
* obj.self = obj;
|
* const cloned = deepClone(obj); // 不会无限递归
|
*/
|
export function deepClone<T>(obj: T): T {
|
return cloneRecursive(obj, new WeakMap());
|
}
|
|
/**
|
* @description JS对象深度合并
|
* @param {Record<string, any>} target 目标对象，默认为空对象
|
* @param {Record<string, any>} source 源对象，默认为空对象
|
* @returns {T | false} 合并后的对象，如果输入参数无效则返回 false
|
*
|
* @example
|
* const target = { a: 1, b: { c: 2 } };
|
* const source = { b: { d: 3 }, e: 4 };
|
* const result = deepMerge(target, source);
|
* // result: { a: 1, b: { c: 2, d: 3 }, e: 4 }
|
*
|
* @example
|
* // 数组合并
|
* const target = { arr: [1, 2] };
|
* const source = { arr: [3, 4] };
|
* const result = deepMerge(target, source);
|
* // result: { arr: [1, 2, 3, 4] }
|
*/
|
export function deepMerge<T extends Record<string, any>>(
|
target: Record<string, any> = {},
|
source: Record<string, any> = {},
|
): T | false {
|
// 检查输入参数的有效性，确保都是普通对象
|
if (!$test.object(target) || !$test.object(source)) {
|
return false;
|
}
|
|
// 深克隆目标对象，避免修改原对象
|
const result = deepClone(target);
|
|
// 遍历源对象的所有可枚举属性
|
for (const key in source) {
|
// 使用安全的属性检查方法
|
if (!Object.prototype.hasOwnProperty.call(source, key)) {
|
continue;
|
}
|
|
const sourceValue = source[key];
|
const targetValue = result[key];
|
|
// 如果源值和目标值都是数组，则合并数组
|
if ($test.array(sourceValue) && $test.array(targetValue)) {
|
result[key] = [...targetValue, ...sourceValue];
|
}
|
// 如果源值和目标值都是对象，则递归合并
|
else if ($test.object(sourceValue) && $test.object(targetValue)) {
|
const mergedValue = deepMerge(targetValue, sourceValue);
|
// 处理递归调用可能返回 false 的情况
|
if (mergedValue === false) {
|
result[key] = deepClone(sourceValue);
|
} else {
|
result[key] = mergedValue;
|
}
|
}
|
// 其他情况直接覆盖，并深克隆以避免引用问题
|
else {
|
result[key] = deepClone(sourceValue);
|
}
|
}
|
|
return result as T;
|
}
|
