第七题：数据排重

Question

第七题：数据排重

KieSun opened this issue 3 years ago · comments

给定一个任意数组，实现一个通用函数，让数组中的数据根据 key 排重：

const dedup = (data, getKey = () => {} ) => {
  // todo
}
let data = [
  { id: 1, v: 1 },
  { id: 2, v: 2 },
  { id: 1, v: 1 },
];

// 以 id 作为排重 key，执行函数得到结果
// data = [
//   { id: 1, v: 1 },
//   { id: 2, v: 2 },
// ];

let data1 = [
  { id: 1, v: 1, id1: 1 },
  { id: 2, v: 2, id1: 2 },
  { id: 1, v: 1, id1: 1 },
]

// 以 id 和 id1 作为排重 key，执行函数得到结果
// data1 = [
//   { id: 1, v: 1, id1: 1 },
//   { id: 2, v: 2, id1: 2 },
// ];

去答题

新建了一个大厂真题每日打卡群，有意愿学习打卡的再进，群已达扫码上线，请加好友拉你进群。

shellming · Answer 1 · Tue Mar 16 2021 11:08:42 GMT+0800 (China Standard Time)

        
const dedup = (data, getKey = () => { }) => {
    const dateMap = data.reduce((pre, cur) => {
        const key = getKey(cur)
        if (!pre[key]) {
            pre[key] = cur
        }
        return pre
    }, {})
    return Object.values(dateMap)
}


const dedup2 = (data, getKey = () => { }) => {
    const keys = data.map(getKey)
    return data.filter((e, index) => index === keys.lastIndexOf(keys[index]))
}

let data = [
    { id: 1, v: 1 },
    { id: 2, v: 2 },
    { id: 1, v: 1 },
];
console.log(dedup(data, (item) => item.id))

// 以 id 作为排重 key，执行函数得到结果
// data = [
//   { id: 1, v: 1 },
//   { id: 2, v: 2 },
// ];

let data1 = [
    { id: 1, v: 1, id1: 1 },
    { id: 2, v: 2, id1: 2 },
    { id: 1, v: 1, id1: 1 },
]
console.log(dedup(data, (item) => `${item.id}|${item.id1}`))

teefing · Answer 2 · Tue Mar 16 2021 11:19:27 GMT+0800 (China Standard Time)

const dedup = (data, getKey = () => {} ) => {
  let m = new Map()
  data.forEach(item => {
    let key = getKey(item)
    if(!Array.isArray(key)) key = [key]
    key = key.map(i => JSON.stringify(i)).join(',')
    if(!m.has(key)) m.set(key, item)
  })

  return [...m.values()]
}
let data = [
  { id: 1, v: 1 },
  { id: 2, v: 2 },
  { id: 1, v: 1 },
];

console.log(dedup(data, item => [item.v]))
// 以 id 作为排重 key，执行函数得到结果
// data = [
//   { id: 1, v: 1 },
//   { id: 2, v: 2 },
// ];

let data1 = [
  { id: 1, v: 1, id1: 1 },
  { id: 2, v: 2, id1: 2 },
  { id: 1, v: 1, id1: 1 },
]
console.log(dedup(data1, item => [item.id, item.id1]))
// 以 id 和 id1 作为排重 key，执行函数得到结果
// data1 = [
//   { id: 1, v: 1, id1: 1 },
//   { id: 2, v: 2, id1: 2 },
// ];

MR.Kevin · Answer 3 · Tue Mar 16 2021 11:34:09 GMT+0800 (China Standard Time)

const dedup = (data, getKey = () => {}) => {
  const map = new Map()
  data.forEach((item) => {
    const key = getKey(item)
    if (!map.has(key)) {
      map.set(key, item)
    }
  })
  let result = []
  for (let [, item] of map.entries()) {
    result.push(item)
  }
  console.log(result)
  return result
}

let data = [
  { id: 1, v: 1 },
  { id: 2, v: 2 },
  { id: 1, v: 2 },
]

dedup(data, (item) => item.id)

let data1 = [
  { id: 1, v: 1, id1: 1 },
  { id: 2, v: 2, id1: 2 },
  { id: 1, v: 2, id1: 1 },
]

dedup(data1, (item) => `${item.id}-${item.id1}`)

青云码上 · Answer 4 · Tue Mar 16 2021 11:39:18 GMT+0800 (China Standard Time)

const dedup = (data) => {
  let obj = {};
  let arr = [];
  data.forEach((item) => {
    obj[JSON.stringify(item)] = null;
  });
  Object.keys(obj).forEach(item => {
    arr.push(JSON.parse(item))
  });
  return arr;
};

let data1 = [
  { id: 1, value: 1, id2: 1 },
  { id: 1, value: 1, id2: 1 },
  { id: 2, value: 1, id2: 1 },
  { id: 2, value: 1, id2: 1 },
  { id: 1, value: 1, id2: 2 },
];
console.log(dedup(data1))

Javon Yan · Answer 5 · Tue Mar 16 2021 13:12:32 GMT+0800 (China Standard Time)

给定一个任意数组，实现一个通用函数，让数组中的数据根据 key 排重（去重）。

const dedup = (data, getKey = () => {} ) => {
    const result = []
    const map = new Map()
    data.forEach(item => {
        const key = getKey(item)
        if (!map.has(key)) {
            result.push(item)
            map.set(key, 1)
        }
    })
    return result
}

