JavaScript에서 객체 배열에서 중복 제거

객체 배열을 포함하는 객체가 있습니다.

things = new Object();

things.thing = new Array();

things.thing.push({place:"here",name:"stuff"});
things.thing.push({place:"there",name:"morestuff"});
things.thing.push({place:"there",name:"morestuff"});

배열에서 중복 객체를 제거하는 가장 좋은 방법이 무엇인지 궁금합니다. 예를 들어, things.thing은 ...

{place:"here",name:"stuff"},
{place:"there",name:"morestuff"}

기본 방법은 다음과 같습니다.

var obj = {};

for ( var i=0, len=things.thing.length; i < len; i++ )
    obj[things.thing[i]['place']] = things.thing[i];

things.thing = new Array();
for ( var key in obj )
    things.thing.push(obj[key]);

어떻게 어떤 약 es6마법?

things.thing = things.thing.filter((thing, index, self) =>
  index === self.findIndex((t) => (
    t.place === thing.place && t.name === thing.name
  ))
)

참조 URL

보다 일반적인 해결책은 다음과 같습니다.

const uniqueArray = things.thing.filter((thing, index) => {
  const _thing = JSON.stringify(thing);
  return index === things.thing.findIndex(obj => {
    return JSON.stringify(obj) === _thing;
  });
});

Stackblitz 예

밑줄 이나 lodash 와 같은 Javascript 라이브러리를 사용할 수 있으면 _.uniq해당 라이브러리 에서 함수를 살펴 보는 것이 좋습니다 . 보낸 사람 lodash:

_.uniq(array, [isSorted=false], [callback=_.identity], [thisArg])

기본적으로 여기에 객체 리터럴이있는 배열을 전달하고 원래 데이터 배열에서 중복을 제거하려는 속성을 다음과 같이 전달합니다.

var data = [{'name': 'Amir', 'surname': 'Rahnama'}, {'name': 'Amir', 'surname': 'Stevens'}];
var non_duplidated_data = _.uniq(data, 'name'); 

업데이트 : Lodash는 이제도 도입했습니다 .uniqBy.

단일 필드의 중복을 기반으로 배열에서 중복 객체를 제거 해야하는 것과 동일한 요구 사항이 있습니다. 여기에서 코드를 찾았습니다 : Javascript : 객체 배열에서 중복 제거

따라서 내 예제에서는 licenseNum 문자열 값이 중복 된 배열에서 객체를 제거하고 있습니다.

var arrayWithDuplicates = [
    {"type":"LICENSE", "licenseNum": "12345", state:"NV"},
    {"type":"LICENSE", "licenseNum": "A7846", state:"CA"},
    {"type":"LICENSE", "licenseNum": "12345", state:"OR"},
    {"type":"LICENSE", "licenseNum": "10849", state:"CA"},
    {"type":"LICENSE", "licenseNum": "B7037", state:"WA"},
    {"type":"LICENSE", "licenseNum": "12345", state:"NM"}
];

function removeDuplicates(originalArray, prop) {
     var newArray = [];
     var lookupObject  = {};

     for(var i in originalArray) {
        lookupObject[originalArray[i][prop]] = originalArray[i];
     }

     for(i in lookupObject) {
         newArray.push(lookupObject[i]);
     }
      return newArray;
 }

var uniqueArray = removeDuplicates(arrayWithDuplicates, "licenseNum");
console.log("uniqueArray is: " + JSON.stringify(uniqueArray));

결과 :

uniqueArray는 다음과 같습니다.

[{"type":"LICENSE","licenseNum":"10849","state":"CA"},
{"type":"LICENSE","licenseNum":"12345","state":"NM"},
{"type":"LICENSE","licenseNum":"A7846","state":"CA"},
{"type":"LICENSE","licenseNum":"B7037","state":"WA"}]

ES6 + 용 최단 라이너

id배열에서 고유 한를 찾으십시오 .

arr.filter((v,i,a)=>a.findIndex(t=>(t.id === v.id))===i)

여러 속성 ( place및 name)으로 고유

arr.filter((v,i,a)=>a.findIndex(t=>(t.place === v.place && t.name===v.name))===i)

