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]);
わかりました、私はそれがトリックをするべきであると思います。それをチェックしなさい、Travis。
EDITplace（旧id）プロパティを正しく参照するようにコードを編集しました。
es6マジックでいかがですか？
things.thing = things.thing.filter((thing, index, self) =>
index === self.findIndex((t) => (
t.place === thing.place && t.name === thing.name
))
)
より一般的な解決策は次のようになります。
const uniqueArray = things.thing.filter((thing,index) => {
return index === things.thing.findIndex(obj => {
return JSON.stringify(obj) === JSON.stringify(thing);
});
});
アンダースコアや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');
UPDATE：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"}]
セットを使ったワンライナー
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)説明：
new Set(myData.map(JSON.stringify))は、文字列化されたmyData要素を使用して Set オブジェクトを作成します。- オブジェクトを設定すると、すべての要素が確実に一意になります。
- それから、Array.fromを使って、作成したセットの要素に基づいて配列を作成します。
- 最後に、JSON.parseを使用して文字列化された要素をオブジェクトに変換します。
すべての加算が終わるまで重複を排除するのを待つことができる場合、典型的なアプローチは最初に配列をソートしてから重複を排除することです。並べ替えを行うと、各要素ごとに配列をスキャンするというN * Nのアプローチが回避されます。
「重複排除」関数は通常一意またはuniqと呼ばれます。いくつかの既存の実装は、２つのステップを組み合わせることができ、例えば、 prototype's 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;
}
オブジェクトの1つのフィールドのみで比較する必要がある場合は、これをArray反復メソッドを使用して実行する別の方法があります。
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');
更新
私は今質問を正しく読みました。これはこれを行う一般的な方法です。配列の2つの要素が等しいと見なされるかどうかをテストする関数を渡します。この場合、比較対象の2つのオブジェクトのnameおよびplaceプロパティの値を比較します。
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);
片ライナーはこちら
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}),{})))最も簡単な方法は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)リストにもう1つ追加します。 ES6とArray.reduceをArray.findと共に使用する。
この例では、guidプロパティに基づいてオブジェクトをフィルタリングしています。
let filtered = array.reduce((accumulator, current) => {
if (! accumulator.find(({guid}) => guid === current.guid)) {
accumulator.Push(current);
}
return accumulator;
}, []);
これを拡張してプロパティの選択を可能にし、それを1つのライナーに圧縮します。
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')
こんにちは、子供たち、このことを粉砕しましょう、なぜ私たちはしないのですか？
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'}];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"
}
]
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 }]
もう1つのオプションは、各オブジェクトに対して選択したプロパティの値を比較し、これをreduce関数でラップするカスタム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;
},[]);
ES6を1行で使用すると、キーごとにオブジェクトの一意のリストを取得できます。
const unique = [...new Map(arr.map(item => [item[key], item])).values()]
関数に入れて、次の例のように使用できます。
const arr = [
{place: "here", name: "stuff"},
{place: "there", name: "morestuff"},
{place: "a", name: "morestuff"},
{place: "b", name: "morestuff"},
{place: "c", name: "morestuff"},
{place: "here", name: "lol"},
{place: "there", name: "test"}
]
function getUniqueListBy(arr, key) {
return [...new Map(arr.map(item => [item[key], item])).values()]
}
const arr1 = getUniqueListBy(arr, 'place')
console.log(arr1)
const arr2 = getUniqueListBy(arr, 'name')
console.log(arr2)let data = [
{
'name': 'Amir',
'surname': 'Rahnama'
},
{
'name': 'Amir',
'surname': 'Stevens'
}
];
let non_duplicated_data = _.uniqBy(data, 'name');
これはes6の解決策で、最後のアイテムだけを残しておきたいものです。このソリューションは機能的でAirbnbスタイルに準拠しています。
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' }]
TypeScriptソリューション
これにより、重複したオブジェクトが削除され、オブジェクトの種類も保持されます。
function removeDuplicateObjects(array: any[]) {
return [...new Set(array.map(s => JSON.stringify(s)))]
.map(s => JSON.parse(s));
}
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）について、obj.idの値という名前のプロパティをuniqでチェックします（この場合、最初の繰り返しでは、プロパティ '1'をチェックします）。それが私たちが使う理由です！ in！uniq [obj.id] uniqがidプロパティをすでに持っている場合は、trueを返します。これはfalse（！）に評価され、フィルタ関数にそのobjを追加しないように指示します。ただし、obj.idプロパティが見つからない場合は、falseが返され、その結果、true（！）と評価され、&&の右側にあるすべての値が返されます（または、uniq [obj.id] = true）。これは真の値で、返された配列にそのobjを追加するようにフィルターメソッドに指示します。また、uniqにプロパティー{1：true}を追加します。これにより、同じIDを持つ他のobjインスタンスが再び追加されないようにします。
1つの最も短いライナー
配列内で一意のIDを見つけます。
arr.filter((v,i,a)=>a.findIndex((t)=>(t.id === v.id))===i)
複数のプロパティ（idおよびname）によって一意
arr.filter((v,i,a)=>a.findIndex((t)=>(t.id === v.id && t.name===v.name))===i)
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()];
詳細： -
- データリストに対して
.map()を実行し、個々のオブジェクトを[key, value]ペア配列（length = 2）に変換すると、最初の要素（key）はstringifiedバージョンのオブジェクトになり、2番目の（value）はobjectになります。 - 上記で作成した配列リストを
new Map()に追加すると、そのキーはstringifiedオブジェクトになり、同じキーを追加すると、既存のキーが上書きされます。 .values()を使用すると、MapIteratorにMap内のすべての値が与えられます（この場合はobj）。- 最後に、
spread ...演算子を使用して、上記の手順の値を使用して新しいArrayを作成します。
オブジェクトの配列から重複を削除するためのES6の方法の探求を継続します。 Array.prototype.filter のthisArg引数を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は字句のスコープにバインドされているため、矢印関数() =>では機能しません。
プロパティのリストを指定したくない場合は、
function removeDuplicates(myArr) {
var props = Object.keys(myArr[0])
return myArr.filter((item, index, self) =>
index === self.findIndex((t) => (
props.every(prop => {
return t[prop] === item[prop]
})
))
)
}
OBS！ IE11とは互換性がありません。
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"});
1つの属性を一意にしたい場合は、lodashライブラリを使用してそれを行うことができます。ここでは、_。uniqByを使用できます。
。uniqBy（array、[iteratee =。identity]）
このメソッドは_。uniq（各要素の最初の出現のみが保持される配列の重複のないバージョンを返します）と似ていますが、一意性が計算される基準を生成するための配列。
したがって、たとえば、 'place'という一意の属性を持つ配列を返したい場合は、
_.uniqBy（things.thing、 'place'）
同様に、 'name'としてユニークな属性が欲しいなら
_.uniqBy（things.thing、 '名前'）
お役に立てれば。
乾杯！
あとでソートされた独自の配列を気にしないのであれば、これが効率的な解決策になります。
things.thing
.sort(((a, b) => a.place < b.place)
.filter((current, index, array) =>
index === 0 || current.place !== array[index - 1].place)
この方法では、現在の要素を配列内の前の要素と比較するだけで済みます。フィルタ処理の前に1回ソート（O(n*log(n))）すると、すべての配列要素（O(n²)）について配列全体で重複を検索するよりも安価です。
1つのプロパティに基づいて重複を厳密に削除する場合は、reduceプロパティに基づいてオブジェクトを配列にplaceすることができます。オブジェクトには一意のキーしか持てないため、values配列に戻るには：
const unique = Object.values(things.thing.reduce((o, t) => ({ ...o, [t.place]: t }), {}))
特定のフィールドに基づいて配列から重複したオブジェクトを頻繁に削除する必要がある場合は、プロジェクトのどこからでもインポートできるdistinct(array, predicate)関数を作成することをお勧めします。これは次のようになります
const things = [{place:"here",name:"stuff"}, ...];
const distinctThings = distinct(things, thing => thing.place);
明瞭な関数は、上の多くの良い答えで与えられた実装のどれでも使うことができます。最も簡単なものはfindIndexを使います：
const distinct = (items, predicate) => items.filter((uniqueItem, index) =>
items.findIndex(item =>
predicate(item) === predicate(uniqueItem)) === index);
Object.values（） を Array.prototype.reduce（） と組み合わせて使用できます。
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 result = Object.values(things.thing.reduce((a, c) => (a[`${c.place}${c.name}`] = c, a), {}));
console.log(result);.as-console-wrapper { max-height: 100% !important; top: 0; }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はオブジェクトの配列です。同じ値を持つオブジェクトが存在します（この小さな例では、2と同じitem_idを持つオブジェクトが2つあります）。 check（id）は、同じitem_idを持つオブジェクトが存在するかどうかを調べる関数です。存在する場合はfalse、それ以外の場合はtrueを返します。その結果に従って、オブジェクトを新しい配列にプッシュしてくださいobj上記のコードの出力は[{"item_id":1},{"item_id":2}]です。
任意のオブジェクトの配列に対する総称
/**
* Remove duplicated values without losing information
*/
const removeValues = (items, key) => {
let tmp = {};
items.forEach(item => {
tmp[item[key]] = (!tmp[item[key]]) ? item : Object.assign(tmp[item[key]], item);
});
items = [];
Object.keys(tmp).forEach(key => items.Push(tmp[key]));
return items;
}
それが誰にでも役立つことを願っています。
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));
配列オブジェクトを文字列に変換して比較できるようにし、その文字列をSetに追加して、比較可能な重複が自動的に削除された後、各文字列をオブジェクトに戻すことができます。
それは他の答えほど高性能ではないかもしれませんが、それは読解可能です。
const things = {};
things.thing = [];
things.thing.Push({place:"here",name:"stuff"});
things.thing.Push({place:"there",name:"morestuff"});
things.thing.Push({place:"there",name:"morestuff"});
const uniqueArray = (arr) => {
const stringifiedArray = arr.map((item) => JSON.stringify(item));
const set = new Set(stringifiedArray);
return Array.from(set).map((item) => JSON.parse(item));
}
const uniqueThings = uniqueArray(things.thing);
console.log(uniqueThings);
ここで私の解決策は、それはobject.propに基づいて重複を検索し、それが重複したオブジェクトを見つけるときそれはarray1のreplaces its valueですwith array2 value
function mergeSecondArrayIntoFirstArrayByProperty(array1, array2) {
for (var i = 0; i < array2.length; i++) {
var found = false;
for (var j = 0; j < array1.length; j++) {
if (array2[i].prop === array1[j].prop) { // if item exist in array1
array1[j] = array2[i]; // replace it in array1 with array2 value
found = true;
}
}
if (!found) // if item in array2 not found in array1, add it to array1
array1.Push(array2[i]);
}
return array1;
}
function filterDuplicateQueries(queries){
let uniqueQueries = [];
queries.forEach((l, i)=>{
let alreadyExist = false;
if(uniqueQueries.length>0){
uniqueQueries.forEach((k, j)=>{
if(k.query == l.query){
alreadyExist = true;
}
});
}
if(!alreadyExist){
uniqueQueries.Push(l)
}
});
- この解決策はあらゆる種類のオブジェクトに対して一般的であり、配列内の
Objectのすべての(key, value)をチェックします。 - ハッシュテーブルとして一時オブジェクトを使用して、
Object全体がキーとして存在したことがあるかどうかを確認します。 Objectの文字列表現が見つかった場合、その項目は配列から削除されます。
var arrOfDup = [{'id':123, 'name':'name', 'desc':'some desc'},
{'id':125, 'name':'another name', 'desc':'another desc'},
{'id':123, 'name':'name', 'desc':'some desc'},
{'id':125, 'name':'another name', 'desc':'another desc'},
{'id':125, 'name':'another name', 'desc':'another desc'}];
function removeDupes(dupeArray){
let temp = {};
let tempArray = JSON.parse(JSON.stringify(dupeArray));
dupeArray.forEach((item, pos) => {
if(temp[JSON.stringify(item)]){
tempArray.pop();
}else{
temp[JSON.stringify(item)] = item;
}
});
return tempArray;
}
arrOfDup = removeDupes(arrOfDup);
arrOfDup.forEach((item, pos) => {
console.log(`item in array at position ${pos} is ${JSON.stringify(item)}`);
});const uniqueElements = (arr, fn) => arr.reduce((acc, v) => {
if (!acc.some(x => fn(v, x))) { acc.Push(v); }
return acc;
}, []);
const stuff = [
{place:"here",name:"stuff"},
{place:"there",name:"morestuff"},
{place:"there",name:"morestuff"},
];
const unique = uniqueElements(stuff, (a,b) => a.place === b.place && a.name === b.name );
//console.log( unique );
[{
"place": "here",
"name": "stuff"
},
{
"place": "there",
"name": "morestuff"
}]
一行で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]);
これはとても簡単なJavaScriptの新しいフィルタ機能を使った解決策です。このような配列があるとしましょう。
var duplicatesArray = ['AKASH','AKASH','NAVIN','HARISH','NAVIN','HARISH','AKASH','MANJULIKA','AKASH','TAPASWENI','MANJULIKA','HARISH','TAPASWENI','AKASH','MANISH','HARISH','TAPASWENI','MANJULIKA','MANISH'];
Filter関数を使用すると、配列内の各要素に対して1回コールバック関数を使用して、新しい配列を作成できます。だからあなたはこのようなユニークな配列を設定することができます。
var uniqueArray = duplicatesArray.filter(function(elem, pos) {return duplicatesArray.indexOf(elem) == pos;});
このシナリオでは、あなたのユニークな配列は重複した配列の全ての値を通り抜けます。 elem変数は、配列内の要素の値（mike、james、james、alex）を表し、位置は、配列内の0から始まる位置（0、1、2、3 ...）、およびduplicatesArrayです。 indexOf（elem）値は、元の配列内でその要素が最初に出現する位置のインデックスです。つまり、要素 'james'は重複しているため、duplicatesArray内のすべての要素をループ処理してそれらをuniqueArrayにプッシュすると、初めてjamesにヒットしたときに、 "pos"の値は1になり、indexOf（elem）同様に1は1なので、JamesはuniqueArrayにプッシュされます。 2回目のJamesのヒット時には、「pos」の値は2であり、indexOf（elem）はまだ1のままです（配列要素の最初のインスタンスしか検出されないため）ので、複製はプッシュされません。そのため、uniqueArrayには一意の値のみが含まれています。
これが上記の関数のデモです。 上記の関数の例はここをクリック
これは重複の数を見つけ、あなたのデータオブジェクトからそれを簡単に削除するための別のテクニックです。 「dupsCount」は重複ファイル数です。まずデータをソートしてから削除してください。それはあなたに最速の重複除去を与えるでしょう。
dataArray.sort(function (a, b) {
var textA = a.name.toUpperCase();
var textB = b.name.toUpperCase();
return (textA < textB) ? -1 : (textA > textB) ? 1 : 0;
});
for (var i = 0; i < dataArray.length - 1; ) {
if (dataArray[i].name == dataArray[i + 1].name) {
dupsCount++;
dataArray.splice(i, 1);
} else {
i++;
}
}
もう1つの方法は、reduce関数を使用してアキュムレータになる新しい配列を用意することです。アキュムレータ配列に同じ名前のthingがすでに存在する場合は、そこに追加しないでください。
let list = things.thing;
list = list.reduce((accumulator, thing) => {
if (!accumulator.filter((duplicate) => thing.name === duplicate.name)[0]) {
accumulator.Push(thing);
}
return accumulator;
}, []);
thing.things = list;
Internet Explorer 11と互換性のあるNice、読みやすいes6ソリューション（私はbabelを使って矢印機能を扱う）が見つからなかったので、この答えを加えています。問題はIE11にpolyfillなしのMap.values()またはSet.values()がないことです。同じ理由で、最初の要素を取得するためにfilter()[0]ではなくfind()を使用しました。
これはどうですか：
function dedupe(arr, compFn){
let res = [];
if (!compFn) compFn = (a, b) => { return a === b };
arr.map(a => {if(!res.find(b => compFn(a, b))) res.Push(a)});
return res;
}
これは、オブジェクトの配列から重複を除去するための簡単な方法です。
私はデータをたくさん扱うので、これは私にとって役に立ちます。
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"
}]
これにより、キーを渡さずに重複オブジェクトが削除されます。
uniqueArray = a => [...new Set(a.map(o => JSON.stringify(o)))].map(s => JSON.parse(s));
var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }];
var unique = uniqueArray(objects);
console.log('Original Object',objects);
console.log('Unique',unique);uniqueArray = a => [...new Set(a.map(o => JSON.stringify(o)))].map(s => JSON.parse(s));
var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }];
var unique = uniqueArray(objects);
console.log(objects);
console.log(unique);
オブジェクト内の複数のプロパティに基づく一意の配列が必要な場合は、これをmapとオブジェクトのプロパティの組み合わせで実行できます。
var hash = array.map(function(element){
var string = ''
for (var key in element){
string += element[key]
}
return string
})
array = array.filter(function(element, index){
var string = ''
for (var key in element){
string += element[key]
}
return hash.indexOf(string) == index
})
var testArray= ['a','b','c','d','e','b','c','d'];
function removeDuplicatesFromArray(arr){
var obj={};
var uniqueArr=[];
for(var i=0;i<arr.length;i++){
if(!obj.hasOwnProperty(arr[i])){
obj[arr[i]] = arr[i];
uniqueArr.Push(arr[i]);
}
}
return uniqueArr;
}
var newArr = removeDuplicatesFromArray(testArray);
console.log(newArr);
Output:- [ 'a', 'b', 'c', 'd', 'e' ]
何かを単純にする。空想はいいのですが、読めないコードは役に立ちません。楽しい ：-）
var a = [
{
executiveId: 6873702,
largePhotoCircle: null,
name: "John A. Cuomo",
photoURL: null,
primaryCompany: "VSE CORP",
primaryTitle: "Chief Executive Officer, President and Director"
},
{
executiveId: 6873702,
largePhotoCircle: null,
name: "John A. Cuomo",
photoURL: null,
primaryCompany: "VSE CORP",
primaryTitle: "Chief Executive Officer, President and Director"
},
{
executiveId: 6873703,
largePhotoCircle: null,
name: "John A. Cuomo",
photoURL: null,
primaryCompany: "VSE CORP",
primaryTitle: "Chief Executive Officer, President and Director",
}
];
function filterDuplicate(myArr, prop) {
// Format - (1)
// return myArr.filter((obj, pos, arr) => {
// return arr.map(mapObj => mapObj[prop]).indexOf(obj[prop]) === pos;
// });
// Format - (2)
var res = {};
var resArr = [];
for (var elem of myArr) {
res[elem.executiveId] = elem;
}
for (let [index, elem] of Object.entries(res)) {
resArr.Push(elem);
}
return resArr;
}
let finalRes = filterDuplicate(a,"executiveId");
console.log("finalResults : ",finalRes);