feat: 初始化

uni_modules/lime-shared/cloneDeep/vue.ts

@@ -0,0 +1,103 @@
+// @ts-nocheck
+/**
+ * 深度克隆一个对象或数组
+ * @param obj 要克隆的对象或数组
+ * @returns 克隆后的对象或数组
+ */
+export function cloneDeep<T>(obj: any): T {
+  // 如果传入的对象为空，返回空
+  if (obj === null) {
+    return null as unknown as T;
+  }
+
+  // 如果传入的对象是 Set 类型，则将其转换为数组，并通过新的 Set 构造函数创建一个新的 Set 对象
+  if (obj instanceof Set) {
+    return new Set([...obj]) as unknown as T;
+  }
+
+  // 如果传入的对象是 Map 类型，则将其转换为数组，并通过新的 Map 构造函数创建一个新的 Map 对象
+  if (obj instanceof Map) {
+    return new Map([...obj]) as unknown as T;
+  }
+
+  // 如果传入的对象是 WeakMap 类型，则直接用传入的 WeakMap 对象进行赋值
+  if (obj instanceof WeakMap) {
+    let weakMap = new WeakMap();
+    weakMap = obj;
+    return weakMap as unknown as T;
+  }
+
+  // 如果传入的对象是 WeakSet 类型，则直接用传入的 WeakSet 对象进行赋值
+  if (obj instanceof WeakSet) {
+    let weakSet = new WeakSet();
+    weakSet = obj;
+    return weakSet as unknown as T;
+  }
+
+  // 如果传入的对象是 RegExp 类型，则通过新的 RegExp 构造函数创建一个新的 RegExp 对象
+  if (obj instanceof RegExp) {
+    return new RegExp(obj) as unknown as T;
+  }
+
+  // 如果传入的对象是 undefined 类型，则返回 undefined
+  if (typeof obj === 'undefined') {
+    return undefined as unknown as T;
+  }
+
+  // 如果传入的对象是数组，则递归调用 cloneDeep 函数对数组中的每个元素进行克隆
+  if (Array.isArray(obj)) {
+    return obj.map(cloneDeep) as unknown as T;
+  }
+
+  // 如果传入的对象是 Date 类型，则通过新的 Date 构造函数创建一个新的 Date 对象
+  if (obj instanceof Date) {
+    return new Date(obj.getTime()) as unknown as T;
+  }
+
+  // 如果传入的对象是普通对象，则使用递归调用 cloneDeep 函数对对象的每个属性进行克隆
+  if (typeof obj === 'object') {
+    const newObj: any = {};
+    for (const [key, value] of Object.entries(obj)) {
+      newObj[key] = cloneDeep(value);
+    }
+    const symbolKeys = Object.getOwnPropertySymbols(obj);
+    for (const key of symbolKeys) {
+      newObj[key] = cloneDeep(obj[key]);
+    }
+    return newObj;
+  }
+
+  // 如果传入的对象是基本数据类型（如字符串、数字等），则直接返回
+  return obj;
+}
+
+// 示例使用
+
+// // 克隆一个对象
+// const obj = { name: 'John', age: 30 };
+// const clonedObj = cloneDeep(obj);
+
+// console.log(clonedObj); // 输出: { name: 'John', age: 30 }
+// console.log(clonedObj === obj); // 输出: false (副本与原对象是独立的)
+
+// // 克隆一个数组
+// const arr = [1, 2, 3];
+// const clonedArr = cloneDeep(arr);
+
+// console.log(clonedArr); // 输出: [1, 2, 3]
+// console.log(clonedArr === arr); // 输出: false (副本与原数组是独立的)
+
+// // 克隆一个包含嵌套对象的对象
+// const person = {
+//   name: 'Alice',
+//   age: 25,
+//   address: {
+//     city: 'New York',
+//     country: 'USA',
+//   },
+// };
+// const clonedPerson = cloneDeep(person);
+
+// console.log(clonedPerson); // 输出: { name: 'Alice', age: 25, address: { city: 'New York', country: 'USA' } }
+// console.log(clonedPerson === person); // 输出: false (副本与原对象是独立的)
+// console.log(clonedPerson.address === person.address); // 输出: false (嵌套对象的副本也是独立的)