모든 속성에 고유함 (대형 배열의 경우 속도가 느림)

arr.filter((v,i,a)=>a.findIndex(t=>(JSON.stringify(t) === JSON.stringify(v)))===i)

마지막 발생을 유지하십시오.

arr.slice().reverse().filter((v,i,a)=>a.findIndex(t=>(t.id === v.id))===i).reverse()

Set을 사용하는 하나의 라이너

var things = new Object();

things.thing = new Array();

things.thing.push({place:"here",name:"stuff"});
things.thing.push({place:"there",name:"morestuff"});
things.thing.push({place:"there",name:"morestuff"});

// assign things.thing to myData for brevity
var myData = things.thing;

things.thing = Array.from(new Set(myData.map(JSON.stringify))).map(JSON.parse);

console.log(things.thing)

설명:

1. new Set(myData.map(JSON.stringify))세트를 만듭니다문자열 화 된 myData 요소를 사용하여 객체를 .
2. 객체 설정은 모든 요소가 고유한지 확인합니다.
3. 그런 다음 Array.from을 사용하여 생성 된 집합의 요소를 기반으로 배열을 만듭니다.
4. 마지막으로 JSON.parse를 사용하여 문자열 화 된 요소를 다시 개체로 변환합니다.

한 줄에 ES6 + 를 사용하면 키를 사용 하여 고유 한 객체 목록을 얻을 수 있습니다.

const unique = [...new Map(arr.map(item => [item[key], item])).values()]

함수에 넣을 수 있습니다.

function getUniqueListBy(arr, key) {
    return [...new Map(arr.map(item => [item[key], item])).values()]
}

다음은 실제 예입니다.

const arr = [
    {place: "here",  name: "x", other: "other stuff1" },
    {place: "there", name: "x", other: "other stuff2" },
    {place: "here",  name: "y", other: "other stuff4" },
    {place: "here",  name: "z", other: "other stuff5" }
]

function getUniqueListBy(arr, key) {
    return [...new Map(arr.map(item => [item[key], item])).values()]
}

const arr1 = getUniqueListBy(arr, 'place')

console.log("Unique by place")
console.log(JSON.stringify(arr1))

console.log("\nUnique by name")
const arr2 = getUniqueListBy(arr, 'name')

console.log(JSON.stringify(arr2))

작동 원리

먼저 배열을 지도 의 입력으로 사용할 수있는 방식으로 다시 매핑 합니다.

arr.map (항목 => [항목 [키], 항목]);

즉, 배열의 각 항목이 2 개의 요소가있는 다른 배열로 변환됩니다. 선택한 키 첫번째 요소로서 전체 초기 항목 번째 요소로서,이 항목 (예.이라고 배열 엔트리 , 맵 엔트리 ). 그리고 여기 공식 문서가 있습니다 지도 생성자에 배열 항목을 추가하는 방법을 보여주는 예제와 함께.

키가 배치 된 예 :

[["here", {place: "here",  name: "x", other: "other stuff1" }], ...]

두 번째로,이 수정 된 배열을 Map 생성자에 전달하면 마술이 일어납니다. Map은 중복 키 값을 제거하고 동일한 키의 마지막 삽입 값만 유지합니다. 참고 : Map은 삽입 순서를 유지합니다. ( 지도와 객체의 차이점 확인 )

새 맵 (위에 방금 매핑 한 항목 배열)

셋째, 맵 값을 사용하여 원래 항목을 검색하지만 이번에는 중복되지 않습니다.

새 맵 (mappedArr) .values ​​()

마지막으로,이 값을 새로운 배열에 추가하여 초기 구조로보고 다음을 반환합니다.

[... 새 맵 (mappedArr) .values ​​()] 반환

다음은 객체의 한 필드 만 비교해야하는 경우 Array iterating 메서드를 사용하여 수행하는 또 다른 옵션입니다.

    function uniq(a, param){
        return a.filter(function(item, pos, array){
            return array.map(function(mapItem){ return mapItem[param]; }).indexOf(item[param]) === pos;
        })
    }

    uniq(things.thing, 'place');

하나의 라이너가 여기 있습니다