测试用例：

let data = [
  { id: 1, v: 1 },
  { id: 2, v: 2 },
  { id: 1, v: 1 },
];

// 以 id 作为排重 key，执行函数得到结果
// data = [
//   { id: 1, v: 1 },
//   { id: 2, v: 2 },
// ];

console.log(dedup(data, item => {return item.id}))

let data1 = [
  { id: 1, v: 1, id1: 1 },
  { id: 2, v: 2, id1: 2 },
  { id: 1, v: 1, id1: 1 },
]

// 以 id 和 id1 作为排重 key，执行函数得到结果
// data1 = [
//   { id: 1, v: 1, id1: 1 },
//   { id: 2, v: 2, id1: 2 },
// ];

console.log(dedup(data1, item => {return JSON.stringify({
    id: item.id,
    id1: item.id1
})}))

水美眉 · Answer 6 · Tue Mar 16 2021 13:36:21 GMT+0800 (China Standard Time)

基于lodash的uniqWith实现，实现了一个通用方法


let objects = [
  { x: 1, y: 2, z: 1 },
  { x: 2, y: 1, z: 2 },
  { x: 1, y: 2, z: 3 },
];

function uniqFn(array, keysList) {
  return _.uniqWith(array, function (arrVal, othVal) {
    return keysList.reduce((acc, cur, idx) => {
      return acc && arrVal[cur] === othVal[cur];
    }, true);
  });
}

uniqFn(objects, ["x", "y"]);
// [Object {x: 1, y: 2, z: 1}, Object {x: 2, y: 1, z: 2}]

liuy1994 · Answer 7 · Tue Mar 16 2021 13:39:12 GMT+0800 (China Standard Time)

// 给定一个任意数组，实现一个通用函数，让数组中的数据根据 key 排重：

const dedup = (data, getKey = () => {} ) => {
  let res = {}
  for (let i=0;i<data.length;i++) {
      const key = getKey(data[i])
    if (res[key] === undefined) {
        res[key] = data[i]
    }
  }
  return Object.values(res)
}
let data = [
  { id: 1, v: 1 },
  { id: 2, v: 2 },
  { id: 1, v: 1 },
];
// console.log(dedup(data, item => item.id))
// 以 id 作为排重 key，执行函数得到结果
// data = [
//   { id: 1, v: 1 },
//   { id: 2, v: 2 },
// ];

let data1 = [
  { id: 1, v: 1, id1: 1 },
  { id: 2, v: 2, id1: 2 },
  { id: 1, v: 1, id1: 1 },
]
console.log(dedup(data1, item => `${item.id}-----${item.id1}`))
// 以 id 和 id1 作为排重 key，执行函数得到结果
// data1 = [
//   { id: 1, v: 1, id1: 1 },
//   { id: 2, v: 2, id1: 2 },
// ];

雾灵 · Answer 8 · Tue Mar 16 2021 13:48:19 GMT+0800 (China Standard Time)

//将数组对象中的每一个对象转换成字符串，来判断是否重复
const dedup = (data, getKey = () => {} ) => {
let hc = []//缓存
let result= []
for (let i = 0; i < data.length; i++) {
    let str = JSON.stringify(data[i])
    if(hc.indexOf(str) === -1){
    hc.push(str)
    result.push(data[i])
    }
}
return result
}

Liang · Answer 9 · Tue Mar 16 2021 13:55:33 GMT+0800 (China Standard Time)

const dedup = (data, getKey = () => { }) => {
  // todo
  const map =  {}
  const result =  []
  data.forEach(item => {
    const key = getKey(item)
    if (!map[key]) {
      result.push(item)
      map[key] = true
    }
  })
  return result
}

yang-1234 · Answer 10 · Tue Mar 16 2021 14:32:00 GMT+0800 (China Standard Time)

  const getkey = (item) => {
        var keys = Object.values(item).toString();
        return keys
    }
    const dedup = (data, fn) => {
        let map = new Map()
        let curArr = []
        data.forEach((item, index) => {
            let keyStr = Object.keys(item).toString()
            let keyVals = Object.values(item)
            let arr = []
            if (map.has(keyStr)) {
                arr = map.get(keyStr)
                arr.push(item)
            } else {
                arr.push(item)
                map.set(keyStr, arr)
            }
        });
        let allArrs = []
        allArrs = [...map.values()];
        const resultArr = []
        for (var i = 0; i < allArrs.length; i++) {
            const map1 = new Map()
            allArrs[i].forEach((item, index) => {
                const key = fn(item)
                if (!map1.has(key)) {
                    resultArr.push(item)
                    map1.set(key, index)
                }
            })
        }
        return resultArr
    }
    var data = [
        { id: 1, id1: 3 },
        { id: 1, id1: 4 },
        { id: 1, id1: 4 },
        { id2: 1, id1: 3 }
    ];
    console.log(dedup(data, getkey))
    var data1 = [
        { id: 1, id1: 3, v: 1 },
        { id: 1, id1: 4 },
        { id: 1, id1: 4 },
        { id2: 1, id1: 3 },
        { id3: 1, id1: 5 },
        { id3: 1, id1: 5 }
    ];
    console.log(dedup(data1, getkey))

