const arrLike = document.querySelectorAll('div') // NodeList（類(lèi)數(shù)組）
const realArr = Array.from(arrLike) // 轉(zhuǎn)換為真正的數(shù)組

const arrLike = document.querySelectorAll('div')
const realArr = [...arrLike]

// 示例1：轉(zhuǎn)換arguments（函數(shù)內(nèi)部的類(lèi)數(shù)組）
function fn() {
  const realArr = Array.prototype.slice.call(arguments)
  console.log(realArr) // 數(shù)組形式的參數(shù)列表
}
fn(1, 2, 3)
// 示例2：轉(zhuǎn)換NodeList
const arrLike = document.querySelectorAll('div')
const realArr = Array.prototype.slice.call(arrLike)

// 接收一個(gè)數(shù)組，返回一個(gè)代理后的新數(shù)組
const proxyArray = arr => {
  // 保存【數(shù)組原始長(zhǎng)度】（重點(diǎn)：固定不變！避免數(shù)組長(zhǎng)度變化導(dǎo)致負(fù)索引計(jì)算錯(cuò)誤）
  const originLength = arr.length;
  // 返回 Proxy 代理對(duì)象，攔截?cái)?shù)組的屬性讀取操作
  return new Proxy(arr, {
    // 攔截所有【讀取屬性/索引】操作（如arr[0]、arr[-1]、arr.length）
    get(target, key) {
      // 判斷：訪問(wèn)的 key 是不是【數(shù)字索引】（1、'2'、-3 都算）
      const isNumberKey = 
        (typeof key === 'number') ||  // 數(shù)字類(lèi)型 key：arr[1]、arr[-1]
        (typeof key === 'string' && !isNaN(Number(key)));  // 字符串?dāng)?shù)字：arr['2']、arr['-3']
      // 如果是數(shù)字索引 → 處理負(fù)索引
      if (isNumberKey) {
        let index = Number(key); // 統(tǒng)一轉(zhuǎn)成數(shù)字，避免字符串索引的問(wèn)題
        // 核心邏輯：負(fù)索引轉(zhuǎn)正索引（循環(huán)處理，支持多重負(fù)索引如-2、-3）
        while (index < 0) {
          index += originLength;
        }
        // 返回處理后的索引對(duì)應(yīng)的值（超出范圍會(huì)返回undefined，和原生數(shù)組一致）
        return target[index];
      }
      // 不是索引（比如 length、push、pop 等數(shù)組方法），正常返回，不影響原生功能
      return target[key];
    }
  });
};

const arr = [10, 20, 30, 40];
const proxyArr = proxyArray(arr);
console.log(proxyArr[-1]); // 40（最后一項(xiàng)）
console.log(proxyArr[-2]); // 30（倒數(shù)第二項(xiàng)）
console.log(proxyArr[0]);  // 10（正常索引）
console.log(proxyArr.length); // 4（原生屬性正常訪問(wèn)）
proxyArr.push(50); // 正常執(zhí)行，數(shù)組變成[10,20,30,40,50]
console.log(proxyArr[-1]); // 50（注意：originLength是原始長(zhǎng)度4，這里為什么是50？）

// 包含空值、null、undefined、對(duì)象嵌套、空字符串，覆蓋常見(jiàn)邊界場(chǎng)景
const arr = [1, , [2, [3, [{ a: [4] }, 5, ["", null, undefined]]]], 6];

const flat1 = arr.flat(Infinity);
console.log(flat1); // [1, 2, 3, {a: [4]}, 5, "", null, undefined, 6]

const flat2 = arr.toString().split(',').map(Number);
console.log(flat2); // [1, NaN, 2, 3, NaN, 5, 0, NaN, NaN, 6]

// 接收數(shù)組和扁平化層級(jí)（默認(rèn)無(wú)限層級(jí)）
function eachFlat(arr, depth = Infinity) {
  const res = []; // 存儲(chǔ)最終的扁平化數(shù)組
  arr.forEach(item => {
    // 判斷：當(dāng)前項(xiàng)是數(shù)組，且層級(jí)未耗盡 → 遞歸扁平化，層級(jí)-1
    if (Array.isArray(item) && depth > 0) {
      res.push(...eachFlat(item, depth - 1)); // 展開(kāi)遞歸結(jié)果，存入res
    } else {
      // 非數(shù)組項(xiàng)，直接存入res（保留原類(lèi)型，不過(guò)濾空項(xiàng)）
      res.push(item);
    }
  });
  return res;
}
const flat3 = eachFlat(arr);
console.log(flat3); // [1, undefined, 2, 3, {a: [4]}, 5, "", null, undefined, 6]