let arr = [
  {id:1,name:"sravan ganji"},
  {id:2,name:"anu"},
  {id:4,name:"mammu"},
  {id:3,name:"sanju"},
  {id:3,name:"ram"},
];

console.log(Object.values(arr.reduce((acc,cur)=>Object.assign(acc,{[cur.id]:cur}),{})))

모든 추가가 끝날 때까지 중복 제거를 기다릴 수있는 경우 일반적인 방법은 먼저 배열을 정렬 한 다음 중복을 제거하는 것입니다. 정렬은 각 요소를 통해 배열을 스캔 할 때 N * N 접근 방식을 피합니다.

"중복 제거"기능은 일반적으로 unique 또는 uniq 이라고 합니다 . 기존의 일부 구현은 두 단계를 결합 할 수 있습니다 (예 : 프로토 타입의 유니크)

이 게시물 에는 라이브러리에 아직 아이디어가없는 경우 시도 할 아이디어가 거의 없습니다 . 개인적으로 나는 이것이 가장 직설적이라고 생각합니다.

    function unique(a){
        a.sort();
        for(var i = 1; i < a.length; ){
            if(a[i-1] == a[i]){
                a.splice(i, 1);
            } else {
                i++;
            }
        }
        return a;
    }  

    // Provide your own comparison
    function unique(a, compareFunc){
        a.sort( compareFunc );
        for(var i = 1; i < a.length; ){
            if( compareFunc(a[i-1], a[i]) === 0){
                a.splice(i, 1);
            } else {
                i++;
            }
        }
        return a;
    }

가장 간단한 방법은 filter다음과 같습니다.

var uniq = {}
var arr  = [{"id":"1"},{"id":"1"},{"id":"2"}]
var arrFiltered = arr.filter(obj => !uniq[obj.id] && (uniq[obj.id] = true));
console.log('arrFiltered', arrFiltered)

이것은 일반적인 방법입니다. 배열의 두 요소가 같은지 여부를 테스트하는 함수를 전달합니다. 이 경우 비교 중인 두 개체 의 name및 place속성 값을 비교합니다.

ES5 답변

function removeDuplicates(arr, equals) {
    var originalArr = arr.slice(0);
    var i, len, val;
    arr.length = 0;

    for (i = 0, len = originalArr.length; i < len; ++i) {
        val = originalArr[i];
        if (!arr.some(function(item) { return equals(item, val); })) {
            arr.push(val);
        }
    }
}

function thingsEqual(thing1, thing2) {
    return thing1.place === thing2.place
        && thing1.name === thing2.name;
}

var things = [
  {place:"here",name:"stuff"},
  {place:"there",name:"morestuff"},
  {place:"there",name:"morestuff"}
];

removeDuplicates(things, thingsEqual);
console.log(things);

원래 ES3 답변

function arrayContains(arr, val, equals) {
    var i = arr.length;
    while (i--) {
        if ( equals(arr[i], val) ) {
            return true;
        }
    }
    return false;
}

function removeDuplicates(arr, equals) {
    var originalArr = arr.slice(0);
    var i, len, j, val;
    arr.length = 0;

    for (i = 0, len = originalArr.length; i < len; ++i) {
        val = originalArr[i];
        if (!arrayContains(arr, val, equals)) {
            arr.push(val);
        }
    }
}

function thingsEqual(thing1, thing2) {
    return thing1.place === thing2.place
        && thing1.name === thing2.name;
}

removeDuplicates(things.thing, thingsEqual);

목록에 하나 더 추가합니다. ES6 및 사용 Array.reduce과를 Array.find.
이 예에서는 guid속성을 기준으로 객체를 필터링합니다 .

let filtered = array.reduce((accumulator, current) => {
  if (! accumulator.find(({guid}) => guid === current.guid)) {
    accumulator.push(current);
  }
  return accumulator;
}, []);

이 속성을 확장하여 속성을 선택하고 하나의 라이너로 압축 할 수 있습니다.

const uniqify = (array, key) => array.reduce((prev, curr) => prev.find(a => a[key] === curr[key]) ? prev : prev.push(curr) && prev, []);

이것을 사용하려면 객체 배열과 중복 제거하려는 키의 이름을 문자열 값으로 전달하십시오.

