对象数组去重

      const s1 = Symbol();
      const s2 = Symbol();
      const arr = [
        { a: 1, b: 2, [s1]: 1 },
        { a: 1, b: 2 },
        { a: 1, b: 3 },
        { b: 1, a: 2 },
        { b: 2, a: 1, [s1]: 1 },
      ];
      // 判断两个值是否相等
      function isEqual(val1, val2) {
        if (!isObject(val1) && !isObject(val2)) return val1 === val2;
        if (!isSameType(val1, val2)) return false;
        let val1keys = [
          ...Object.keys(val1),
          ...Object.getOwnPropertySymbols(val1),
        ];
        let val2Keys = [
          ...Object.keys(val2),
          ...Object.getOwnPropertySymbols(val2),
        ];
        if (val1keys.length !== val2Keys.length) return false;
        for (const key of val1keys) {
          if (!val2Keys.includes(key)) return false;
          const res = isEqual(val1[key], val2[key]);
          if (!res) return false;
        }
        return true;
      }

      // 判断是否是对象
      function isObject(val) {
        return typeof val === "object" && val !== null;
      }

      // 判断是否是相同类型
      function isSameType(a, b) {
        return (
          Object.prototype.toString.call(a) ===
          Object.prototype.toString.call(b)
        );
      }
      // console.log(isEqual(arr[0], arr[4]));
      // console.log(isEqual([1, 2, 3], {0: 1, 1: 2, 2:3}));

      // 第一种, 根据某个键是否唯一
      const filterArrByParam = (arr, uniId = "a") => {
        let _arr = new Map();
        return arr.filter(
          (item) => !_arr.has(item[uniId]) && _arr.set(item[uniId], 1)
        );
      };

      // 对象数组去重 第二种
      function filterArr(arr) {
        const _arr = [...arr];
        for (let i = 0; i < _arr.length; i++) {
          for (let j = i + 1; j < _arr.length; j++) {
            if (isEqual(_arr[i], _arr[j])) {
              _arr.splice(j, 1);
              j--;
            }
          }
        }
        return _arr;
      }

      console.log(filterArr(arr));