function reduceFlat(arr, depth = Infinity) {
  // reduce接收兩個(gè)參數(shù)：回調(diào)函數(shù)和初始值（空數(shù)組）
  return arr.reduce((acc, val) => 
    // 回調(diào)邏輯：如果當(dāng)前項(xiàng)是數(shù)組且層級(jí)未耗盡，遞歸處理后合并；否則直接加入acc
    acc.concat(Array.isArray(val) && depth > 0 ? reduceFlat(val, depth - 1) : val), []);
}
const flat4 = reduceFlat(arr);
console.log(flat4); // 和forEach遞歸結(jié)果一致

function stackFlat(arr) {
  const res = []; // 最終結(jié)果數(shù)組
  const stack = [...arr]; // 用棧存儲(chǔ)待處理的元素，初始存入原數(shù)組的所有項(xiàng)
  // 循環(huán)：棧不為空就繼續(xù)處理
  while (stack.length) {
    const item = stack.pop(); // 從棧尾取出一個(gè)元素（后進(jìn)先出）
    // 如果是數(shù)組，就把它的所有項(xiàng)壓入棧（展開(kāi)后壓入，相當(dāng)于扁平化一層）
    Array.isArray(item) ? stack.push(...item) : res.unshift(item); // 非數(shù)組項(xiàng)，加入res的開(kāi)頭
  }
  return res;
}
const flat5 = stackFlat(arr);
console.log(flat5); // 和遞歸方案結(jié)果一致

const recursiveMax = (arr) => {
  // 邊界條件：如果傳入的不是數(shù)組，深度為0（遞歸終止條件）
  if (!Array.isArray(arr)) {
    return 0;
  }
  // 初始值：當(dāng)前數(shù)組本身的層級(jí)是1（即使是空數(shù)組，深度也是1）
  let maxDepth = 1;
  // 遍歷數(shù)組的每一項(xiàng)，遞歸計(jì)算子數(shù)組的深度
  for (let i = 0; i < arr.length; i++) {
    // 如果當(dāng)前項(xiàng)是數(shù)組，遞歸計(jì)算它的深度，再加上當(dāng)前層級(jí)1（因?yàn)樗钱?dāng)前數(shù)組的子項(xiàng)）
    if (Array.isArray(arr[i])) {
      let depth = 1 + recursiveMax(arr[i]);
      // 保留最大的深度（對(duì)比當(dāng)前maxDepth和子數(shù)組的深度，取較大值）
      maxDepth = Math.max(maxDepth, depth);
    }
  }
  return maxDepth;
}

console.log(recursiveMax([1, [2, [3]]])); // 3（最外層1層，中間2層，最里3層）
console.log(recursiveMax([1, 2, 3])); // 1（無(wú)嵌套）
console.log(recursiveMax([[[]], [1, [2]]])); // 3（最里層的空數(shù)組是3層）
console.log(recursiveMax(123)); // 0（不是數(shù)組）

function unique(arr) {
  const result = []; // 存儲(chǔ)去重后的數(shù)組
  for (let i = 0; i < arr.length; i++) {
    // indexOf返回-1，表示當(dāng)前元素不在result中（未重復(fù)）
    if (result.indexOf(arr[i]) === -1) {
      result.push(arr[i]); // 未重復(fù)則加入result
    }
  }
  return result;
}

console.log(unique([1, 2, 2, 3, 3, 3])); // [1,2,3]
console.log(unique([1, '1', 2, 2])); // [1, '1', 2]（區(qū)分?jǐn)?shù)字和字符串）
console.log(unique([null, null, undefined, undefined])); // [null, undefined]

// 方案1：Set去重（ES6+，最簡(jiǎn)潔，時(shí)間復(fù)雜度O(n)）
function uniqueSet(arr) {
  return [...new Set(arr)]; // Set自動(dòng)去重，再轉(zhuǎn)成數(shù)組
}
// 方案2：對(duì)象鍵值對(duì)去重（兼容ES5，時(shí)間復(fù)雜度O(n)）
function uniqueObj(arr) {
  const obj = {};
  const result = [];
  arr.forEach(item => {
    if (!obj[item]) { // 利用對(duì)象鍵名唯一的特性
      obj[item] = true;
      result.push(item);
    }
  });
  return result;
}