xxp9413 · Answer 11 · Tue Mar 16 2021 14:54:30 GMT+0800 (China Standard Time)

基于lodash的uniqWith实现，实现了一个通用方法


let objects = [
  { x: 1, y: 2, z: 1 },
  { x: 2, y: 1, z: 2 },
  { x: 1, y: 2, z: 3 },
];

function uniqFn(array, keysList) {
  return _.uniqWith(array, function (arrVal, othVal) {
    return keysList.reduce((acc, cur, idx) => {
      return acc && arrVal[cur] === othVal[cur];
    }, true);
  });
}

uniqFn(objects, ["x", "y"]);
// [Object {x: 1, y: 2, z: 1}, Object {x: 2, y: 1, z: 2}]

面试官说就你聪明呗

zyc · Answer 12 · Tue Mar 16 2021 15:37:24 GMT+0800 (China Standard Time)

// 利用map key 根据条件生成唯一key
const dedup = (data, getKey = () => {} ) => {
    // todo
    const result = [];
    const map = new Map();
    (data || []).forEach((item)=>{
        const key = getKey(item)
        if(!map.has(key)){
            result.push(item)
            map.set(key, 1)
        }
    })
    return result
  }
  dedup(data, (item)=>`id:${item.id}`)
  dedup(data1, (item)=>`id:${item.id}id1:${item.id1}`)

vision · Answer 13 · Tue Mar 16 2021 15:40:18 GMT+0800 (China Standard Time)

const dedup = (data, getKey = () => {} ) => {
  const map = {};
  const result = data.filter(i => {
    const key = getKey(i);
    if(map[key]) {
      return false;
    }
    map[key] = true;
    return true;
  })
  return result;
}

xiaofan-love · Answer 14 · Tue Mar 16 2021 15:51:51 GMT+0800 (China Standard Time)

const dedup = (data, unique) => {
    let keyMap = {};
    let newData = [];
    if (typeof unique === 'string') {
       unique = [unique];
       keyMap[unique] = []
    } else {
        unique.forEach(val => {
            keyMap[val] = []
        })
    }
    data.map(val => {
        let pushIndex = -1;
        for (var i = 0; i < unique.length; i++) {
            // 目标值不存在同样输出返回
            pushIndex = i;
            if (val.hasOwnProperty(unique[i])) {
                // 有目标key值
                if (!keyMap[unique[i]].includes(val[unique[i]])) {
                    // 目标value值不存在，进行存储
                    keyMap[unique[i]].push(val[unique[i]])
                    pushIndex = i;
                } else {
                    // 目标value值已存在，直接终止循环
                    pushIndex = -1;
                    break;
                }
            }
        }
        if (pushIndex > -1) {
            newData.push(val)
        }
    })
    return newData
}

测试结果

// 测试用例1
const data = [
    { id: 1, v: 1 },
    { id: 2, v: 2 },
    { id: 1, v: 1 },
]

dedup(data, 'id')
// 输出 => 符合预期结果
[ { id: 1, v: 1 }, { id: 2, v: 2 } ]

// 测试用例1
const data2 = [
    { id: 1, v: 1, id1: 1 },
    { id: 2, v: 2, id1: 2 },
    { id: 1, v: 1, id1: 1 },
]

dedup(data2, ['id', 'id1'])
// 输出 => 符合预期结果
[ { id: 1, v: 1, id1: 1 }, { id: 2, v: 2, id1: 2 } ]

// 测试用例3
const data3 = [
    { id: 1, v: 1, id1: 1 },
    { id: 2, v: 2, id1: 2 },
    { id: 3, v: 1, id1: 3 },
    { id: 1, v: 1, id1: 1 },
    { id: 1, v: 1, id1: 1 },
]
dedup(data3, ['id', 'id1', 'v'])
// 输出 => 符合预期结果
[ { id: 1, v: 1, id1: 1 }, { id: 2, v: 2, id1: 2 } ]

// 测试用例4
const data4 = [
    { id: 1, v: 1, id1: 1 },
    { id: 2, v: 2, id1: 2 },
    { id: 3, v: 1, id1: 3 },
    { id: 1, v: 1, id1: 1 },
    { id: 1, v: 1, id1: 1 },
    { id: 6, v1: 1, id1: 4 }
]
dedup(data4, ['id', 'id1', 'v'])
// 输出 => 符合预期结果
[ { id: 1, v: 1, id1: 1 },
  { id: 2, v: 2, id1: 2 },
  { id: 6, v1: 1, id1: 4 } ]

Leon · Answer 15 · Tue Mar 16 2021 16:32:11 GMT+0800 (China Standard Time)

 const dedup = (data, getKey = () => {} ) => {
    let obj = {}
    let arr = []
    data.reduce((acc, cur) => {
        let key =  getKey(cur);
        obj[`${key}`] ? '' : obj[`${key}`] = true && arr.push(cur)
    },[])
    return arr
  }
  console.log(dedup(data1, getkey= item => item.id))
  console.log(dedup(data1, getkey= item => `${item.id}${item.id1}`))

monadaa · Answer 16 · Tue Mar 16 2021 16:33:31 GMT+0800 (China Standard Time)

