function unique(arr) {
  const result = []
  for (const item of arr) {
    // 遍歷原數(shù)組，逐個(gè)取出元素判斷是否存在新數(shù)組，若新數(shù)組中不存在則添加
    if (!result.includes(item)) {
      result.push(item)
    }
  }
  return result
}

// 方法1：雙循環(huán)索引比較——i 與左側(cè)每個(gè) j 比對(duì)
function unique1(arr) {
  const result = []
  for (let i = 0, l = arr.length; i < l; i++) {
    for (let j = 0; j <= i; j++) {
      if (arr[i] === arr[j]) {
        // i === j 表示前面沒有相同值，當(dāng)前項(xiàng)是首次出現(xiàn)，追加到新數(shù)組中
        if (i === j) result.push(arr[i])
        // 只要遇到相同值，要么剛添加了，要么前面已添加，可跳出循環(huán)
        break
      }
    }
  }
  return result
}

// 方法2：新建數(shù)組 + includes 檢查
function unique2(arr) {
  const result = []
  for (const item of arr) {
    // 不存在新數(shù)組就添加，利用includes判斷
    if (!result.includes(item)) result.push(item)
  }
  return result
}

// 方法3：從后往前原地 splice
function unique3(arr) {
  let l = arr.length
  while (l-- > 0) {
    for (let i = 0; i < l; i++) {
      // 將當(dāng)前項(xiàng)逐個(gè)與前面項(xiàng)比較，若遇到重復(fù)就刪除當(dāng)前項(xiàng)，原數(shù)組操作
      if (arr[l] === arr[i]) {
        arr.splice(l, 1)
        break
      }
    }
  }
  return arr
}

// 方法4：從前往后原地 splice（刪后面相同項(xiàng)）
function unique4(arr) {
  let l = arr.length
  for (let i = 0; i < l; i++) {
    for (let j = i + 1; j < l; j++) {
      // 將當(dāng)前項(xiàng)逐個(gè)與后面項(xiàng)比較，若遇到重復(fù)就刪除重復(fù)項(xiàng)，原數(shù)組操作
      if (arr[i] === arr[j]) {
        arr.splice(j, 1)
        // 因?yàn)樽郧跋蚝蟊闅v，刪除重復(fù)項(xiàng)后，需要將下標(biāo)和總長度各自減1位
        j--; l--
      }
    }
  }
  return arr
}

// 方法5：forEach + indexOf
// indexOf 返回首次出現(xiàn)下標(biāo)，等于當(dāng)前下標(biāo)即首次
function unique5(arr) {
  const result = []
  arr.forEach((item, i) => {
    // 與unique1思路一致，利用indexOf實(shí)現(xiàn)查找
    if (arr.indexOf(item) === i) result.push(item)
  })
  return result
}

// 方法6：雙重 while 倒序 splice
// 與 unique3 同類：自尾向前，當(dāng)前尾元素若在前段出現(xiàn)過則刪掉該尾元素
function unique6(arr) {
  let l = arr.length
  while (l-- > 0) {
    let i = l
    while (i-- > 0) {
      // 與左側(cè)某項(xiàng)相等說明重復(fù)，刪掉當(dāng)前下標(biāo) l 的元素后跳出內(nèi)層
      if (arr[l] === arr[i]) {
        arr.splice(l, 1)
        break
      }
    }
  }
  return arr
}

// 方法7：filter + indexOf 一行經(jīng)典
// 寫法最短，但每次 indexOf 都是 O(n)
function unique7(arr) {
  // indexOf 得首次下標(biāo)，與當(dāng)前 i 相同才保留，否則是后面出現(xiàn)的重復(fù)項(xiàng)
  return arr.filter((item, i) => arr.indexOf(item) === i)
}

// 方法8：filter + Set 閉包——推薦寫法
// Set.add 返回 Set 自身，結(jié)合短路 && 返回布爾值
function unique8(arr) {
  const seen = new Set()
  // 未見過才執(zhí)行 add；add 恒為真值，整體表達(dá)式作 filter 謂詞
  return arr.filter(item => !seen.has(item) && seen.add(item))
}