/**
 * 扁平數(shù)組 轉(zhuǎn) 樹(shù)形結(jié)構(gòu)
 * @param {Array} arr - 扁平數(shù)組（每一項(xiàng)必須包含id和parentId）
 * @param {number} rootValue - 根節(jié)點(diǎn)的 parentId 值，默認(rèn) 0（通常根節(jié)點(diǎn)parentId為0或null）
 * @returns {Array} 樹(shù)形結(jié)構(gòu)數(shù)組（根節(jié)點(diǎn)數(shù)組，每個(gè)節(jié)點(diǎn)包含children屬性）
 */
function arrayToTree(arr, rootValue = 0) {
  // 1. 創(chuàng)建 ID 映射表，快速查找節(jié)點(diǎn)（核心優(yōu)化：避免嵌套循環(huán)，時(shí)間復(fù)雜度從O(n2)降至O(n)）
  const map = {};
  const tree = []; // 最終的樹(shù)形結(jié)構(gòu)數(shù)組
  // 第一步：先把所有節(jié)點(diǎn)存入map，并初始化children屬性（避免后續(xù)判斷children是否存在）
  arr.forEach(item => {
    // 深拷貝當(dāng)前節(jié)點(diǎn)（避免修改原始數(shù)組），并初始化children為空數(shù)組
    map[item.id] = { ...item, children: [] };
  });
  // 第二步：遍歷扁平數(shù)組，構(gòu)建父子關(guān)系
  arr.forEach(item => {
    const currentNode = map[item.id]; // 當(dāng)前節(jié)點(diǎn)（從map中快速獲取）
    const parentNode = map[item.parentId]; // 父節(jié)點(diǎn)（從map中快速獲?。?
    // 判斷：如果當(dāng)前節(jié)點(diǎn)是根節(jié)點(diǎn)（parentId === rootValue），直接加入tree
    if (item.parentId === rootValue) {
      tree.push(currentNode);
    } 
    // 否則：如果父節(jié)點(diǎn)存在，將當(dāng)前節(jié)點(diǎn)加入父節(jié)點(diǎn)的children
    else if (parentNode) {
      parentNode.children.push(currentNode);
    }
  });
  return tree;
}

const arr = [
  { id: 1, name: '節(jié)點(diǎn)1', parentId: 0 }, // 根節(jié)點(diǎn)（parentId=0）
  { id: 2, name: '節(jié)點(diǎn)2', parentId: 0 }, // 根節(jié)點(diǎn)（parentId=0）
  { id: 3, name: '節(jié)點(diǎn)1-1', parentId: 1 }, // 子節(jié)點(diǎn)（父節(jié)點(diǎn)id=1）
  { id: 4, name: '節(jié)點(diǎn)1-2', parentId: 1 }, // 子節(jié)點(diǎn)（父節(jié)點(diǎn)id=1）
  { id: 5, name: '節(jié)點(diǎn)1-1-1', parentId: 3 }, // 孫節(jié)點(diǎn)（父節(jié)點(diǎn)id=3）
];
const tree = arrayToTree(arr);
console.log(JSON.stringify(tree, null, 2)); // 格式化輸出，便于查看樹(shù)形結(jié)構(gòu)

[
  {
    "id": 1,
    "name": "節(jié)點(diǎn)1",
    "parentId": 0,
    "children": [
      {
        "id": 3,
        "name": "節(jié)點(diǎn)1-1",
        "parentId": 1,
        "children": [
          {
            "id": 5,
            "name": "節(jié)點(diǎn)1-1-1",
            "parentId": 3,
            "children": []
          }
        ]
      },
      {
        "id": 4,
        "name": "節(jié)點(diǎn)1-2",
        "parentId": 1,
        "children": []
      }
    ]
  },
  {
    "id": 2,
    "name": "節(jié)點(diǎn)2",
    "parentId": 0,
    "children": []
  }
]

const shallowCopy = function(obj) {
  // 邊界條件：如果不是對(duì)象（如數(shù)字、字符串、null），直接返回（值類(lèi)型無(wú)需拷貝）
  if (typeof obj !== "object" || obj === null) return obj;
  // 初始化新對(duì)象/數(shù)組：如果是數(shù)組，新建數(shù)組；否則新建對(duì)象
  let newObj = obj instanceof Array ? [] : {};
  // 遍歷原對(duì)象的自有屬性（不遍歷原型鏈上的屬性）
  for (let key in obj) {
    if (obj.hasOwnProperty(key)) {
      // 只復(fù)制頂層屬性，深層屬性仍為引用
      newObj[key] = obj[key];
    }
  }
  return newObj;
};