const result = uniqify(myArrayOfObjects, 'guid')

당신은 또한 사용할 수 있습니다 Map:

const dedupThings = Array.from(things.thing.reduce((m, t) => m.set(t.place, t), new Map()).values());

전체 샘플 :

const things = new Object();

things.thing = new Array();

things.thing.push({place:"here",name:"stuff"});
things.thing.push({place:"there",name:"morestuff"});
things.thing.push({place:"there",name:"morestuff"});

const dedupThings = Array.from(things.thing.reduce((m, t) => m.set(t.place, t), new Map()).values());

console.log(JSON.stringify(dedupThings, null, 4));

결과:

[
    {
        "place": "here",
        "name": "stuff"
    },
    {
        "place": "there",
        "name": "morestuff"
    }
]

댕, 애들 아, 이거 뭉개 보자, 우리 왜?

let uniqIds = {}, source = [{id:'a'},{id:'b'},{id:'c'},{id:'b'},{id:'a'},{id:'d'}];
let filtered = source.filter(obj => !uniqIds[obj.id] && (uniqIds[obj.id] = true));
console.log(filtered);
// EXPECTED: [{id:'a'},{id:'b'},{id:'c'},{id:'d'}];

TypeScript 솔루션

이렇게하면 중복 객체가 제거되고 객체 유형도 보존됩니다.

function removeDuplicateObjects(array: any[]) {
  return [...new Set(array.map(s => JSON.stringify(s)))]
    .map(s => JSON.parse(s));
}

고려하면 lodash.uniqWith

var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }];

_.uniqWith(objects, _.isEqual);
// => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]

다른 옵션은 사용자 정의 indexOf 함수를 작성하는 것입니다.이 함수는 각 오브젝트에 대해 선택한 특성 값을 비교하고이를 감소 함수로 랩핑합니다.

var uniq = redundant_array.reduce(function(a,b){
      function indexOfProperty (a, b){
          for (var i=0;i<a.length;i++){
              if(a[i].property == b.property){
                   return i;
               }
          }
         return -1;
      }

      if (indexOfProperty(a,b) < 0 ) a.push(b);
        return a;
    },[]);

let myData = [{place:"here",name:"stuff"}, 
 {place:"there",name:"morestuff"},
 {place:"there",name:"morestuff"}];


let q = [...new Map(myData.map(obj => [JSON.stringify(obj), obj])).values()];

console.log(q)

ES6 및을 사용하는 하나의 라이너 new Map().

// assign things.thing to myData
let myData = things.thing;

[...new Map(myData.map(obj => [JSON.stringify(obj), obj])).values()];

세부:-

1. 이렇게 .map()데이터 목록 및 각 객체로 변환 [key, value]쌍 배열 (길이 = 2)의 첫 번째 요소 (키)가 될 stringified객체 및 제 (값)적인 버전 일 것object 자체.
2. 위에서 만든 배열 목록을 추가 new Map()하면 키가 stringified객체로 사용되며 동일한 키를 추가하면 이미 존재하는 키가 재정의됩니다.
3. 를 사용하면 .values()MapIterator에 Map의 모든 값이 제공됩니다 (obj 이 경우)
4. 마지막으로 spread ...연산자는 위 단계의 값으로 새 Array를 제공합니다.

마지막 항목 만 유지하려는 es6 솔루션이 있습니다. 이 솔루션은 기능적이고 에어 비앤비 스타일을 준수합니다.

const things = {
  thing: [
    { place: 'here', name: 'stuff' },
    { place: 'there', name: 'morestuff1' },
    { place: 'there', name: 'morestuff2' }, 
  ],
};

const removeDuplicates = (array, key) => {
  return array.reduce((arr, item) => {
    const removed = arr.filter(i => i[key] !== item[key]);
    return [...removed, item];
  }, []);
};

console.log(removeDuplicates(things.thing, 'place'));
// > [{ place: 'here', name: 'stuff' }, { place: 'there', name: 'morestuff2' }]

removeDuplicates ()는 객체 배열을 가져오고 id 속성을 기반으로 중복 객체없이 새 배열을 반환합니다.