const dedup = (data, getKey = () => { }) => {
  // todo
  const arr = [];
  const map = {};
  data.forEach(item => {
    const key = getKey(item);
    console.log(map[key])
    if (!map[key]) {
      arr.push(item);
      map[key] = true;
      console.log(1111111, map[key])
    }
  })
  return arr
}
let data = [
  { id: 1, v: 1 },
  { id: 2, v: 2 },
  { id: 1, v: 1 },
]
// dedup(data, (item) => `${item.id}`)
console.log( dedup(data, (item) => `${item.id}-${item.id1}`) )

mengzhe510 · Answer 17 · Tue Mar 16 2021 16:40:26 GMT+0800 (China Standard Time)

const dedup = (data, getKey = () => {} ) => {
  let map = new Map()
  return data.filter(item => {
    let key = getKey(item)
    if (!map.has(key)) {
      map.set(key,true)
      return true
    }
    return false
  })
}
console.log(dedup(data, key => `${key.id}`))
console.log(dedup(data1, key => `${key.id}_${key.id1}`))

Yugang Cao · Answer 18 · Tue Mar 16 2021 17:12:15 GMT+0800 (China Standard Time)

let data = [
  { id: 1, v: 1 },
  { id: 2, v: 2 },
  { id: 1, v: 1 },
];

// 以 id 作为排重 key，执行函数得到结果
// data = [
//   { id: 1, v: 1 },
//   { id: 2, v: 2 },
// ];

let data1 = [
  { id: 1, v: 1, id1: 1 },
  { id: 2, v: 2, id1: 2 },
  { id: 1, v: 1, id1: 1 },
]

// 以 id 和 id1 作为排重 key，执行函数得到结果
// data1 = [
//   { id: 1, v: 1, id1: 1 },
//   { id: 2, v: 2, id1: 2 },
// ];

const dedup = (data, getKey = () => {} ) => {
  const result = []
  const map = new Map()
  data.forEach(item => {
    if (!map.has(getKey(item))) {
      result.push(item)
      map.set(getKey(item), 1)
    }
  });
  return result
}

console.log(dedup(data, (item) => item?.id))

Dengju Deng · Answer 19 · Tue Mar 16 2021 17:20:12 GMT+0800 (China Standard Time)

Typescript 版本实现 👋

使用 Map 数据结构存储键值对。

type Item<T> = {
  [k: string]: T;
};
type GetKey<T> = ((item: Item<T>) => string | number) | (() => void);
type Dedup = <T>(data: Array<Item<T>>, getKey?: GetKey<T>) => Array<Item<T>>;

const dedup: Dedup = (data, getKey = () => {}) => {
  const output: any[] = [];
  const map = new Map();
  data.forEach((element) => {
    const key = getKey(element);
    if (!map.has(key)) {
      output.push(element);
      map.set(key, 1);
    }
  });
  console.log(map);
  return output;
};

测试：

const data = [
  { id: 1, v: 1 },
  { id: 2, v: 2 },
  { id: 1, v: 1 }
];
// 以 id 作为排重 key，执行函数得到结果
console.log(dedup(data, (item) => item.id));

const data1 = [
  { id: 1, v: 1, id1: 1 },
  { id: 2, v: 2, id1: 2 },
  { id: 1, v: 1, id1: 1 }
];

// 以 id 和 id1 作为排重 key，执行函数得到结果
console.log(
  dedup(data1, (item) => JSON.stringify({ id: item.id, id1: item.id1 }))
);

输出：

// data
[
  { id: 1, v: 1 },
  { id: 2, v: 2 },
]
// data1
[
  { id: 1, v: 1, id1: 1 },
  { id: 2, v: 2, id1: 2 },
]

Akimoto · Answer 20 · Tue Mar 16 2021 17:34:09 GMT+0800 (China Standard Time)

/**
 * Desc: 数据排重
 * 给定一个任意数组，实现一个通用函数，让数组中的数据根据 key 排重：
const dedup = (data, getKey = () => {} ) => {
  // todo
}
let data = [
  { id: 1, v: 1 },
  { id: 2, v: 2 },
  { id: 1, v: 1 },
];

// 以 id 作为排重 key，执行函数得到结果
// data = [
//   { id: 1, v: 1 },
//   { id: 2, v: 2 },
// ];

let data1 = [
  { id: 1, v: 1, id1: 1 },
  { id: 2, v: 2, id1: 2 },
  { id: 1, v: 1, id1: 1 },
]

// 以 id 和 id1 作为排重 key，执行函数得到结果
// data1 = [
//   { id: 1, v: 1, id1: 1 },
//   { id: 2, v: 2, id1: 2 },
// ];
 *
 * */


const dedup = (data: any[], getKey = (item: any): any => {}) => {
    const results = new Array();
    const map = new Map();
    data.forEach((dataItem) => {
        const key = getKey(dataItem);
        if (!map.has(key)) {
            map.set(key, dataItem);
        }
    });
    map.forEach((item) => {
        results.push(item);
    });
    return results;
}

let data = [
    { id: 1, v: 1 },
    { id: 2, v: 2 },
    { id: 1, v: 1 },
];

let data1 = [
    { id: 1, v: 1, id1: 1 },
    { id: 2, v: 2, id1: 2 },
    { id: 1, v: 1, id1: 1 },
];

const res = dedup(data, (item) => item.id);
console.log(res);