// （1）對(duì)象淺拷貝
const obj = { a: 1, b: { c: 2 } };
const copy1 = Object.assign({}, obj); // Object.assign：合并對(duì)象，實(shí)現(xiàn)淺拷貝
const copy2 = { ...obj }; // 擴(kuò)展運(yùn)算符：最簡(jiǎn)潔的對(duì)象淺拷貝方式
// （2）數(shù)組淺拷貝
const arr = [1, 2, [3, 4]];
const copy3 = arr.slice(); // slice：截取整個(gè)數(shù)組，返回新數(shù)組（淺拷貝）
const copy4 = [].concat(arr); // concat：合并數(shù)組，返回新數(shù)組（淺拷貝）

const obj = { a: 1, b: { c: 2 } };
const copy = { ...obj };
copy.a = 100; // 修改頂層屬性，原對(duì)象不受影響
console.log(obj.a); // 1（原對(duì)象不變）
copy.b.c = 200; // 修改深層屬性，原對(duì)象受影響
console.log(obj.b.c); // 200（原對(duì)象被修改）

function deepCopyJSON(obj) {
  return JSON.parse(JSON.stringify(obj));
}

function deepCopy(obj) {
  // 邊界條件：非對(duì)象（值類(lèi)型）直接返回
  if (typeof obj !== 'object' || obj === null) {
    return obj;
  }
  // 初始化新對(duì)象/數(shù)組
  const result = Array.isArray(obj) ? [] : {};
  // 遍歷自有屬性，遞歸拷貝每一項(xiàng)
  for (const key in obj) {
    if (obj.hasOwnProperty(key)) {
      // 遞歸拷貝深層屬性
      result[key] = deepCopy(obj[key]);
    }
  }
  return result;
}

function deepClone(obj, map = new WeakMap()) {
  // 邊界條件：非對(duì)象直接返回
  if (obj === null || typeof obj !== 'object') return obj;
  // 處理循環(huán)引用：如果map中已有當(dāng)前對(duì)象，直接返回緩存的對(duì)象（避免遞歸死循環(huán)）
  if (map.has(obj)) return map.get(obj);
  let result;
  // 特殊類(lèi)型處理：Date
  if (obj instanceof Date) result = new Date(obj);
  // 特殊類(lèi)型處理：RegExp（保留正則的source和flags）
  else if (obj instanceof RegExp) result = new RegExp(obj.source, obj.flags);
  // 特殊類(lèi)型處理：Map
  else if (obj instanceof Map) {
    result = new Map();
    map.set(obj, result); // 緩存當(dāng)前對(duì)象，避免循環(huán)引用
    obj.forEach((val, key) => result.set(key, deepClone(val, map))); // 遞歸拷貝Map的每一項(xiàng)
  }
  // 特殊類(lèi)型處理：Set
  else if (obj instanceof Set) {
    result = new Set();
    map.set(obj, result); // 緩存當(dāng)前對(duì)象
    obj.forEach(val => result.add(deepClone(val, map))); // 遞歸拷貝Set的每一項(xiàng)
  }
  // 普通對(duì)象/數(shù)組
  else {
    result = Array.isArray(obj) ? [] : {};
    map.set(obj, result); // 緩存當(dāng)前對(duì)象
    // 遍歷自有屬性，遞歸拷貝
    for (const key in obj) {
      if (obj.hasOwnProperty(key)) {
        result[key] = deepClone(obj[key], map);
      }
    }
  }
  return result;
}

const testObj = {
  a: 1,
  b: { c: 2 },
  d: [3, 4],
  func: () => console.log(1), // 函數(shù)
  date: new Date(), // Date類(lèi)型
  reg: /test/g, // RegExp類(lèi)型
  map: new Map([[1, 'a']]), // Map類(lèi)型
  set: new Set([1, 2, 3]) // Set類(lèi)型
};
testObj.self = testObj; // 循環(huán)引用（自身引用自身）
const copy1 = deepCopyJSON(testObj);   // 有丟失（函數(shù)、map、set丟失，date轉(zhuǎn)成字符串）
const copy2 = deepCopy(testObj);      // 基礎(chǔ)版（循環(huán)引用報(bào)錯(cuò)）
const copy3 = deepClone(testObj);     // 完美版（所有類(lèi)型都保留，循環(huán)引用正常）
console.log(copy3.func); // () => console.log(1)（函數(shù)保留）
console.log(copy3.date instanceof Date); // true（Date類(lèi)型保留）
console.log(copy3.reg.test('test')); // true（正則正常使用）
console.log(copy3.self === copy3); // true（循環(huán)引用正常）

