第 113 题：根据以下要求，写一个数组去重函数 #215
Comments
|
我不会🙁 |
|
用set做 |
|
￣□￣｜｜ |
|
function parseArr(arr){ |
|
用set做的麻烦问一下怎么处理对象顺序不同的问题 |
NO Setarr.map(JSON.stringify).filter((v, k, arr) => arr.indexOf(v) === k).map(JSON.parse) |
|
用JSON.parse和JSON.stringify的同学，如果数组有undefined是不是就报错了;还有就是如果数组里包含循环引用的对象，是不是就都报错了╮(╯▽╰)╭ |
|
用JSON.stringify的，没考虑object里的key顺序不同？😑做题前要把情况考虑清楚 |
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)); |
自定义哈希函数 哈希表因为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
} |
//这个还要做类型判断和还原的，但是我们可以机智的用JSON.stringify 案例测试： 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"]); |
|
var $ = { }, }, }, }, }
|
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 |
|
最原始（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"] |
var toType = (obj) => {
return ({}).toString.call(obj).match(/\s([a-zA-Z]+)/)[1].toLowerCase()
}
var isEqual = (value, other) => {
var type = toType(value);
if (type !== toType(other)) return false;
if (type === 'number') {
return value === other
}
var valueLen = type === 'array' ? value.length : Object.keys(value).length;
var otherLen = type === 'array' ? other.length : Object.keys(other).length;
if (valueLen !== otherLen) return false;
if (type === 'array') {
for (var i = 0; i < valueLen; i++) {
if (!isEqual(value[i], other[i])) return false;
}
} else {
for (var key in value) {
if (value.hasOwnProperty(key)) {
if (!isEqual(value[key], other[key])) return false;
}
}
}
return true;
};
function unique(arr) {
arr = arr.reduce((previous, current) => {
var object = previous.filter(item => isEqual(item, current));
if (object.length === 0) {
previous.push(current);
}
return previous;
}, []);
return arr
}
unique([123, {a: 1}, {a: {c: 1, b: 1}}, {a: "1"}, {a: {b: 1, c: 1}}, "meili"])
// => [ 123, { a: 1 }, { a: { c: 1, b: 1 } }, { a: '1' }, 'meili' ] |
function filterArray(array) {
var keys = {}
if (array && array.length) {
var rst = array.filter((val1)=>{
var str = JSON.stringify(val1);
if (!keys[str]) {
keys[str] = true;
return true;
} else {
return false;
}
})
}
return rst;
}
// [123, "meili", "123", "mogu", 123]，则输出：[123, "meili", "123", "mogu"]
console.log(filterArray([123, "meili", "123", "mogu", 123]))
// [123, [1, 2, 3], [1, "2", 3], [1, 2, 3], "meili"]，则输出：[123, [1, 2, 3], [1, "2", 3], "meili"]
console.log(filterArray([123, [1, 2, 3], [1, "2", 3], [1, 2, 3], "meili"]))
// [123, {a: 1}, {a: {b: 1}}, {a: "1"}, {a: {b: 1}}, "meili"]，则输出：[123, {a: 1}, {a: {b: 1}}, {a: "1"}, "meili"]
console.log(filterArray([123, {a: 1}, {a: {b: 1}}, {a: "1"}, {a: {b: 1}}, "meili"])) |
function filterMap (arr) {
var Map103 = new Map()
arr.forEach(item => {
Map103.set(JSON.stringify(item), item)
})
return [...Map103.values()]
}
console.log(filterMap([123, "meili", "123", "mogu", 123]))
console.log(filterMap([123, [1, 2, 3], [1, "2", 3], [1, 2, 3], "meili"]))
console.log(filterMap([123, {a: 1}, {a: {b: 1}}, {a: "1"}, {a: {b: 1}}, "meili"])) |
let x = [123, "meili", "123", "mogu", 123]
let x1 = [123, [1, 2, 3], [1, "2", 3], [1, 2, 3], "meili"]
let x2 = [123, {a: 1}, {a: {b: 1}}, {a: "1"}, {a: {b: 1}}, "meili"]
function func(arr) {
let newArr = arr.map(item => JSON.stringify(item))
return arr.filter((item,index)=>{
if(typeof item === 'object') {
return newArr.indexOf(JSON.stringify(item)) === index
}else{
return arr.indexOf(item) === index
}
})
}
console.log(func(x))
console.log(func(x1))
console.log(func(x2))考点就在于2个一模一样对象的过滤，虽然是一样的，但是会作为不同的对象存储在堆内存中，所以需要用JSON.stringify 序列化才能准确判断，逻辑方面没有5楼写的好 |
|
|
|
|
先定义一个判断是否相同的函数，类型不同直接返回false，两边为object则递归再次比较 function isOne(left, right) {
if (typeof left !== typeof right) {
return false
}
if (typeof left == 'object') {
let isTrue = true
Object.keys(left).forEach(key => {
if (typeof left[key] == 'object') {
isTrue = isOne(left[key], right[key])
} else {
if (left[key] !== right[key]) {
isTrue = false
}
}
});
return isTrue
} else {
if (left === right)
return true
}
}去重主函数： function deepFliter(array) {
let result = []
for (let i = 0; i < array.length; i++) {
let temp = true
for (let j = i + 1; j < array.length; j++) {
if (isOne(array[j], array[i])) {
temp = false
}
}
if (temp) {
result.push(array[i])
}
}
return result
}
let array = [123, { a: 1 }, { a: { b: 1 } }, { a: "1" }, { a: { b: 1 } }, "meili"]
console.log(deepFliter(array)) |
那么key顺序不同的应该输出哪个key顺序的结果呢 |
|
so， @yygmind 这题需要考虑键顺序不同的 json 么 |
|
没有什么数组去重是一个 new Set 解决不了的……等一下，你是说数组项里还可能有对象或数组？打扰了…… function removeRepeat(arr) {
const map = new Map();
// 先用 Set 过滤一波，过滤掉重复的基本类型
return [...new Set(arr)].filter(item => {
// 这里现在只剩下引用类型了
// 把引用类型转为 string，作为 Map 的键名
const key = JSON.stringify(item);
// 判断是否有此键名
if (!map.has(key)) {
map.set(key, true);
return true;
}
});
}
const test = [
{
it: [123, "meili", "123", "mogu", 123],
expect: [123, "meili", "123", "mogu"]
}, {
it: [123, [1, 2, 3], [1, "2", 3], [1, 2, 3], "meili"],
expect: [123, [1, 2, 3], [1, "2", 3], "meili"]
}, {
it: [123, {a: 1}, {a: {b: 1}}, {a: "1"}, {a: {b: 1}}, "meili"],
expect: [123, {a: 1}, {a: {b: 1}}, {a: "1"}, "meili"]
}
];
test.map(item => {
const result = removeRepeat(item.it);
const isPassed = JSON.stringify(result) === JSON.stringify(item.expect);
console.group(result);
isPassed ? console.log('%c√ Pass', 'color: green') :
console.log('%c× Failed', 'color: red');
console.groupEnd();
});
|
//false 不相等 true相等
function compareArray(t, j) {
if (t instanceof Array && j instanceof Array && t.length === j.length) {
let flag = true;
for (let i = 0; i < t.length; i++) {
flag = flag && t[i] === j[i];
if (!flag) {
break;
}
}
return flag;
}
}
//false 不相等 true相等
function compareObject(obj1, obj2) {
let retObj1 = {};
let retObj2 = {};
let flag = true;
transform(obj1, '', retObj1);
transform(obj2, '', retObj2);
for (let key in retObj1) {
if (retObj1[key] !== retObj2[key]) {
flag = false;
break;
}
}
return flag;
}
var transform = function (entry, str, temp) {
for (let key of Object.keys(entry)) {
if (typeof entry[key] === "object") {
transform(entry[key], str + key + '.', temp);
} else {
str += key;
temp[str] = entry[key];
}
}
}
function test(tmp) {
return Array.from(new Set(tmp)).reduce((prev, curr) => {
let flag = false
for (let t of prev) {
if (typeof t === 'object') {
if (curr instanceof Array) {
flag = !flag && compareArray(t, curr);
if (flag) {
break;
}
} else if (curr instanceof Object) {
flag = !flag && compareObject(t, curr)
if (flag) {
break;
}
}
}
}
if (!flag) {
prev.push(curr)
}
return prev
}, [])
}大佬们给看下行不行呢？ |
function unique(arr) {
const result = [];
const isArray = Array.isArray;
for (let v of arr) {
result.every(e => !equal(v, e)) && result.push(v);
}
return result;
function equal(a, b) {
if (a && b && typeof a === 'object' && typeof b === 'object') {
return isArray(a) === isArray(b)
&& (isArray(a) ?
a.length === b.length && a.every((e, i) => equal(e, b[i]))
: Object.keys(a).length === Object.keys(b).length && Object.keys(a).every(k => equal(a[k], b[k]))
);
} else {
return a === b;
}
}
} |
问题问题实际上是一个去重问题，在
去重本身就是遍历数组比较而已，因此重点是实现含有以上两条扩展规则的比较函数。 实现比较函数思路：
去重思路：
代码实现// 辅助函数 用于类型获取
var getType = (function() {
const class2type = { '[object Boolean]': 'boolean', '[object Number]': 'number', '[object String]': 'string', '[object Function]': 'function', '[object Array]': 'array', '[object Date]': 'date', '[object RegExp]': 'regexp', '[object Object]': 'object', '[object Error]': 'error', '[object Symbol]': 'symbol' };
return function getType(obj) {
if (obj == null) {
return obj + '';
}
const str = Object.prototype.toString.call(obj);
return typeof obj === 'object' || typeof obj === 'function' ? class2type[str] || 'object' : typeof obj;
};
})();
/**
* 判断两个元素是否相等
* 在 === 的基础上 有如下扩展规则
* 规则1：如果是数组 则每个元素相等认为两个数组相等
* 规则2：如果是对象 则每个键的值都相等则认为两个对象相等
* @param {any} target 比较元素
* @param {any} other 其他元素
* @returns {Boolean} 是否相等
*/
function isEqual(target, other) {
const t1 = getType(target);
const t2 = getType(other);
// 类型不同
if (t1 !== t2) return false;
if (t1 === 'array') {
if (target.length !== other.length) return false; // 数组长度不等
// 比较当前数组和另一个数组中的每个元素
return target.every((item, i) => {
// return item === target;
return isEqual(item, other[i]);
});
}
if (t2 === 'object') {
// 对象情况类似数组 但是遍历方法区别一下
const keysArr = Object.keys(target);
if (keysArr.length !== Object.keys(other).length) return false;
return keysArr.every(k => {
return isEqual(target[k], other[k]);
});
}
return target === other;
}
/**
* 对输入数组按照指定规则进行去重
*
* @param {Array<any>} arr 待去重的数组
* @returns {Array<any>} 去重后的新数组
*/
function unique(arr) {
return arr.reduce((outputArr, current) => {
const isUnique = !outputArr.some(item => isEqual(current, item));
if (isUnique) {
outputArr.push(current);
}
return outputArr;
}, []);
} |
|
参考了大家的 function getUnrepeatArr(arr){
let obj = {}
return arr.filter((item) => {
return obj.hasOwnProperty(JSON.stringify(item)) ? false : (obj[JSON.stringify(item)] = true)
})
}测试了三个用例，可以输出正确结果。 |
/*
第 113 题：编程题，根据以下要求，写一个数组去重函数（蘑菇街）
如传入的数组元素为[123, "meili", "123", "mogu", 123]，则输出：[123, "meili", "123", "mogu"]
如传入的数组元素为[123, [1, 2, 3], [1, "2", 3], [1, 2, 3], "meili"]，则输出：[123, [1, 2, 3], [1, "2", 3], "meili"]
如传入的数组元素为[123, {a: 1}, {a: {b: 1}}, {a: "1"}, {a: {b: 1}}, "meili"]，则输出：[123, {a: 1}, {a: {b: 1}}, {a: "1"}, "meili"]
*/
function unique(arr) {
const res = [];
const isObject = item =>
Object.prototype.toString.call(item) === "[object Object]";
const isArray = item =>
Object.prototype.toString.call(item) === "[object Array]";
const compare = (a, b) => {
if (isArray(a) && isArray(b) && a.length === b.length) {
for (let i = 0; i < a.length; i++) {
if (!compare(a[i], b[i])) {
return false;
}
}
return true;
} else if (isObject(a) && isObject(b)) {
if (Object.values(a).length === Object.values(b).length) {
for (let key in a) {
if (!compare(a[key], b[key])) {
return false;
}
}
return true;
} else {
return false;
}
} else {
if (a === b) {
return true;
}
return false;
}
};
const find = function(res, item) {
if(res.length==0){
return false;
}
for (let i = 0; i < res.length; i++) {
if (compare(res[i], item)) {
return true;
}
}
return false;
};
for (let i = 0; i < arr.length; i++) {
if (!find(res, arr[i])) {
res.push(arr[i]);
}
}
return res;
}
console.log(unique([123, "meili", "123", "mogu","123"]));
console.log(unique([123, [1, 2, 3], [1, "2", 3], [1, 2, 3], "meili"]));
console.log(unique([123, {a: 1}, {a: {b: 1}}, {a: "1"}, {a: {b: 1}}, "meili"])); |
function getArr(arr) {
let set = new Set()
let mArr = []
for(let i = 0; i < arr.length; i++) {
if (Array.isArray(arr[i]) || typeof (arr[i]) == 'object') {
let str = JSON.stringify(arr[i])
if (!mArr.includes(str)) {
set.add(arr[i])
mArr.push(str)
}
} else {
set.add(arr[i])
}
}
return [...set]
}
|
|
function dedup(list = []) {
let m = new Map()
Array.from(new Set(list)).map(item => {
if (typeof(item) === 'object') {
if (!m.has(JSON.stringify(item))) {
m.set(JSON.stringify(item), item)
}
} else {
m.set(item, item)
}
})
return [...m.values()]
}
dedup([123, "meili", "123", "mogu", 123])
dedup([123, [1, 2, 3], [1, "2", 3], [1, 2, 3], "meili"])
dedup([123, {a: 1}, {a: {b: 1}}, {a: "1"}, {a: {b: 1}}, "meili"])
|
|
对象转化为数组格式排序后，再用JSON.stringify处理，解决键名顺序问题 const arr1 = [123, "meili", "123", "mogu", 123];
const arr2 = [123, [1, 2, 3], [1, "2", 3], [1, 2, 3], "meili"];
const arr3 = [123, { a: 1 }, { a: { b: 1 } }, { a: "1" }, { a: { b: 1 } }, "meili", { a: { b: 1, c: 2, d: 4 } }, { a: { d: 4, c: 2, b: 1 } }];
const arr4 = [{ b: 1, c: 2 }, { c: 2, b: 1 }];
const cutRepeatNotype = (arr) => {
const getArray = (data) => {
if (data instanceof Array) {
let val = [];
for (let i = 0; i < data.length; i++) {
val.push(getArray(data[i]));
}
return val;
}
else if (data && typeof data === 'object') {
let val = [];
let map = new Map();
for (let k in data) {
map.set(k, data[k]);
}
([...map.keys()]).sort((a, b) => a > b ? 1 : -1).forEach(k => {
val.push([k, getArray(map.get(k))]);
});
return val;
}
else {
return data;
}
};
let arrStr = arr.map(item => ({
val: item,
type: JSON.stringify(getArray(item))
}));
let map = new Map();
return arrStr.filter(item => !map.has(item.type) && map.set(item.type, item.val)).map(item => item.val);
};
console.log(cutRepeatNotype(arr1));
console.log(cutRepeatNotype(arr2));
console.log(cutRepeatNotype(arr3));
console.log(cutRepeatNotype(arr4)); |
function delRepeat(originalArr) {
let arr = originalArr.slice(0)
for (let i = 0; i < arr.length; i++) {
for (let j = i + 1; j < arr.length; j++) {
if (objDeepEqual(arr[i], arr[j])) {
arr.splice(j, 1)
}
}
}
return arr
}
function objDeepEqual(source, target) {
if (typeof source !== typeof target) return false
if (typeof source === 'object') {
for (let key in source) {
if (typeof source[key] !== 'object') {
if (source[key] !== target[key]) {
return false
}
} else if (!objDeepEqual(source[key], target[key])) {
return false
}
}
} else if (source !== target) {
return false
}
return true
} |
|
最笨的方法： |
|
数组里面还包含引用传递的对象没有管 function equal (source, target) {
var to = Object.prototype.toString
var q1 = to.call(source)
var q2 = to.call(target)
if (q1 === '[object Array]' && q2 === '[object Array]') {
return source.every((item, index) => item === target[index])
} else if (q1 === '[object Object]' && q2 === '[object Object]') {
for (var k in source) {
var item = source[k]
var t = target[k]
if (to.call(item) === '[object Object]' && to.call(t) === '[object Object]') {
return equal(item, t)
}
if (item !== t) {
return false
}
}
return true
} else {
return source === target
}
}
function start (a1) {
var result = [].concat(a1), r = []
while (result.length) {
var item = result.shift()
r.push(item)
for (var i = result.length - 1; i >= 0; i--) {
if (equal(item, result[i])) {
result.splice(i, 1)
}
}
}
return r
} |
|
写的比较麻烦... var arr1 = [123, "meili", "123", "mogu", 123];
var arr2 = [123, [1, 2, 3], [1, "2", 3], [1, 2, 3], "meili"];
var arr3 = [123, { a: 1 }, { a: { b: 1 } }, { a: "1" }, { a: { b: 1 } }, "meili"];
var arr4 = [123, { a: 1 }, { a: { b: 1 } }, { a: "1" }, { a: { b: 1 } }, "meili", [1, 2, 3], [1, "2", 3], [1, 2, 3]];
function unique(arr) {
var arrSet = [... new Set(arr)];
var arr = [];
var obj = [];
arrSet.map((item, index) => {
type(item, index, arr, obj);
});
if (arr.length > 0) {
for (var i = 0; i < arr.length - 1; i++) {
for (var j = i + 1; j < arr.length; j++) { // 通过对应的角标删除arrSet对应的项
var index1 = arr[i];
var index2 = arr[j];
if (JSON.stringify(arrSet[index1]) === JSON.stringify(arrSet[index2])) {
arrSet.splice(index2, 1);
}
}
}
}
if (obj.length > 0) {
for (var i = 0; i < obj.length - 1; i++) {
for (var j = i + 1; j < obj.length; j++) {
var index1 = obj[i];
var index2 = obj[j];
if (JSON.stringify(arrSet[index1]) === JSON.stringify(arrSet[index2])) {
arrSet.splice(index2, 1);
}
}
}
}
return arrSet;
}
function type(item, index, arr, obj) {
if (item instanceof Object) {
if (Array.isArray(item)) {
arr.push(index); // 如果是数组，把对应的角标传入arr
} else {
obj.push(index); // 如果是对象，把对应的角标传入obj
}
}
}
console.log(unique(arr4)); |
function diff(arr){
let res = {};
let _arr = [];
for(let i = 0; i < arr.length; i++){
let key = typeof arr[i] + JSON.stringify(arr[i]);
if(!res[key]){
res[key] = true;
_arr.push(arr[i])
}
}
return _arr
}
let arr1 = [123, "meili", "123", "mogu", 123];
let arr2 = [123, [1, 2, 3], [1, "2", 3], [1, 2, 3], "meili"]
let arr3 = [123, { a: 1 }, { a: { b: 1 } }, { a: "1" }, { a: { b: 1 } }, "meili"]
console.log(diff(arr1))
console.log(diff(arr2))
console.log(diff(arr3)) |
|
function f(arr){ |
|
触及到老夫的知识盲区了 |
const uniq = (arr = []) => arr.reduce((t, c) => (t.includes(c) ? t : t.push(c), t), [])
const uniqArr = [123, "meili", "123", "mogu", 123]
console.log(uniq(uniqArr)) // [[123, "meili", "123", "mogu"]
//下面的不会，哈哈哈哈 |
|
function getType(data) {
return Object.prototype.toString.call(data)
}
function ff(arr) {
let targetArr = Array.from(new Set(arr))
let obj = {}
arr.forEach((item, index) => {
let typeStr = getType(item)
if (typeStr === '[object Object]' || typeStr === '[object Array]') {
let valStr = JSON.stringify(item)
if (obj[valStr]) {
targetArr.splice(index, 1)
} else {
obj[valStr] = true
}
}
})
return targetArr
}
ff([123, {a: 1}, {a: {b: 1}}, {a: "1"}, {a: {b: 1}}, "meili"])应该可以... 大概 |
|
如果 [1,2,3] 和 [1,3,2] 。{a:1,b:2} 和 {b:2,a:1} 也算相等的话 function unique(array) {
var newArr = [array[0]]
var len = array.length
for (var i = 0; i < len; i++) {
for (var j = 0; j < newArr.length; j++) {
if (isEq(newArr[j], array[i])) {
break
}
if (j == newArr.length - 1) {
newArr.push(array[i])
}
}
}
function isEq(a, b) {
if (Array.isArray(a) && Array.isArray(b)) {
var aLen = a.length
var bLen = b.length
if (aLen !== bLen) {
return false
}
for (var i = 0; i < aLen; i++) {
if (!b.includes(a[i])) {
return false
}
}
return true
} else if (typeof a == 'object' && typeof b == 'object') {
for (const key in a) {
if (a.hasOwnProperty(key)) {
return isEq(a[key], b[key])
}
}
} else {
return Object.is(a, b)
}
}
return newArr
} |
|
不用搞的这么复杂吧， 上面这么多循环 var arr = [1, -1, 0, 0, 0, 123, [1, 2, 3], [1, '2', 3], [1, 2, 3], 'meili', null, '', null, '', NaN, NaN, undefined, undefined]
// arr = [123, "meili", "123", "mogu", 123]
// arr = [123, {a: 1}, {a: {b: 1}}, {a: "1"}, {a: {b: 1}}, "meili"]
function moveSame(arr) {
const map = {}
const result = []
for (let i = 0, len = arr.length; i < len; i++) {
const item = arr[i]
let key
if (typeof item === 'object') {
key = JSON.stringify(arr[i])
} else {
key = item + typeof item
}
if (!map[key]) {
map[key] = true
result.push(item)
}
}
return result
}
console.log(moveSame(arr)); |
考虑的不错， 不过题目显然不是这个意思，而且数组是undefined 也不会报错， 会变成null值，如果非要这么搞， 那么就对数组或者对象的值先做针对处理，再用stringify。 |
|
一个for循环搞定 function filter(arr) {
let map = {};
let result = [];
for (let i = 0; i < arr.length; i++) {
console.log(JSON.stringify(arr[i]))
if (!map[JSON.stringify(arr[i])]) {
map[JSON.stringify(arr[i])] = true;
result.push(arr[i]);
}
}
return result;
}使用一个对象来保存已有的数据。 |
var arr = [123, [1, 2, 3], [1, "2", 3], [1, 2, 3], "meili"];
function test(input) {
var t = input.reduce(function (acc, item){
acc[JSON.stringify(item)] = item;
return acc;
}, {});
return Object.keys(t).map(k => t[k])
}
console.log(test(arr)) |
|
const find10 = () => { } |
function transform(arr) {
const set = new Set(arr.map(itm => itm !== void 0 ? JSON.stringify(itm) : void 0));
return Array.from(set).map(itm => {
if (itm === void 0) return void 0;
const parsed = JSON.parse(itm);
return typeof parsed !== 'object' ? JSON.parse(itm) : parsed;
})
}
console.log(
transform(
// [123, "meili", "123", "mogu", 123]
// [123, [1, 2, 3], [1, "2", 3], [1, 2, 3], "meili"]
// [123, { a: 1 }, { a: { b: 1 } }, { a: "1" }, { a: { b: 1 } }, "meili"]
[123, { a: 1 }, { a: { b: 1 } }, undefined, { a: "1" }, { a: { b: 1 } }, "meili", null]
)
); |
|
考虑对象的key值顺序，稍微麻烦了点 function deleteMul(arr) {
let set = new Set(arr);
arr = Array.from(set);
const is = (target) => Object.prototype.toString.call(target);
let objSet = [],
arrSet = [];
for (const iterator of arr) {
switch (is(iterator)) {
case "[object Object]":
objSet.push(iterator);
set.delete(iterator);
break;
case "[object Array]":
arrSet.push(iterator);
set.delete(iterator);
break;
default:
break;
}
}
const isSameObj = (a, b) => {
const aKeys = Object.keys(a),
bKeys = Object.keys(b);
if (aKeys.length !== bKeys.length) return false;
aKeys.sort((_a, _b) => _a - _b);
bKeys.sort((_a, _b) => _a - _b);
let i = 0;
while (i < aKeys.length) {
const aK = aKeys[i],
bK = bKeys[i];
if (aK !== bK) {
return false;
} else {
if (a[aK] !== b[bK]) {
const aType = is(a[aK]),
bType = is(b[bK]);
if (aType !== bType) return false;
switch (aType) {
case "[object Object]":
if (!isSameObj(a[aK], b[bK])) return false;
break;
case "[object Array]":
if (!isSameArr((a[aK], b[bK]))) return false;
break;
default:
return false;
}
}
}
i++;
}
return true;
};
const isSameArr = (a, b) => {
if (a.length !== b.length) return false;
for (let i = 0; i < a.length; i++) {
if (a[i] === b[i]) {
continue;
} else {
const aType = is(a),
bType = is(b);
if (aType !== bType) return false;
switch (aType) {
case "[object Object]":
if (!isSameObj(a[i], b[i])) return false;
break;
case "[object Array]":
if (!isSameArr((a[i], b[i]))) return false;
break;
default:
return false;
}
}
}
return true;
};
let repeatSet = new Set();
for (let i = 0; i < objSet.length - 1; i++) {
if (repeatSet.has(i)) continue;
for (let j = i + 1; j < objSet.length; j++) {
if (repeatSet.has(j)) continue;
if (isSameObj(objSet[i], objSet[j])) {
repeatSet.add(j);
}
}
}
Array.from(repeatSet).forEach((i) => (objSet[i] = null));
repeatSet.clear();
for (let i = 0; i < arrSet.length - 1; i++) {
if (repeatSet.has(i)) continue;
for (let j = i + 1; j < arrSet.length; j++) {
if (repeatSet.has(j)) continue;
if (isSameArr(objSet[i], objSet[j])) {
repeatSet.add(j);
}
}
}
Array.from(repeatSet).forEach((i) => (arrSet[i] = null));
return Array.from(set)
.concat(objSet.filter((i) => i !== null))
.concat(arrSet.filter((i) => i !== null));
} |
|
如果数组中都是都是基本数据类型，那么可以使用 function solution(arr){
return Array.from(new Set(arr))
}现在是数组中的元素可能是引用数据类型，如对象，数组等，为此可以使用Set集合，Set中有的就跳过，没有就插入新数组 function solution(arr){
const hashSet=new Set();
const res=[];
for(const i of arr){
if(hashSet.has(JSON.stringify(i))){
continue;
}
hashSet.add(JSON.stringify(i));
res.push(i)
}
return res;
}
// let arr=[123, "meili", "123", "mogu", 123];
// let arr=[123, [1, 2, 3], [1, "2", 3], [1, 2, 3], "meili"]
// let arr=[123, {a: 1}, {a: {b: 1}}, {a: "1"}, {a: {b: 1}}, "meili"]
// let arr=[1,'1',{a:1,b:"1"},{b:'1',a:1},{a:1,b:2},[1,2,3],null,undefined,undefined];
console.log(solution(arr))let arr=[123, {a: 1,b:2},{b:2,a:1} , {a: "1"} , "meili"]对于该示例，如果判定{a:1,b:2}与{b:2,a:1}相等的话，那么上面的方法暂时不能排除，需要对对象类型进一步判断 |
|
就哈哈哈哈 |
|
|
|
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
and others
如传入的数组元素为
[123, "meili", "123", "mogu", 123]，则输出：[123, "meili", "123", "mogu"]如传入的数组元素为
[123, [1, 2, 3], [1, "2", 3], [1, 2, 3], "meili"]，则输出：[123, [1, 2, 3], [1, "2", 3], "meili"]如传入的数组元素为
[123, {a: 1}, {a: {b: 1}}, {a: "1"}, {a: {b: 1}}, "meili"]，则输出：[123, {a: 1}, {a: {b: 1}}, {a: "1"}, "meili"]The text was updated successfully, but these errors were encountered: