第 113 题：根据以下要求，写一个数组去重函数

[yygmind]

1. 如传入的数组元素为[123, "meili", "123", "mogu", 123]，则输出：[123, "meili", "123", "mogu"]

2. 如传入的数组元素为[123, [1, 2, 3], [1, "2", 3], [1, 2, 3], "meili"]，则输出：[123, [1, 2, 3], [1, "2", 3], "meili"]

3. 如传入的数组元素为[123, {a: 1}, {a: {b: 1}}, {a: "1"}, {a: {b: 1}}, "meili"]，则输出：[123, {a: 1}, {a: {b: 1}}, {a: "1"}, "meili"]

[liuwenai]

我不会🙁

[Nina0408]

用set做

[Ficks]

￣□￣｜｜

[SilvaYH]

function parseArr(arr){
return [...new Set(arr.map(JSON.stringify))].map(JSON.parse)
}

没有考虑到数据类型为null,undefind等类型 包括数据为对象时key顺序不同的问题
这里再更正一下
// 判断对象
function isObj(obj){
 return Object.prototype.toString.call(obj) === '[object Object]'
}
// 对象重整 对key进行排序
function parseObj(obj){
	let keys = Object.keys(obj).sort()
	let newObj = {}
	for(let key of keys){
               // 不晓得有没有有必要，反正把value为obj的情况也处理一下 - -
                obj[key]=isObj(obj[key])?parseObj(obj[key]):obj[key]
		newObj[key] = obj[key]
	}
	return newObj
}

// 最后
const arr = [1,'1',{a:1,b:"1"},{b:'1',a:1},{a:1,b:2},[1,2,3],null,undefined,undefined]
function passArr(arr){
	return [...new Set(arr.map(item=>
		isObj(item)? JSON.stringify(parseObj(item)) : ( !item ? item : JSON.stringify(item))
    ))].map(item=>!item?item : JSON.parse(item))
}

[MarioJames]

用set做的麻烦问一下怎么处理对象顺序不同的问题
如{a:1, b:2}和{b:2, a: 1}

[MoveZZG]

NO Set

arr.map(JSON.stringify).filter((v, k, arr) => arr.indexOf(v) === k).map(JSON.parse)

[flyfox11]

用JSON.parse和JSON.stringify的同学，如果数组有undefined是不是就报错了;还有就是如果数组里包含循环引用的对象，是不是就都报错了╮(╯▽╰)╭

[suguoyao]

用JSON.stringify的，没考虑object里的key顺序不同？😑做题前要把情况考虑清楚

[Gentlemancj]

function dis(arr) {
    const resObj = {};
    const res = [];
    arr.forEach((item) => {
        const key = item + JSON.stringify(item);
        if (!resObj[key]) {
            res.push(item);
            resObj[key] = item;
        }
    })
    return res;
}

const test1 = [123, "meili", "123", "mogu", 123];

const test2 = [123, [1, 2, 3], [1, "2", 3], [1, 2, 3], "meili"];

const test3 = [123, { a: 1 }, { a: { b: 1 } }, { a: "1" }, { a: { b: 1 } }, "meili"];

console.log(dis(test1));

console.log(dis(test2));

console.log(dis(test3));

[ZodiacSyndicate]

自定义哈希函数 哈希表

因为JSON.stringify碰到key顺序不同但值相同的对象时生成的字符串不一样，所以自定义哈希函数，处理对象时先把对象的key按字典序排序，然后再生成哈希字符串

function hash(arg) {
    if (typeof arg === 'string') return `"${arg}"`
    if (typeof arg === 'number' || typeof arg === 'undefined') return `${arg}`
    if (typeof arg === 'symbol' || typeof arg === 'boolean') return arg.toString()
    if (arg === null) return 'null'
    if (Array.isArray(arg)) {
        let res = '['
        for (const item of arg) {
            res += `${hash(item)},`
        }
        res += ']'
        return res
    }
    let res = '{'
    const keys = Object.keys(arg).sort()
    for (const key of keys) {
        res += `${key}:${hash(arg[key])},`
    }
    res += '}'
    return res
}

function distinct(arr) {
    const res = []
    const map = {}
    for (const item of arr) {
        const key = hash(item)
        if (!map[key]) {
            map[key] = 1
            res.push(item)
        }
    }
    return res
}

[IAMSBLOL]

    var addSign = (data) => {
        
        var signArr = data.map((o, i) => {
            return JSON.stringify(o)
        })

        var set = [...new Set(signArr)]

        return set.map((o, i) => JSON.parse(o))
    }

//这个还要做类型判断和还原的，但是我们可以机智的用JSON.stringify它帮我们做了不同类型的处理
### 保留一下先，key顺序不同会出问题。不能是完全解决

案例测试：
addSign([123, "meili", "123", "mogu", 123]);

addSign([123, [1, 2, 3], [1, "2", 3], [1, 2, 3], "meili"]);

addSign([123, {a: 1}, {a: {b: 1}}, {a: "1"}, {a: {b: 1}}, "meili"]);

addSign([123, {a: 1}, {a: {b: 1}}, {a: "1"}, {a: {b: [1,2,{a:2222}]}}, "meili"]);

[pangxieju]

var $ = {
filters1: function(data) {
if (!data || !data.length) return [];

var temp = {0: [], 1: []};
for (var i = 0; i < data.length; i++) {
  if (!~temp[0].indexOf(JSON.stringify(data[i]))) {
    temp[0].push(JSON.stringify(data[i]))
    temp[1].push(data[i]);
  }
}
return temp[1];

},
filters2: function(data) {
if (!data || !data.length) return [];

var temp = {};
for (var i = 0; i < data.length; i++) {
  temp[JSON.stringify(data[i])] = data[i];
}
return Object.values(temp);

},
filters3: function(data) {
if (!data || !data.length) return [];

var d = new Map();
for (var i = 0; i < data.length; i++) {
  d.set(JSON.stringify(data[i]), data[i]);
}

var temp = [];
d.forEach(val => {
  temp.push(val);
})

return temp;

},
filters4: function(data) {
if (!data || !data.length) return [];

return data.map(JSON.stringify).filter((v, k, data) => data.indexOf(v) === k).map(JSON.parse);

},
filters5: function(data) {
if (!data || !data.length) return [];

return [...new Set(data.map(JSON.stringify))].map(JSON.parse);

}
};

• 2 输出的顺序会不一致
• 4,5 数组里有 undefined 会报错
• 使用 JSON.stringify 只是为了保证唯一值来去重
• 其实不用 JSON.stringify 也可以实现，比如取 MD5
• 如果错误欢迎指正

[harryliuy]

let arr = [123, "meili", "123", "mogu", 123];
let _arr = [];
arr.forEach(it => {
    if (!_arr.some(v => _.isEqual(v,it))) {
        _arr.push(it);
    }
});
console.log(_arr);

lodash

[chenweihuan]

最原始（ben）的方式，两个for循环

var a=[123, [1, 2, 3], [1, "2", 3], [1, 2, 3], "meili"];
function fn(arr) {
	let res =[];
	arr.forEach(v=>{
		if(res.length === 0){
			res.push(v);
		}else{
			for(let i =0;i<=res.length;i++){
				if(JSON.stringify(res[i]) === JSON.stringify(v))break;
				if(i === res.length-1)res.push(v);
			}
		}
	})
	return res;
}
console.log(fn(a));//[123, [1, 2, 3], [1, "2", 3], "meili"]