// 對(duì)象扁平化：{a:{b:{c:1}}} → { "a.b.c": 1 }
const objectFlatten = (obj) => {
  const res = {}; // 存儲(chǔ)最終扁平化結(jié)果
  // 遞歸扁平化函數(shù)：item是當(dāng)前遍歷的對(duì)象，preKey是父級(jí)key（初始為空）
  function flat(item, preKey = "") {
    // 遍歷對(duì)象的所有[key, value]對(duì)（Object.entries能獲取自身可枚舉屬性）
    Object.entries(item).forEach(([key, val]) => {
      // 拼接新key：如果有父級(jí)key，就用“父級(jí).key”，否則直接用當(dāng)前key
      const newKey = preKey ? `${preKey}.${key}` : key;
      // 關(guān)鍵判斷：如果當(dāng)前value是對(duì)象（且不是數(shù)組），繼續(xù)遞歸；否則直接賦值
      // 注意：這里排除數(shù)組，是因?yàn)閿?shù)組扁平化有專門(mén)的方法，避免混淆
      if (val && typeof val === 'object' && !Array.isArray(val)) {
        flat(val, newKey); // 遞歸，把當(dāng)前newKey作為父級(jí)key傳入
      } else {
        res[newKey] = val; // 非對(duì)象/數(shù)組，直接存入結(jié)果
      }
    });
  }
  flat(obj); // 啟動(dòng)遞歸
  return res;
};

// 反扁平化（點(diǎn)分隔 key → 嵌套對(duì)象）
const unFlatten = (obj) => {
  const res = {}; // 最終還原的嵌套對(duì)象
  // 遍歷扁平化對(duì)象的所有[key, value]對(duì)
  for (const [key, value] of Object.entries(obj)) {
    const keys = key.split('.'); // 把key按“.”分割成數(shù)組，比如“a.b.c”→["a","b","c"]
    // reduce遍歷keys數(shù)組，逐層構(gòu)建嵌套對(duì)象
    // acc：累加器（當(dāng)前層級(jí)的對(duì)象），k：當(dāng)前key，index：當(dāng)前索引
    keys.reduce((acc, k, index) => {
      // 最后一個(gè)key：直接賦值value（最底層值）
      if (index === keys.length - 1) {
        acc[k] = value;
      } else {
        // 非最后一個(gè)key：如果當(dāng)前層級(jí)沒(méi)有這個(gè)key，就創(chuàng)建空對(duì)象，避免報(bào)錯(cuò)
        acc[k] = acc[k] || {};
      }
      // 返回當(dāng)前層級(jí)的對(duì)象，供下一次reduce使用
      return acc[k];
    }, res); // 初始累加器是res（最外層空對(duì)象）
  }
  return res;
};

const origin = { a: { b: { c: 1 }, d: 2 } };
const flat = objectFlatten(origin);
const nested = unFlatten(flat);
console.log('扁平化：', flat);       // { 'a.b.c': 1, 'a.d': 2 } ?
console.log('還原后：', nested);     // { a: { b: { c: 1 }, d: 2 } } ?

// 檢測(cè)對(duì)象是否存在循環(huán)引用（標(biāo)準(zhǔn)面試版）
function isCycleObject(obj) {
  // 關(guān)鍵：用WeakSet存儲(chǔ)已遍歷過(guò)的對(duì)象，避免內(nèi)存泄漏
  // WeakSet的特點(diǎn)：存儲(chǔ)的是對(duì)象的弱引用，不會(huì)阻止垃圾回收，適合這種場(chǎng)景
  const seenObjects = new WeakSet();
  // 遞歸檢測(cè)函數(shù)
  function detect(target) {
    // 只檢查對(duì)象/數(shù)組（基礎(chǔ)類(lèi)型：數(shù)字、字符串等，不會(huì)有循環(huán)引用）
    if (target && typeof target === 'object') {
      // 如果當(dāng)前對(duì)象已經(jīng)在seenObjects中 → 存在循環(huán)引用
      if (seenObjects.has(target)) {
        return true;
      }
      // 標(biāo)記當(dāng)前對(duì)象為已訪問(wèn)，存入WeakSet
      seenObjects.add(target);
      // 遍歷當(dāng)前對(duì)象的所有自身屬性，遞歸檢測(cè)
      for (const key in target) {
        // 只遍歷自身屬性，避免遍歷原型鏈上的屬性（優(yōu)化性能）
        if (Object.prototype.hasOwnProperty.call(target, key)) {
          // 遞歸檢測(cè)當(dāng)前屬性的值，如果有循環(huán)引用，直接返回true
          if (detect(target[key])) {
            return true;
          }
        }
      }
    }
    // 基礎(chǔ)類(lèi)型、null，或者沒(méi)有循環(huán)引用，返回false
    return false;
  }
  return detect(obj);
}

