feat(DOC): 完整地审查了代码，更完整的注释说明

- 无代码修改

utils/data.ts

@@ -3,6 +3,23 @@
  * @param func 要节流的函数
  * @param wait 等待时间（毫秒）
  * @param options 选项
+ * 
+ * 解释
+ * leading 表示首次调用时立即执行函数
+ * trailing: true 表示最后一次调用后等待 wait 毫秒后执行函数
+ * 
+ * 三种可能
+ * leading: true, trailing: true 表示首次调用时立即执行函数，最后一次调用后等待 wait 毫秒后补一次执行函数
+ * 第一次触发（remaining大于wait）->（if分支）立即执行
+ * 期间再次触发（remaining小于等于wait）->（else if分支）触发定时器，到时间补一次
+ * 
+ * leading: true, trailing: false 表示首次调用时立即执行函数，最后一次调用后不等待 wait 毫秒执行函数
+ * 第一次触发（remaining大于wait）->（if分支）立即执行
+ * 期间再次触发（remaining小于等于wait）->不管
+ * 
+ * leading: false, trailing: true 表示首次调用时不立即执行函数，最后一次调用后等待 wait 毫秒后执行函数
+ * 第一次触发（remaining等于wait）->（else if分支）触发定时器，到时间执行函数
+ * 期间再次触发->（else if分支）不断重置定时器，但remaining会不断减少
  */
 export function throttle<T extends (...args: unknown[]) => unknown>(
   func: T,
@@ -53,6 +70,7 @@ export const deepClone = <T>(obj: T): T => {
     return new Date(obj.getTime()) as unknown as T;
   }
 
+  // 上面是边界情况判断，下面才是真的深拷贝逻辑
   // 处理数组
   if (Array.isArray(obj)) {
     return obj.map(item => deepClone(item)) as unknown as T;
@@ -61,7 +79,9 @@ export const deepClone = <T>(obj: T): T => {
   // 处理普通对象
   const clonedObj = {} as T;
   for (const key in obj) {
+    // 最安全的一集
     if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      // 递归
       clonedObj[key] = deepClone(obj[key]);
     }
   }
@@ -88,6 +108,7 @@ export function deepEqual(a: unknown, b: unknown): boolean {
   if (keysA.length !== keysB.length) return false;
 
   for (const key of keysA) {
+    // 递归，上面比值，下面先确认键一不一样
     if (!keysB.includes(key) || !deepEqual((a as Record<string, unknown>)[key], (b as Record<string, unknown>)[key])) {
       return false;
     }
@@ -101,6 +122,8 @@ export function deepEqual(a: unknown, b: unknown): boolean {
  * @param obj 源对象
  * @param keys 要选取的属性键数组
  * @returns 包含指定属性的新对象
+ * 对象或数组类型属性：拷贝引用
+ * 基本类型属性：直接赋值
  */
 export function pick<T extends Record<string, unknown>, K extends keyof T>(
   obj: T,
@@ -142,6 +165,7 @@ export function merge<T extends Record<string, unknown>>(...objects: Partial<T>[
 
   for (const obj of objects) {
     if (obj && typeof obj === 'object') {
+      // 浅拷贝
       Object.assign(result, obj);
     }
   }
@@ -150,7 +174,7 @@ export function merge<T extends Record<string, unknown>>(...objects: Partial<T>[
 }
 
 /**
- * 将对象转换为查询字符串
+ * 将对象转换为查询字符串（但是没用到）
  * @param obj 要转换的对象
  * @returns 查询字符串
  */
@@ -196,6 +220,7 @@ export const unique = <T, K = unknown>(
   keyFn?: (item: T) => K
 ): T[] => {
   if (!keyFn) {
+    // 只适用于简单数组（也是蛮神奇的语法）
     return [...new Set(array)];
   }
 
@@ -203,9 +228,11 @@ export const unique = <T, K = unknown>(
   return array.filter(item => {
     const key = keyFn(item);
     if (seen.has(key)) {
+      // 已存在，返回false过滤该元素
       return false;
     }
     seen.add(key);
+    // 返回true保留该元素
     return true;
   });
 };
@@ -213,7 +240,7 @@ export const unique = <T, K = unknown>(
 /**
  * 数组分组
  * @param array 要分组的数组
- * @param keyFn 分组键函数
+ * @param keyFn 分组键函数（箭头函数实现）
  * @returns 分组后的对象
  */
 export const groupBy = <T, K extends string | number | symbol>(
@@ -233,7 +260,7 @@ export const groupBy = <T, K extends string | number | symbol>(
 /**
  * 数组排序
  * @param array 要排序的数组
- * @param compareFn 比较函数
+ * @param compareFn 比较函数（箭头函数实现）
  * @returns 排序后的新数组
  */
 export const sortBy = <T>(
@@ -248,6 +275,18 @@ export const sortBy = <T>(
  * @param func 要防抖的函数
  * @param wait 等待时间（毫秒）
  * @param immediate 是否立即执行
+ * 
+ * 两种类型：
+ * 1. 立即执行：第一次触发立即执行，之后触发只重置等待时间
+ * 2. 非立即执行：触发后等待时间结束才执行，期间触发会重置等待时间
+ * 
+ * immediate=true 立即执行
+ * 第一次触发（callNow为true）->设定定时器（时间到了消除定时器），并立即执行
+ * 期间多次触发->不断重置定时器的等待时间
+ * 
+ * immediate=false 非立即执行
+ * 第一次触发（callNow为false）->设定定时器（时间到了调用函数）
+ * 期间多次触发->不断重置定时器的等待时间
  */
 export function debounce<T extends (...args: unknown[]) => unknown>(
   func: T,