const res1 = dedup(data1, (item) => `${item.id}+${item.id1}`);
console.log(res1);

慕童 · Answer 21 · Tue Mar 16 2021 19:55:58 GMT+0800 (China Standard Time)

function dedup(data, getKey) {
  let map = {};
  data.forEach((item) => {
    let key = getKey(item).join(",");
    if (!map[key]) {
      map[key] = item;
    }
  });
  return Object.values(map);
}

let data = [
  { id: 1, v: 1 },
  { id: 1, v: 1 },
  { id: 2, v: 2 }
];

let data1 = [
  { id: 1, v: 1, id1: 1 },
  { id: 2, v: 2, id1: 2 },
  { id: 1, v: 1, id1: 1 }
];

console.log(dedup(data, (item) => [item.id]));
console.log(dedup(data1, (item) => [item.id, item.id1]));

panalanjun · Answer 22 · Tue Mar 16 2021 20:26:42 GMT+0800 (China Standard Time)

var dedup = (data, getKey = () => {}) => {
	var obj = {};
	data.forEach(item => {
		var key = getKey(item);
		if (!obj.hasOwnProperty(key)) {
			obj[key] = item;
		}
	});
	return Object.values(obj);
}

var data = [
  { id: 1, v: 1 },
  { id: 2, v: 2 },
  { id: 1, v: 1 },
];

// 以 id 作为排重 key
console.log(dedup(data, (item) => item.id));


var data1 = [
  { id: 1, v: 1, id1: 1 },
  { id: 2, v: 2, id1: 2 },
  { id: 1, v: 1, id1: 1 },
]

// 以 id 和 id1 作为排重 key
console.log(dedup(data1, (item) => `${item.id}_${item.id1}`));

sunsmeil · Answer 23 · Tue Mar 16 2021 20:28:39 GMT+0800 (China Standard Time)

/*
 * @Descripttion: 
 * @version: 
 * @Date: 2021-03-16 19:58:14
 * @LastEditTime: 2021-03-16 20:20:16
 */
const dedup = (data, getKey = () => {} ) => {
  const map = new Map()
  const getKeys = getKey()
  
  if(!getKeys || getKeys.length === 0 ){
    return data
  }
  
  return data.filter(val => {
    // 取对应key的值放进map;如果已经存在不再存
    let mapKey = getKeys.map(keys => val[keys]).join('-')

    return map.get(mapKey) 
    ? false
    : !!map.set(mapKey, true)
  })
}
let data = [
  { id: 1, v: 1 },
  { id: 2, v: 2 },
  { id: 1, v: 1 },
];

console.log(dedup(data, getKey = () => ['id']))
// 以 id 作为排重 key，执行函数得到结果
// data = [
//   { id: 1, v: 1 },
//   { id: 2, v: 2 },
// ];

let data1 = [
  { id: 1, v: 1, id1: 1 },
  { id: 2, v: 2, id1: 2 },
  { id: 1, v: 1, id1: 1 },
]
console.log(dedup(data1, getKey = () => ['id', 'id1']))

// 以 id 和 id1 作为排重 key，执行函数得到结果
// data1 = [
//   { id: 1, v: 1, id1: 1 },
//   { id: 2, v: 2, id1: 2 },
// ];

sunsmeil · Answer 24 · Tue Mar 16 2021 20:32:56 GMT+0800 (China Standard Time)

const dedup = (data, unique) => {
    let keyMap = {};
    let newData = [];
    if (typeof unique === 'string') {
       unique = [unique];
       keyMap[unique] = []
    } else {
        unique.forEach(val => {
            keyMap[val] = []
        })
    }
    data.map(val => {
        let pushIndex = -1;
        for (var i = 0; i < unique.length; i++) {
            // 目标值不存在同样输出返回
            pushIndex = i;
            if (val.hasOwnProperty(unique[i])) {
                // 有目标key值
                if (!keyMap[unique[i]].includes(val[unique[i]])) {
                    // 目标value值不存在，进行存储
                    keyMap[unique[i]].push(val[unique[i]])
                    pushIndex = i;
                } else {
                    // 目标value值已存在，直接终止循环
                    pushIndex = -1;
                    break;
                }
            }
        }
        if (pushIndex > -1) {
            newData.push(val)
        }
    })
    return newData
}

测试结果


// 测试用例1
const data = [
    { id: 1, v: 1 },
    { id: 2, v: 2 },
    { id: 1, v: 1 },
]

dedup(data, 'id')
// 输出 => 符合预期结果
[ { id: 1, v: 1 }, { id: 2, v: 2 } ]

// 测试用例1
const data2 = [
    { id: 1, v: 1, id1: 1 },
    { id: 2, v: 2, id1: 2 },
    { id: 1, v: 1, id1: 1 },
]

dedup(data2, ['id', 'id1'])
// 输出 => 符合预期结果
[ { id: 1, v: 1, id1: 1 }, { id: 2, v: 2, id1: 2 } ]

// 测试用例3
const data3 = [
    { id: 1, v: 1, id1: 1 },
    { id: 2, v: 2, id1: 2 },
    { id: 3, v: 1, id1: 3 },
    { id: 1, v: 1, id1: 1 },
    { id: 1, v: 1, id1: 1 },
]
dedup(data3, ['id', 'id1', 'v'])
// 输出 => 符合预期结果
[ { id: 1, v: 1, id1: 1 }, { id: 2, v: 2, id1: 2 } ]