const obj1 = {};
const obj2 = {};
obj1.someProp = obj2;
obj2.someProp = obj1; // 循環(huán)引用
const normalObj = { a: 1, b: { c: 2 } }; // 無(wú)循環(huán)
console.log(isCycleObject(obj1));    // true ?（有循環(huán)引用）
console.log(isCycleObject(normalObj)); // false ?（無(wú)循環(huán)引用）

// 判斷是否為對(duì)象（排除 null 和基礎(chǔ)類(lèi)型）
function isObject(value) {
  return typeof value === 'object' && value !== null;
}
// 判斷是否為數(shù)組
function isArray(value) {
  return Object.prototype.toString.call(value) === '[object Array]';
}
/**
 * 深度合并對(duì)象 / 數(shù)組
 * @param {any} target - 目標(biāo)數(shù)據(jù)（被覆蓋的對(duì)象）
 * @param {any} source - 源數(shù)據(jù)（覆蓋目標(biāo)的對(duì)象）
 * @returns {any} 合并后的新數(shù)據(jù)
 */
function merge(target, source) {
  // 邊界處理：如果target或source不是對(duì)象，直接返回source（source優(yōu)先）
  // 比如 target是1，source是2 → 返回2；source是undefined，返回target
  if (!isObject(target) || !isObject(source)) {
    return source !== undefined ? source : target;
  }
  // 初始化結(jié)果：如果source是數(shù)組，結(jié)果就是數(shù)組；否則是對(duì)象（和source類(lèi)型一致）
  const result = isArray(source) ? [] : {};
  // 第一步：復(fù)制target的內(nèi)容到result（保留target的原有屬性）
  if (isArray(result)) {
    // 結(jié)果是數(shù)組 → 復(fù)制target的數(shù)組元素（如果target也是數(shù)組）
    if (isArray(target)) {
      target.forEach((item, i) => {
        result[i] = item;
      });
    }
  } else {
    // 結(jié)果是對(duì)象 → 復(fù)制target的自身屬性
    for (const key in target) {
      if (target.hasOwnProperty(key)) {
        result[key] = target[key];
      }
    }
  }
  // 第二步：合并source的內(nèi)容到result（覆蓋target的同名屬性，嵌套對(duì)象遞歸合并）
  if (isArray(source)) {
    // source是數(shù)組 → 遍歷數(shù)組元素，遞歸合并
    source.forEach((item, i) => {
      result[i] = merge(result[i], item);
    });
  } else {
    // source是對(duì)象 → 遍歷自身屬性，遞歸合并
    for (const key in source) {
      if (source.hasOwnProperty(key)) {
        result[key] = merge(result[key], source[key]);
      }
    }
  }
  return result;
}

const object = { a: [{ b: 2 }, { d: 4 }] };
const other = { a: [{ c: 3 }, { e: 5 }] };
console.log(merge(object, other));
// 輸出：{ a: [ { b: 2, c: 3 }, { d: 4, e: 5 } ] } ?（嵌套數(shù)組合并成功）

const deepEqual = (a, b) => {
  // 1. 引用完全相同 → 直接相等（比如 a和b指向同一個(gè)對(duì)象）
  if (a === b) return true;
  // 2. 類(lèi)型不同 → 不相等（比如 a是對(duì)象，b是數(shù)組；a是數(shù)字，b是字符串）
  if (typeof a !== typeof b) return false;
  // 3. 處理 null（null的typeof是object，單獨(dú)判斷）
  if (a === null || b === null) return a === b;
  // 4. 專門(mén)處理：兩個(gè)都是 NaN 的情況（NaN === NaN 是 false，需要單獨(dú)判斷）
  const type = typeof a;
  if (type !== 'object' && type !== 'function') {
    // 基礎(chǔ)類(lèi)型（數(shù)字、字符串、布爾值），處理 NaN 特殊情況
    return Number.isNaN(a) && Number.isNaN(b);
  }
  // 5. 日期 / 正則 特殊判斷（它們的結(jié)構(gòu)相同，值也相同，才算是相等）
  const tagA = Object.prototype.toString.call(a);
  const tagB = Object.prototype.toString.call(b);
  if (tagA !== tagB) return false; // 標(biāo)簽不同，直接不相等（比如 Date 和 RegExp）
  if (tagA === '[object Date]') {
    // 日期：判斷時(shí)間戳是否相同（getTime()返回毫秒數(shù)）
    return a.getTime() === b.getTime();
  }
  if (tagA === '[object RegExp]') {
    // 正則：判斷正則表達(dá)式的源文本（source）和標(biāo)志（flags）是否相同
    return a.source === b.source && a.flags === b.flags;
  }
  // 6. 獲取所有鍵（包含 Symbol 類(lèi)型的鍵，避免遺漏）
  const keysA = Reflect.ownKeys(a);
  const keysB = Reflect.ownKeys(b);
  if (keysA.length !== keysB.length) return false; // 鍵的數(shù)量不同，直接不相等
  // 7. 遞歸比較每個(gè)鍵的值（確保所有層級(jí)的結(jié)構(gòu)和值都相同）
  for (const key of keysA) {
    if (!deepEqual(a[key], b[key])) {
      return false;
    }
  }
  // 所有條件都滿足 → 完全相等
  return true;
};