const allTests = [
  {name: 'Test1', id: '1'}, 
  {name: 'Test3', id: '3'},
  {name: 'Test2', id: '2'},
  {name: 'Test2', id: '2'},
  {name: 'Test3', id: '3'}
];

function removeDuplicates(array) {
  let uniq = {};
  return array.filter(obj => !uniq[obj.id] && (uniq[obj.id] = true))
}

removeDuplicates(allTests);

예상되는 결과:

[
  {name: 'Test1', id: '1'}, 
  {name: 'Test3', id: '3'},
  {name: 'Test2', id: '2'}
];

먼저 변수 uniq의 값을 빈 객체로 설정합니다.

다음으로 객체 배열을 필터링합니다. Filter는 제공된 함수로 구현 된 테스트를 통과하는 모든 요소를 ​​사용하여 새 배열을 만듭니다.

return array.filter(obj => !uniq[obj.id] && (uniq[obj.id] = true));

위에서는 &&의 단락 기능을 사용합니다. &&의 왼쪽이 true로 평가되면 &&의 오른쪽에있는 값을 리턴합니다. 왼쪽이 거짓이면 &&의 왼쪽에있는 것을 반환합니다.

각 객체 (obj)에 대해 uniq에 obj.id라는 값의 속성이 있는지 확인합니다 (이 경우 첫 번째 반복에서는 속성 '1'을 확인합니다). 또는 거짓) 그래서 우리는! ! uniq [obj.id]에서 uniq에 id 속성이 이미 있으면 true를 반환하여 필터 함수에 해당 obj를 추가하지 말라고 false (!)로 평가합니다. 그러나 obj.id 속성을 찾지 못하면 false를 반환 한 다음 true (!)로 평가하고 &&의 오른쪽으로 모든 것을 반환합니다 (uniq [obj.id] = true). 이 값은 필터 메소드에 해당 obj를 리턴 된 배열에 추가하도록 지시하는 값이며, {1 : true} 특성을 uniq에 추가합니다. 이렇게하면 동일한 ID를 가진 다른 obj 인스턴스가 다시 추가되지 않습니다.

let data = [
  {
    'name': 'Amir',
    'surname': 'Rahnama'
  }, 
  {
    'name': 'Amir',
    'surname': 'Stevens'
  }
];
let non_duplicated_data = _.uniqBy(data, 'name');

나는의 조합을 생각 reduce과 JSON.stringify에 완벽하게 비교 개체 및 선택적으로 축적에없는 사람들을 추가하는 우아한 방법입니다.

JSON.stringify어레이에 많은 객체가 있고 대부분의 경우 복잡하지만 극한의 경우 성능 문제가 될 수 있음을 명심하십시오 .

var collection= [{a:1},{a:2},{a:1},{a:3}]

var filtered = collection.reduce((filtered, item) => {
  if( !filtered.some(filteredItem => JSON.stringify(filteredItem) == JSON.stringify(item)) )
    filtered.push(item)
  return filtered
}, [])

console.log(filtered)

동일하지만 덜 효율적인 다른 방법 :

collection.reduce((filtered, item) => 
  filtered.some(filteredItem => 
    JSON.stringify(filteredItem ) == JSON.stringify(item)) 
      ? filtered
      : [...filtered, item]
, [])

객체 배열에서 중복을 제거하는 ES6 방법을 계속 탐색합니다. thisArg인수를 설정 하여 적절한 대안 Array.prototype.filter을 new Set제공하십시오.

const things = [
  {place:"here",name:"stuff"},
  {place:"there",name:"morestuff"},
  {place:"there",name:"morestuff"}
];

const filtered = things.filter(function({place, name}) {

  const key =`${place}${name}`;

  return !this.has(key) && this.add(key);

}, new Set);

console.log(filtered);

그러나 어휘 범위에 바인딩 된 화살표 함수 () =>에서는 작동하지 않습니다 this.

es6 마술 한 줄에 ... 그것에서 읽을 수 있습니다!