// 测试用例4
const data4 = [
    { id: 1, v: 1, id1: 1 },
    { id: 2, v: 2, id1: 2 },
    { id: 3, v: 1, id1: 3 },
    { id: 1, v: 1, id1: 1 },
    { id: 1, v: 1, id1: 1 },
    { id: 6, v1: 1, id1: 4 }
]
dedup(data4, ['id', 'id1', 'v'])
// 输出 => 符合预期结果
[ { id: 1, v: 1, id1: 1 },
  { id: 2, v: 2, id1: 2 },
  { id: 6, v1: 1, id1: 4 } ]

您好这个测试用例是用的什么生成的呀还是自己写的

muzishuiji · Answer 25 · Tue Mar 16 2021 20:56:14 GMT+0800 (China Standard Time)

const dedup = (data, getKey = () => {}) => {
  const keys = getKey() || [];
  let temp = [];
  let obj = {};
  keys.forEach((key) => {
    data.forEach((item) => {
      // 判断是否有对应的属性
      if (item[key]) {
        if (!obj[item[key]]) {
          temp.push({ ...item });
        }
        obj[item[key]] = true;
      }
    });
  });
  return temp;
};
let data = [
  { id: 1, v: 1 },
  { id: 2, v: 2 },
  { id: 1, v: 2 },
];

// 以 id 作为排重 key，执行函数得到结果
dedup (data, ( ) => ['id'])
// data = [
//   { id: 1, v: 1 },
//   { id: 2, v: 2 },
// ];

let data1 = [
  { id: 1, v: 1, id1: 1 },
  { id: 2, v: 2, id1: 2 },
  { id: 1, v: 2, id1: 1 },
]

// 以 id 和 id1 作为排重 key，执行函数得到结果
dedup (data, ( ) => ['id', 'id1'])
// data1 = [
//   { id: 1, v: 1, id1: 1 },
//   { id: 2, v: 2, id1: 2 },
// ];

xiaofan-love · Answer 26 · Tue Mar 16 2021 20:58:09 GMT+0800 (China Standard Time)

const dedup = (data, unique) => {
    let keyMap = {};
    let newData = [];
    if (typeof unique === 'string') {
       unique = [unique];
       keyMap[unique] = []
    } else {
        unique.forEach(val => {
            keyMap[val] = []
        })
    }
    data.map(val => {
        let pushIndex = -1;
        for (var i = 0; i < unique.length; i++) {
            // 目标值不存在同样输出返回
            pushIndex = i;
            if (val.hasOwnProperty(unique[i])) {
                // 有目标key值
                if (!keyMap[unique[i]].includes(val[unique[i]])) {
                    // 目标value值不存在，进行存储
                    keyMap[unique[i]].push(val[unique[i]])
                    pushIndex = i;
                } else {
                    // 目标value值已存在，直接终止循环
                    pushIndex = -1;
                    break;
                }
            }
        }
        if (pushIndex > -1) {
            newData.push(val)
        }
    })
    return newData
}

测试结果


// 测试用例1
const data = [
    { id: 1, v: 1 },
    { id: 2, v: 2 },
    { id: 1, v: 1 },
]

dedup(data, 'id')
// 输出 => 符合预期结果
[ { id: 1, v: 1 }, { id: 2, v: 2 } ]

// 测试用例1
const data2 = [
    { id: 1, v: 1, id1: 1 },
    { id: 2, v: 2, id1: 2 },
    { id: 1, v: 1, id1: 1 },
]

dedup(data2, ['id', 'id1'])
// 输出 => 符合预期结果
[ { id: 1, v: 1, id1: 1 }, { id: 2, v: 2, id1: 2 } ]

// 测试用例3
const data3 = [
    { id: 1, v: 1, id1: 1 },
    { id: 2, v: 2, id1: 2 },
    { id: 3, v: 1, id1: 3 },
    { id: 1, v: 1, id1: 1 },
    { id: 1, v: 1, id1: 1 },
]
dedup(data3, ['id', 'id1', 'v'])
// 输出 => 符合预期结果
[ { id: 1, v: 1, id1: 1 }, { id: 2, v: 2, id1: 2 } ]

// 测试用例4
const data4 = [
    { id: 1, v: 1, id1: 1 },
    { id: 2, v: 2, id1: 2 },
    { id: 3, v: 1, id1: 3 },
    { id: 1, v: 1, id1: 1 },
    { id: 1, v: 1, id1: 1 },
    { id: 6, v1: 1, id1: 4 }
]
dedup(data4, ['id', 'id1', 'v'])
// 输出 => 符合预期结果
[ { id: 1, v: 1, id1: 1 },
  { id: 2, v: 2, id1: 2 },
  { id: 6, v1: 1, id1: 4 } ]

您好这个测试用例是用的什么生成的呀还是自己写的

自己写的额

vandvassily · Answer 27 · Tue Mar 16 2021 21:02:53 GMT+0800 (China Standard Time)

const dedup = (data, getKey = () => {}) => {
  const res = []
  const map = {}
  data.forEach((value) => {
    if (!map[getKey(value)]) {
      map[getKey(value)] = value
      res.push(value)
    }
  })

  return res
}
let data = [
  { id: 1, v: 1 },
  { id: 2, v: 2 },
  { id: 1, v: 1 },
]