// 方法9：reduce 累加（用數(shù)組）
// 函數(shù)式風(fēng)格，但 includes 仍是 O(n2)
function unique9(arr) {
  return arr.reduce((acc, item) => {
    // 與 unique2 同思路，只是用 reduce 折疊出結(jié)果數(shù)組
    if (!acc.includes(item)) acc.push(item)
    return acc
  }, [])
}

// 方法10：reduce + Set 閉包——O(n) 函數(shù)式
function unique10(arr) {
  const seen = new Set()
  return arr.reduce((acc, item) => {
    // Set 判重 O(1)，首次出現(xiàn)才同步記入 acc
    if (!seen.has(item)) {
      seen.add(item)
      acc.push(item)
    }
    return acc
  }, [])
}

// 方法11：Object + typeof 鍵
// 用 typeof + value 拼成字符串作為對(duì)象鍵，避免 1 與 '1' 沖突
function unique11(arr) {
  const obj = {}
  return arr.filter(item => {
    const key = typeof item + item
    // hasOwnProperty 防原型鏈上同名屬性；賦值表達(dá)式求值為 true，表示首次保留
    return Object.prototype.hasOwnProperty.call(obj, key)
      ? false
      : (obj[key] = true)
  })
}

// 方法12：new Set 轉(zhuǎn)數(shù)組——一行經(jīng)典
// Set 用 SameValueZero 比較，NaN 也能正確去重
function unique12(arr) {
  // 展開成數(shù)組，迭代順序與元素首次插入 Set 的順序一致（保序）
  return [...new Set(arr)]
}

// 方法13：Map.set + keys
// 適合"按鍵去重，值攜帶其他信息"的場景
function unique13(arr) {
  const map = new Map()
  // 鍵重復(fù)時(shí)覆蓋值，keys 迭代順序仍為各鍵首次插入順序
  arr.forEach(item => map.set(item, item))
  return [...map.keys()]
}

// 方法14：Object 字面量哈希
// 注意：1 與 '1' 會(huì)被合并；數(shù)字鍵會(huì)被引擎按升序重排
// [1, 'a', 2, 'b', -1] 會(huì)變成 [1, 2, 'a', 'b', -1]
function unique14(arr) {
  const obj = {}
  // 屬性名會(huì)轉(zhuǎn)成字符串，對(duì)象等引用類型鍵易撞成 '[object Object]'
  for (const item of arr) obj[item] = item
  return Object.values(obj)
}

// 方法15：sort + splice 升序去重
// 注意 sort 不傳比較函數(shù)會(huì)按字符串排序，數(shù)字?jǐn)?shù)組要傳 (a, b) => a - b
function unique15(arr) {
  arr.sort((a, b) => a - b)
  let l = arr.length
  while (l-- > 1) {
    // 排序后相等必相鄰，刪后一重復(fù)項(xiàng)；從后往前 splice 不影響已掃下標(biāo)
    if (arr[l] === arr[l - 1]) arr.splice(l, 1)
  }
  return arr
}

// 方法16：sort + filter 相鄰判重
function unique16(arr) {
  arr.sort((a, b) => a - b)
  // 首元素必留；之后僅當(dāng)與前一項(xiàng)不同才保留，即每段相同值只留第一個(gè)
  return arr.filter((item, i) => i === 0 || item !== arr[i - 1])
}

// 方法17：經(jīng)典雙指針（LeetCode 26）
// 排序后原地雙指針，O(1) 額外空間
function unique17(arr) {
  if (arr.length === 0) return arr
  arr.sort((a, b) => a - b)
  let slow = 0
  for (let fast = 1; fast < arr.length; fast++) {
    // fast 遇到新值則擴(kuò)展「唯一前綴」，寫入 slow+1 位置
    if (arr[fast] !== arr[slow]) arr[++slow] = arr[fast]
  }
  // 前綴長度為 slow+1，截掉尾部重復(fù)占位
  return arr.slice(0, slow + 1)
}

// 方法18：遞歸原地刪除
// 先看當(dāng)前「末尾」是否在前綴中出現(xiàn)過，重復(fù)則 splice 掉末尾
function unique18(arr, length) {
  if (length <= 1) return arr
  const last = length - 1
  for (let i = last - 1; i >= 0; i--) {
    // 與前段某項(xiàng)相同則末尾是重復(fù)，刪掉后不再比較
    if (arr[last] === arr[i]) {
      arr.splice(last, 1)
      break
    }
  }
  // 本層已處理原末尾，子問題規(guī)模減一（與是否 splice 無關(guān)）
  return unique18(arr, length - 1)
}