// returns the union of two arrays where duplicate objects with the same 'prop' are removed
const removeDuplicatesWith = (a, b, prop) => a.filter(x => !b.find(y => x[prop] === y[prop]);

ES6 'reduce'및 'find'어레이 헬퍼 메소드를 사용한 간단한 솔루션

효율적이고 완벽하게 작동합니다!

"use strict";

var things = new Object();
things.thing = new Array();
things.thing.push({
    place: "here",
    name: "stuff"
});
things.thing.push({
    place: "there",
    name: "morestuff"
});
things.thing.push({
    place: "there",
    name: "morestuff"
});

// the logic is here

function removeDup(something) {
    return something.thing.reduce(function (prev, ele) {
        var found = prev.find(function (fele) {
            return ele.place === fele.place && ele.name === fele.name;
        });
        if (!found) {
            prev.push(ele);
        }
        return prev;
    }, []);
}
console.log(removeDup(things));

나중에 고유 한 배열을 정렬하는 데 신경 쓰지 않으면 효율적인 솔루션이 될 것입니다.

things.thing
  .sort(((a, b) => a.place < b.place)
  .filter((current, index, array) =>
    index === 0 || current.place !== array[index - 1].place)

이렇게하면 현재 요소와 배열의 이전 요소 만 비교하면됩니다. 필터링하기 전에 한 번 정렬하면 ( O(n*log(n))) 모든 배열 요소 ( O(n²)) 에 대해 전체 배열에서 중복을 검색하는 것보다 저렴 합니다.

이것은 객체 배열에서 이중성을 제거하는 간단한 방법입니다.

나는 데이터를 많이 다루고 있으며 이것은 나에게 유용하다.

const data = [{name: 'AAA'}, {name: 'AAA'}, {name: 'BBB'}, {name: 'AAA'}];
function removeDuplicity(datas){
    return datas.filter((item, index,arr)=>{
    const c = arr.map(item=> item.name);
    return  index === c.indexOf(item.name)
  })
}

console.log(removeDuplicity(data))

콘솔에 인쇄합니다 :

[[object Object] {
name: "AAA"
}, [object Object] {
name: "BBB"
}]

str =[
{"item_id":1},
{"item_id":2},
{"item_id":2}
]

obj =[]
for (x in str){
    if(check(str[x].item_id)){
        obj.push(str[x])
    }   
}
function check(id){
    flag=0
    for (y in obj){
        if(obj[y].item_id === id){
            flag =1
        }
    }
    if(flag ==0) return true
    else return false

}
console.log(obj)

str 은 객체의 배열입니다. 동일한 값을 가진 객체가 있습니다 (여기서는 작은 예에서는 item_id가 2 인 객체가 두 개 있습니다). check (id) 는 item_id가 같은 객체가 있는지 확인하는 함수입니다. 존재하는 경우 false를 리턴하고 그렇지 않으면 true를 리턴하십시오. 그 결과에 따라 객체를 새로운 배열로 밀어 넣습니다. obj 위 코드의 출력은 [{"item_id":1},{"item_id":2}]

Lodash 도서관에 대해 들어 보셨습니까? 논리를 코드에 적용하고 싶지 않고 최적화되고 신뢰할 수있는 이미 존재하는 코드를 사용하고 싶을 때이 유틸리티를 사용하는 것이 좋습니다.

이런 배열을 만들어보십시오

things.thing.push({place:"utopia",name:"unicorn"});
things.thing.push({place:"jade_palace",name:"po"});
things.thing.push({place:"jade_palace",name:"tigress"});
things.thing.push({place:"utopia",name:"flying_reindeer"});
things.thing.push({place:"panda_village",name:"po"});

하나의 속성을 고유하게 유지하려면 lodash 라이브러리를 사용하여 잘 수행 할 수 있습니다. 여기서 _.uniqBy를 사용할 수 있습니다

.uniqBy (배열, [iteratee = .identity])

이 메소드는 _.uniq (각 요소의 첫 번째 항목 만 유지되는 중복없는 버전의 배열을 리턴 함 )와 유사 합니다. 고유성이 계산됩니다.

예를 들어 'place'의 고유 한 속성을 가진 배열을 반환하려는 경우

_.uniqBy (things.thing, 'place')

마찬가지로 'name'으로 고유 한 속성을 원할 경우

_.uniqBy (things.thing, 'name')

도움이 되었기를 바랍니다.

건배!