// 以 id 作为排重 key，执行函数得到结果
// data = [
//   { id: 1, v: 1 },
//   { id: 2, v: 2 },
// ];

let data1 = [
  { id: 1, v: 1, id1: 1 },
  { id: 2, v: 2, id1: 2 },
  { id: 1, v: 1, id1: 1 },
]

// 以 id 和 id1 作为排重 key，执行函数得到结果
// data1 = [
//   { id: 1, v: 1, id1: 1 },
//   { id: 2, v: 2, id1: 2 },
// ];

console.log(dedup(data, (value) => `id${value.id}`))
console.log(dedup(data1, (value) => `id${value.id}idx${value.idx}`))

Mr.Huang · Answer 28 · Tue Mar 16 2021 21:49:52 GMT+0800 (China Standard Time)

既然是通用的，就考虑了key为基本数据类型、数组、对象三种情况

const dedup = (data, getKey = () => {}) => {
    let arrKey = [];
    let objKey = [];
    let map = new Map();
    return data.filter((item, index) => {
        let hasIt = false; // 是否存在该项
        let key = getKey(item, index);
        if (Array.isArray(key)) {
            // 二维数组查找相同的一项
            let index = arrKey.findIndex((items) => {
                if (items.length !== key.length) {
                    return false;
                }
                // items 与 key各项是否相同
                return -1 === items.findIndex((t, i) => t !== key[i]);
            });
            hasIt = -1 !== index
            if (!hasIt) {
                arrKey.push(key);
            }
        } else if ("object" === typeof key && key !== null) {
            let index = objKey.findIndex(obj => {
                let keyEntties = Object.entries(key)
                if(keyEntties.length !== Object.keys(obj).length){
                    return false
                }
                return -1 === keyEntties.findIndex(([key, value])=>obj[key]!==value)
            })
            hasIt = -1 !== index 
            if (!hasIt) {
                objKey.push(key);
            }
        } else {
            hasIt = map.get(key)
            if (!hasIt) {
                map.set(key, true)
            }
        }
        return !hasIt;
    });
};
let data = [
  { id: 1, v: 1 },
  { id: 2, v: 2 },
  { id: 1, v: 1 },
];
let result = dedup(data, item => item.id)
console.log('基本数据类型做key', JSON.stringify(result));
// 以 id 作为排重 key，执行函数得到结果
// data = [
//   { id: 1, v: 1 },
//   { id: 2, v: 2 },
// ];

let data1 = [
  { id: 1, v: 1, id1: 1 },
  { id: 2, v: 2, id1: 2 },
  { id: 1, v: 1, id1: 1 },
];

// 以 id 和 id1 作为排重 key，执行函数得到结果
// data1 = [
//   { id: 1, v: 1, id1: 1 },
//   { id: 2, v: 2, id1: 2 },
// ];
result = dedup(data1, item => ([item.id, item.id1]))
console.log('数组做key', JSON.stringify(result));
result = dedup(data1, ({id, id1}) => ({id, id1}))
console.log('对象做key', JSON.stringify(result));

ErnestWangZuNian · Answer 29 · Tue Mar 16 2021 22:54:55 GMT+0800 (China Standard Time)

map结构很容易实现

  const dedup = (data: any[], getKey: () => string | string[]) => {
  const keys = getKey();
  const uniqueKeys = Array.isArray(keys) ? keys : [keys];
  const tempMap = new Map();
  const result: any[] = [];
  data.forEach(item => {
    const stringKey = JSON.stringify(uniqueKeys.map(key => item[key]));
    if (!tempMap.has(stringKey)) {
      result.push(item);
      tempMap.set(stringKey, true);
    }
  });
  console.log(tempMap, 'wwww');
  return result;
};
let data = [
  { id: 1, v: 1 },
  { id: 1, v: 2 },
  { id: 1, v: 2 },
];
let data1 = [
  {
    id: 1,
    v: 1,
    id1: 1,
  },
  {
    id: 1,
    v: 2,
    id1: 1,
  },
  {
    id: 1,
    v: 2,
    id1: 2,
  },
];
console.log(dedup(data, () => 'id'));

console.log(dedup(data1, () => ['id', 'id1']));

ChenJK · Answer 30 · Tue Mar 16 2021 22:56:35 GMT+0800 (China Standard Time)

const dedup = (data, getKey = () => {}) => {
  const result = [];
  const map = new Map();
  data.forEach((item) => {
    const key = getKey(item);
    if (!map.has(key)) {
      result.push(item);
      map.set(key, 1);
    }
  });
  return result;
};

learnRy · Answer 31 · Tue Mar 16 2021 22:58:40 GMT+0800 (China Standard Time)

const dedup = (data, getKey = ()=> {}) => {
  const arr = []
  const map = new Map()
  data.forEach((item, index) => {
    let sign = false
    for(let i = 0; i < index; i++) {
      if(map.get(i) === getKey(item)) {
        sign = true
        return 
      }
    }
    if(!sign) {
      map.set(index, getKey(item))
    }
   })
   data.forEach((item, index) => {
     if(map.get(index)) {
       arr.push(JSON.parse(JSON.stringify(item)))
     }
   })
   return arr
}

