JavaScript:동일한 속성 값을 공유하는 개체의 중복 제거

JavaScript:동일한 속성 값을 공유하는 개체의 중복 제거

특정 개체를 기준으로 자르고 싶은 배열이 있습니다.key:value이 특정 항목당 하나의 개체만 포함하는 배열을 만들고 싶습니다.key:value쌍. 복제의 어떤 개체가 새 배열에 복사되는지는 중요하지 않습니다.

예를 들어, 저는 다음 항목을 기준으로 트리밍하고 싶다.price의 특성arrayWithDuplicates다음 각 값 중 하나만 포함하는 새 어레이를 만듭니다.

var arrayWithDuplicates = [
  {"color":"red", 
    "size": "small",
    "custom": {
      "inStock": true,
      "price": 10
    }
  },
  {"color":"green", 
    "size": "small",
    "custom": {
      "inStock": true,
      "price": 30
    }
  },
  {"color":"blue", 
    "size": "medium",
    "custom": {
      "inStock": true,
      "price": 30
    }
  },
  {"color":"red", 
    "size": "large",
    "custom": {
      "inStock": true,
      "price": 20
    }
  }
];

다음과 같이 됩니다.

var trimmedArray = [
  {"color":"red", 
    "size": "small",
    "custom": {
      "inStock": true,
      "price": 10
    }
  },
  {"color":"green", 
    "size": "small",
    "custom": {
      "inStock": true,
      "price": 30
    }
  },
  {"color":"red", 
    "size": "large",
    "custom": {
      "inStock": true,
      "price": 20
    }
  }
];

루프스루하여 실행할 수 있는 JavaScript 또는 Angular 함수가 있습니까?

편집: 필터링할 속성이 다른 속성 내에 중첩되었습니다.

이 함수는 새 값을 반환하여 어레이에서 중복된 값을 제거합니다.

function removeDuplicatesBy(keyFn, array) {
    var mySet = new Set();
    return array.filter(function(x) {
        var key = keyFn(x), isNew = !mySet.has(key);
        if (isNew) mySet.add(key);
        return isNew;
    });
}

var values = [{color: "red"}, {color: "blue"}, {color: "red", number: 2}];
var withoutDuplicates = removeDuplicatesBy(x => x.color, values);
console.log(withoutDuplicates); // [{"color": "red"}, {"color": "blue"}]

그래서 이렇게 쓸 수 있어요.

var arr = removeDuplicatesBy(x => x.custom.price, yourArrayWithDuplicates);

Angular에 내장된 기능은 없다고 생각합니다만, 만드는 것은 어렵지 않습니다.

function removeDuplicates(originalArray, objKey) {
  var trimmedArray = [];
  var values = [];
  var value;

  for(var i = 0; i < originalArray.length; i++) {
    value = originalArray[i][objKey];

    if(values.indexOf(value) === -1) {
      trimmedArray.push(originalArray[i]);
      values.push(value);
    }
  }

  return trimmedArray;

}

사용방법:

removeDuplicates(arrayWithDuplicates, 'size');

반품:

[
    {
        "color": "red",
        "size": "small"
    },
    {
        "color": "blue",
        "size": "medium"
    },
    {
        "color": "red",
        "size": "large"
    }
]

그리고.

removeDuplicates(arrayWithDuplicates, 'color');

반품:

[
    {
        "color": "red",
        "size": "small"
    },
    {
        "color": "green",
        "size": "small"
    },
    {
        "color": "blue",
        "size": "medium"
    }
]

사용하다Array.filter()를 사용하여 값을 추적합니다.Object값이 이미 해시에 포함되어 있는 모든 항목을 필터링합니다.

function trim(arr, key) {
    var values = {};
    return arr.filter(function(item){
        var val = item[key];
        var exists = values[val];
        values[val] = true;
        return !exists;
    });
}

이 경우 밑줄을 사용할 수 있습니다.

//by size:
var uSize = _.uniqBy(arrayWithDuplicates, function(p){ return p.size; });

//by custom.price;
var uPrice = _.uniqBy(arrayWithDuplicates, function(p){ return p.custom.price; });

lodash를 사용하여 중복 개체를 제거할 수 있습니다.

 import * as _ from 'lodash';
  _.uniqBy(data, 'id');

여기 있습니다.id'는 고유 식별자입니다.

다음 기능을 사용해 보십시오.