const objA = { a: 1, b: { c: 2 }, d: new Date(2024), e: /abc/g };
const objB = { a: 1, b: { c: 2 }, d: new Date(2024), e: /abc/g };
const objC = { a: 1, b: { c: 3 } };
console.log(deepEqual(objA, objB)); // true ?（結(jié)構(gòu)和值完全相同）
console.log(deepEqual(objA, objC)); // false ?（b.c的值不同）
console.log(deepEqual(NaN, NaN)); // true ?（特殊處理NaN）

// 手寫(xiě)實(shí)現(xiàn) Object.assign（淺拷貝、合并對(duì)象）
Object.assign2 = function(target, ...sources) {
  // 1. 邊界處理：target 是 null / undefined → 直接報(bào)錯(cuò)（和原生Object.assign一致）
  if (target == null) {
    throw new TypeError('Cannot convert undefined or null to object');
  }
  // 2. 把 target 包裝成對(duì)象（處理 target 是數(shù)字、字符串、布爾值的情況）
  // 比如 target是1 → 包裝成 Number {1}；target是"abc" → 包裝成 String {"abc"}
  const ret = Object(target);
  // 3. 遍歷所有源對(duì)象（sources是剩余參數(shù)，可能有多個(gè)源對(duì)象）
  sources.forEach(obj => {
    if (obj != null) { // 跳過(guò) null/undefined（原生Object.assign也會(huì)跳過(guò)）
      // 4. 遍歷源對(duì)象自身可枚舉屬性（不遍歷原型鏈）
      for (const key in obj) {
        if (obj.hasOwnProperty(key)) {
          ret[key] = obj[key]; // 覆蓋賦值（源對(duì)象屬性覆蓋目標(biāo)對(duì)象同名屬性）
        }
      }
    }
  });
  return ret;
};

const target = { a: 1, b: { c: 2 } };
const source1 = { b: { d: 3 }, e: 4 };
const source2 = null;
const result = Object.assign2(target, source1, source2);
console.log(result); // { a: 1, b: { d: 3 }, e: 4 } ?
console.log(result.b === source1.b); // true ?（淺拷貝，引用相同）

// 下劃線轉(zhuǎn)駝峰
function snakeToCamel(str) {
  // 正則匹配：_ + 小寫(xiě)字母（比如 _n）
  // 替換邏輯：把匹配到的內(nèi)容，替換成對(duì)應(yīng)的大寫(xiě)字母（n → N）
  return str.replace(/_([a-z])/g, (match, letter) => letter.toUpperCase());
}

// 駝峰轉(zhuǎn)下劃線
function camelToSnake(str) {
  // 正則匹配：大寫(xiě)字母（比如 N）
  // 替換邏輯：把匹配到的大寫(xiě)字母，替換成 _ + 對(duì)應(yīng)的小寫(xiě)字母（N → _n）
  return str.replace(/[A-Z]/g, (match) => "_" + match.toLowerCase());
}

console.log(snakeToCamel("user_name")); // userName ?
console.log(snakeToCamel("user_age_18")); // userAge18 ?
console.log(camelToSnake("userName")); // user_name ?
console.log(camelToSnake("userAge18")); // user_age_18 ?

/**
 * 接口請(qǐng)求緩存工具（重復(fù)請(qǐng)求合并 + 緩存）
 * 功能：同一請(qǐng)求同時(shí)多次調(diào)用，只發(fā)一次；已成功的請(qǐng)求直接讀緩存
 */