Leexuetao · Answer 32 · Tue Mar 16 2021 22:59:17 GMT+0800 (China Standard Time)

const dedup = (data, getKey = () => {} ) => {
const keys = data.map(getKey)
return data.filter((item, index) => index === keys.indexOf(keys[index]))
}

dedup(data, (item) => ${item.id})
dedup(data1, (item) => ${item.id},${item.id1})

LiuJianliang · Answer 33 · Tue Mar 16 2021 23:13:42 GMT+0800 (China Standard Time)

const dedup = (data, getKey = () => { }) => {
        const map = data.reduce((pre, cur) => {
            const key = getKey(cur)
            if (!pre[key]) {
                pre[key] = cur
            }
            return pre
        }, {})
        return Object.values(map)
    }

Li · Answer 34 · Tue Mar 16 2021 23:18:04 GMT+0800 (China Standard Time)

function dedup(data, getKey = () => {}) {
  if (data == null) return;
  let result = new Map();
  data.reduce((prev, curr) => {
    const key = getKey(curr);
    if (!result.has(key)) {
      prev.set(key, curr);
    }
    return prev;
  }, result);

  return Array.from(result.values());
}

let data = [
  { id: 1, v: 1 },
  { id: 2, v: 2 },
  { id: 1, v: 1 }
];

// 以 id 作为排重 key，执行函数得到结果
// data = [
//   { id: 1, v: 1 },
//   { id: 2, v: 2 },
// ];

let data1 = [
  { id: 1, v: 1, id1: 1 },
  { id: 2, v: 2, id1: 2 },
  { id: 1, v: 1, id1: 1 }
];

// 以 id 和 id1 作为排重 key，执行函数得到结果
// data1 = [
//   { id: 1, v: 1, id1: 1 },
//   { id: 2, v: 2, id1: 2 },
// ];

console.log(dedup(data, (value) => value.id));
console.log(dedup(data1, (value) => `${value.id}-${value.id1}`));

weiChow · Answer 35 · Tue Mar 16 2021 23:39:46 GMT+0800 (China Standard Time)

const dedup = (data: any[], keys: string[]) => {
    const _duplicateRemovalMap = new Map();

    data.forEach((item, index) => {
      let _uniqueKey: string = '';
      keys.forEach((key, index) => {
        _uniqueKey += index > 0 ? `-${item[key]}` : `${item[key]}`;
      });
      _duplicateRemovalMap.set(_uniqueKey, index);
    })

    const _duplicateRemovalList: any[] = [];

    // @ts-ignore
    for (let index of _duplicateRemovalMap.values()) {
      _duplicateRemovalList.push(data[index as number]);
    }

    return _duplicateRemovalList;
  }

SunshineZJJ · Answer 36 · Wed Mar 17 2021 14:59:53 GMT+0800 (China Standard Time)

// ---循环排序
			function sortEle(arr, key) {
				for (var i = 1; i <= arr.length - 1; i++) {
					//内层循环
					for (var j = 0; j <= arr.length - 1 - i; j++) {
						if (arr[j][key] > arr[j + 1][key]) {
							const one = arr[j];
							const two = arr[j + 1];
							arr[j] = two;
							arr[j + 1] = one;
							arr[j].index = j;
							arr[j + 1].index = j + 1;
						}
					}
				}
				return arr
			}
			// ---去重
			function unique(arr,key) {
				var hash = [];
				for (var i = 0; i < arr.length; i++) {
					let repate=hash.filter(e=>{return e[key]==arr[i][key]});
					if (!(repate && repate.length>0)) {
						hash.push(arr[i]);
					}
				}
				return hash;
			}
			
			const dedup = (data, key) => {
				return sortEle(unique(data, key),key);
			}

smy · Answer 37 · Thu Mar 18 2021 00:08:38 GMT+0800 (China Standard Time)

let data = [
    { id: 1, v: 1 },
    { id: 2, v: 2 },
    { id: 1, v: 1 },
]

let data1 = [
    { id: 1, v: 1, id1: 1 },
    { id: 2, v: 2, id1: 2 },
    { id: 1, v: 1, id1: 1 },
]

const dedup = (data, getKey = () => { }) => {
    const map = new Map()
    return data.reduce((prev, curr) => {
	const key = getKey(curr)
        if (!map.has(key)) {
	    prev.push(curr)
	    map.set(key, 1)
	}
	return prev
    }, [])
}

console.log(dedup(data, item => item.id))
console.log(dedup(data1, item => JSON.stringify({id: item.id, id1: item.id1})))

Jialing · Answer 38 · Mon Mar 22 2021 23:17:54 GMT+0800 (China Standard Time)

const dedup = (data, getKey = () => {} ) => {
  const map = new Map();

  data.forEach((item) => {
    let k = getKey(item);
    if(Array.isArray(k)) k = k.join('-');
    !map.has(k) && map.set(k, item);
  });
  return [...map.values()];
}

Jacky-Summer · Answer 39 · Mon Mar 29 2021 23:23:50 GMT+0800 (China Standard Time)

const dedup = (data, getKey = () => {}) => {
  const result = []
  const map = new Map()
  data.forEach(item => {
    const key = getKey(item)
    if (!map.has(key)) {
      result.push(item)
      map.set(key, item)
    }
  })
  return result
}