function trim(items){
    const ids = [];
    return items.filter(item => ids.includes(item.id) ? false : ids.push(item.id));
}

사용.lodash쉽게 걸러낼 수 있다

첫 번째 파라미터는 어레이가 되고 두 번째 파라미터는 중복되는 필드가 됩니다.

_.uniqBy(arrayWithDuplicates, 'color')

고유한 값을 가진 어레이가 반환됩니다.

가장 뛰어난 퍼포먼스는 아니지만 심플한 솔루션:

var unique = [];
duplicates.forEach(function(d) {
    var found = false;
    unique.forEach(function(u) {
        if(u.key == d.key) {
            found = true;
        }
    });
    if(!found) {
        unique.push(d);
    }
});

for (let i = 0; i < arrayWithDuplicates.length; i++) {
     for (let j = i + 1; j < arrayWithDuplicates.length; j++) {
       if (arrayWithDuplicates[i].name === students[j].name) {
          arrayWithDuplicates.splice(i, 1);
       }
     }
    }

this will work perfectly...and this will delete first repeated array.
To delete last repeated array we only have to change
 arrayWithDuplicates.splice(i, 1) ; into
 arrayWithDuplicates.splice(j, 1);

즉, 사용자가 여러 개체를 처리할 때 이 기능을 수행할 수 있는 기능은 없습니다.또한 중복된 개체를 중복으로 삭제하는 규칙도 없습니다.

이 예에서는, 다음의 것을 삭제합니다.size: small그러나 루프를 사용하여 이 기능을 구현하려면 어레이를 루프할 때 첫 번째 기능을 포함하고 마지막 기능을 제외해야 합니다.

lodash와 같은 라이브러리를 살펴보고 원하는 동작을 얻기 위해 API 메서드를 조합한 함수를 만드는 것이 매우 가치가 있을 수 있습니다.

다음은 기본 어레이와 필터 식을 사용하여 반환 결과에 연결되기 전에 새 항목이 중복으로 간주되는지 여부를 확인할 수 있는 가능한 솔루션입니다.

var arrayWithDuplicates = [
    {"color":"red", "size": "small"},
    {"color":"green", "size": "small"},
    {"color":"blue", "size": "medium"},
    {"color":"red", "size": "large"}
];

var reduce = function(arr, prop) {
  var result = [],
      filterVal,
      filters,
      filterByVal = function(n) {
          if (n[prop] === filterVal) return true;
      };
  for (var i = 0; i < arr.length; i++) {
      filterVal = arr[i][prop];
      filters   = result.filter(filterByVal);
      if (filters.length === 0) result.push(arr[i]);
  }
  return result;
};

console.info(reduce(arrayWithDuplicates, 'color'));

여기서 어레이 필터링에 관한 자료를 참조할 수 있습니다.삭제할 항목에 대한 프리퍼런스를 제공해야 할 경우 반환값을 추가하기 전에 추가 속성을 체크하는 추가 파라미터와 로직을 정의할 수 있습니다.

도움이 됐으면 좋겠네요!

여기 타이프 스크립트 방법이 있습니다.

    public removeDuplicates(originalArray:any[], prop) {
    let newArray = [];
    let lookupObject = {};

    originalArray.forEach((item, index) => {
        lookupObject[originalArray[index][prop]] = originalArray[index];
    });

    Object.keys(lookupObject).forEach(element => {
        newArray.push(lookupObject[element]);
    });
    return newArray;
}

그리고.

let output = this.removeDuplicates(yourArray,'color');

이것은 Yvemancera의 솔루션에 근거한 또 하나의 「기능」에 지나지 않습니다(자신의 솔루션을 손질하기 시작한 후).또, 현재는 IE 11만을 사용할 수 있기 때문에, ES5는 한정되어 있습니다.

var newArray = RemoveDuplicates(myArray,'Role', 2);

function RemoveDuplicates(array, objKey, rtnType) {
var list = [], values = [], value;
for (var i = 0; i < array.length; i++) {
    value = array[i][objKey];
    if(values.indexOf(value) === -1){
        list.push(array[i]);
        values.push(value);
        }
    }
    if(rtnType == 1)
        return list;
    return values;
};

단일 개체 속성 값을 기준으로 개체를 필터링할 때 모든 어레이가 아닌 대부분의 어레이에서 이 기능이 작동하기를 바랍니다.

언급URL : https://stackoverflow.com/questions/32238602/javascript-remove-duplicates-of-objects-sharing-same-property-value