// 方法19：遞歸拼接返回（不修改原數(shù)組）
// 每層只決定「當(dāng)前末尾項(xiàng)」是否并入結(jié)果，前綴由遞歸算好
function unique19(arr, length) {
  if (length <= 1) return arr.slice(0, length)
  const last = length - 1
  const lastItem = arr[last]
  let isRepeat = false
  for (let i = last - 1; i >= 0; i--) {
    // 末尾值在前段出現(xiàn)過則本層不追加
    if (lastItem === arr[i]) {
      isRepeat = true
      break
    }
  }
  const head = unique19(arr, length - 1)
  // 非重復(fù)才把當(dāng)前末尾接到前綴結(jié)果后面
  return isRepeat ? head : head.concat(lastItem)
}

// 方法20：JSON 字符串判重——處理對(duì)象數(shù)組
// 把對(duì)象序列化成字符串作為 Set 的鍵，能去重 {id:1} 這類結(jié)構(gòu)
function unique20(arr) {
  const seen = new Set()
  const result = []
  for (const item of arr) {
    // 結(jié)構(gòu)一致則鍵一致（字段順序不同會(huì)得到不同鍵）
    const key = JSON.stringify(item)
    if (!seen.has(key)) {
      seen.add(key)
      result.push(item)
    }
  }
  return result
}

// 用法示例：
// unique20([{id: 1}, {id: 2}, {id: 1}])
// => [{id: 1}, {id: 2}]

// 保序、O(n)、寫法最短，工程首選
const result = [...new Set(arr)]

// 或函數(shù)式風(fēng)格，O(n)
const seen = new Set()
const result = arr.filter(x => !seen.has(x) && seen.add(x))

const result = [...new Map(arr.map(x => [x.id, x])).values()]

const seen = new Set()
const result = arr.filter(x => {
  const key = JSON.stringify(x)
  return !seen.has(key) && seen.add(key)
})

const result = [...new Set(arr)].sort((a, b) => a - b)

/**
 * 帶業(yè)務(wù)規(guī)則的去重。
 *
 * @param {Array} data 原數(shù)據(jù)
 * @param {Function} keyFn 從元素提取去重鍵
 * @param {Function} onDup 遇到重復(fù)時(shí)如何合并 (舊值, 新值) -> 新代表值
 */
function uniqueBy(data, keyFn, onDup) {
  // Map 保證遍歷順序與首次出現(xiàn)順序一致
  const chosen = new Map()
  for (const item of data) {
    const key = keyFn(item)
    if (!chosen.has(key)) {
      chosen.set(key, item)
    } else if (onDup) {
      chosen.set(key, onDup(chosen.get(key), item))
    }
  }
  return [...chosen.values()]
}

const students = [
  { id: 1, name: '張三', score: 90 },
  { id: 1, name: '張三', score: 95 },   // 同 id，分?jǐn)?shù)更高
  { id: 2, name: '李四', score: 85 },
]

const result = uniqueBy(
  students,
  x => x.id,
  (old, news) => news.score > old.score ? news : old,
)
// [{id:1, score:95, ...}, {id:2, score:85, ...}]

const counts = new Map()
for (const item of data) {
  counts.set(item, (counts.get(item) || 0) + 1)
}
// counts.keys() 是保序的去重結(jié)果
// [...counts.entries()] 是 [[元素, 次數(shù)], ...]

const seen = new Set()
const result = []
for (const x of data) {
  if (x >= 0 && x <= 100) {
    if (seen.has(x)) continue
    seen.add(x)
  }
  result.push(x)
}

// 用 Map 按 id 去重
const result = [...new Map(arr.map(x => [x.id, x])).values()]

// 拼成復(fù)合鍵
const result = [...new Map(arr.map(x => [`${x.id}|${x.type}`, x])).values()]

const seen = new Set()
const result = arr.filter(x => {
  const key = JSON.stringify(x)
  return !seen.has(key) && seen.add(key)
})
// 注意：字段順序不同的對(duì)象會(huì)被認(rèn)為不同