class CacheRequest {
  constructor() {
    // 緩存池：key = 請(qǐng)求唯一標(biāo)識(shí)，value = 緩存數(shù)據(jù) / 請(qǐng)求Promise
    // 用Map存儲(chǔ)，支持快速查找和刪除
    this.cache = new Map();
  }
  // 生成唯一緩存 KEY（根據(jù) url + 請(qǐng)求方式 + 參數(shù) + 請(qǐng)求體，確保唯一）
  getCacheKey(url, options = {}) {
    const { method = 'GET', body = null } = options;
    // 處理 params / body 保證唯一：把對(duì)象轉(zhuǎn)成字符串，避免因?qū)ο笠貌煌瑢?dǎo)致key不同
    return [
      url,
      method.toUpperCase(), // 統(tǒng)一轉(zhuǎn)大寫(xiě)，避免 GET 和 get 視為不同請(qǐng)求
      JSON.stringify(options.params || {}), // params參數(shù)（GET請(qǐng)求常用）
      body ? JSON.stringify(body) : '' // body參數(shù)（POST請(qǐng)求常用）
    ].join('&'); // 用&連接，生成唯一key
  }
  // 核心請(qǐng)求方法（自動(dòng)緩存 + 合并請(qǐng)求）
  request(url, options = {}) {
    const key = this.getCacheKey(url, options);
    // 1. 緩存存在 → 直接返回（分兩種狀態(tài)：pending / success）
    if (this.cache.has(key)) {
      const cached = this.cache.get(key);
      // 狀態(tài)1：請(qǐng)求還在等待中（pending）→ 直接返回同一個(gè)Promise（實(shí)現(xiàn)請(qǐng)求合并）
      // 比如同時(shí)調(diào)用兩次request('/api/user')，第一次發(fā)請(qǐng)求，第二次直接返回同一個(gè)Promise
      if (cached.status === 'pending') {
        return cached.promise;
      }
      // 狀態(tài)2：請(qǐng)求已成功（success）→ 直接返回緩存數(shù)據(jù)（無(wú)需再次請(qǐng)求）
      return Promise.resolve(cached.data);
    }
    // 2. 緩存不存在 → 發(fā)送新請(qǐng)求
    const fetchPromise = fetch(url, options)
      .then(res => {
        // 處理HTTP錯(cuò)誤（比如404、500），拋出錯(cuò)誤，進(jìn)入catch
        if (!res.ok) throw new Error('請(qǐng)求失敗：' + res.status);
        return res.json(); // 解析響應(yīng)數(shù)據(jù)（根據(jù)接口返回格式調(diào)整，比如res.text()）
      })
      .then(data => {
        // 請(qǐng)求成功 → 更新緩存為success狀態(tài)，存儲(chǔ)數(shù)據(jù)
        this.cache.set(key, { status: 'success', data });
        return data; // 返回?cái)?shù)據(jù)，供外部使用
      })
      .catch(err => {
        // 請(qǐng)求失敗 → 刪除緩存（下次調(diào)用會(huì)重新請(qǐng)求，避免緩存錯(cuò)誤數(shù)據(jù)）
        this.cache.delete(key);
        throw err; // 拋出錯(cuò)誤，供外部捕獲處理
      });
    // 先把請(qǐng)求存入緩存，標(biāo)記為pending（正在請(qǐng)求），避免重復(fù)請(qǐng)求
    this.cache.set(key, { status: 'pending', promise: fetchPromise });
    return fetchPromise;
  }
  // 清空緩存（可指定url / 全部清空，靈活實(shí)用）
  clearCache(url) {
    if (!url) {
      this.cache.clear(); // 無(wú)url參數(shù) → 清空所有緩存
      return;
    }
    // 有url參數(shù) → 清空所有以該url開(kāi)頭的緩存（比如清空/api/user相關(guān)的所有請(qǐng)求緩存）
    for (const key of this.cache.keys()) {
      if (key.startsWith(url)) this.cache.delete(key);
    }
  }
}

// 實(shí)例化緩存工具
const cacheRequest = new CacheRequest();
// 第一次請(qǐng)求：無(wú)緩存，發(fā)送請(qǐng)求
cacheRequest.request('/api/user', { method: 'GET', params: { id: 1 } })
  .then(data => console.log('第一次請(qǐng)求：', data));
// 第二次請(qǐng)求：同一請(qǐng)求，緩存處于pending狀態(tài)，合并請(qǐng)求（不重復(fù)發(fā)請(qǐng)求）
cacheRequest.request('/api/user', { method: 'GET', params: { id: 1 } })
  .then(data => console.log('第二次請(qǐng)求（合并）：', data));
// 一段時(shí)間后，第三次請(qǐng)求：緩存已存在，直接讀緩存
setTimeout(() => {
  cacheRequest.request('/api/user', { method: 'GET', params: { id: 1 } })
    .then(data => console.log('第三次請(qǐng)求（讀緩存）：', data));
}, 1000);
// 清空/api/user相關(guān)的所有緩存
cacheRequest.clearCache('/api/user');