Angenommen, ich habe ein Array wie dieses: [1, 1, 2, 2, 3]
Ich möchte die Duplikate erhalten, die sich in diesem Fall befinden: [1, 2]
Unterstützt lodash das? Ich möchte es auf dem kürzesten Weg machen.
Sie können dies verwenden:
_.filter(arr, (val, i, iteratee) => _.includes(iteratee, val, i + 1));
Wenn eine Zahl mehr als zweimal in Ihrem Array erscheint, können Sie immer _.uniq
verwenden.
Eine andere Möglichkeit ist, nach eindeutigen Elementen zu gruppieren und die Gruppenschlüssel mit mehr als einem Element zurückzugeben
_([1, 1, 2, 2, 3]).groupBy().pickBy(x => x.length > 1).keys().value()
var array = [1, 1, 2, 2, 3];
var groupped = _.groupBy(array, function (n) {return n});
var result = _.uniq(_.flatten(_.filter(groupped, function (n) {return n.length > 1})));
Dies funktioniert auch für unsortierte Arrays.
Wie wäre es mit countBy()
gefolgt von reduce()
?
const items = [1,1,2,3,3,3,4,5,6,7,7];
const dup = _(items)
.countBy()
.reduce((acc, val, key) => val > 1 ? acc.concat(key) : acc, [])
.map(_.toNumber)
console.log(dup);
// [1, 3, 7]
Ein anderer Weg, aber Filter und ecmaScript 2015 (ES6) verwenden
var array = [1, 1, 2, 2, 3];
_.filter(array, v =>
_.filter(array, v1 => v1 === v).length > 1);
//→ [1, 1, 2, 2]
hier ist meine, es6-artige, deps-freie Antwort. mit Filter statt Reduzierstück
// this checks if elements of one list contains elements of second list
// example code
[0,1,2,3,8,9].filter(item => [3,4,5,6,7].indexOf(item) > -1)
// function
const contains = (listA, listB) => listA.filter(item => listB.indexOf(item) > -1)
contains([0,1,2,3], [1,2,3,4]) // => [1, 2, 3]
// only for bool
const hasDuplicates = (listA, listB) => !!contains(listA, listB).length
edit: hmm mein schlechtes ist: Ich habe q als allgemeine Frage gelesen, aber das ist strikt für lodash, aber mein Punkt ist - du brauchst kein lodash hier :)
Nun, Sie können diesen Code verwenden, der viel schneller ist, da er eine Komplexität von O(n) hat und Lodash nicht verwendet.
[1, 1, 2, 2, 3]
.reduce((agg,col) => {
agg.filter[col] = agg.filter[col]? agg.dup.Push(col): 2;
return agg
},
{filter:{},dup:[]})
.dup;
//result:[1,2]
Hier ist eine andere prägnante Lösung:
let data = [1, 1, 2, 2, 3]
let result = _.uniq(_.filter(data, (v, i, a) => a.indexOf(v) !== i))
console.log(result)
<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.min.js"></script>
_.uniq
kümmert sich um die Dubs, die _.filter
kommt zurück mit.
Gleich mit ES6 und Set :
let data = [1, 1, 2, 2, 3]
let result = new Set(data.filter((v, i, a) => a.indexOf(v) !== i))
console.log(Array.from(result))
Hoffnung unten Lösung hilft Ihnen und es wird unter allen Bedingungen nützlich sein
hasDataExist(listObj, key, value): boolean {
return _.find(listObj, function(o) { return _.get(o, key) == value }) != undefined;
}
let duplcateIndex = this.service.hasDataExist(this.list, 'xyz', value);
Sie müssen lodash
nicht verwenden, sondern können folgenden Code verwenden:
function getDuplicates(array, key) {
return array.filter(e1=>{
if(array.filter(e2=>{
return e1[key] === e2[key];
}).length > 1) {
return e1;
}
})
}