如何返回数组中的重复字符串数组？

Question

我需要一个函数，它接受一个数组并返回一个包含所有重复项的数组。如果可能，我宁愿使用underscore。

给出的数组：

[ 
    "apple", 
    "apple", 
    "pear", 
    "pear", 
    "kiwi", 
    "peach" 
] 

我需要返回数组

[ 
    "apple", 
    "pear" 
] 

许多我发现会返回一个布尔值，而不是重复的阵列的方法。

例如

var fruits = ["apple","apple"]; 
var uniq_fruits = _.uniq(fruits); 
var duplicates_exist = (fruits.length == uniq_fruits.length); 

Answer 1

你可以使用_.countBy来获取单词频率，然后用_.reduce收集频率大于1的值：

function collect_dups(a, n, word) { 
    if(n > 1) 
     a.push(word); 
    return a; 
} 
var dups = _(words).chain() 
        .countBy() 
        .reduce(collect_dups, []) 
        .value(); 

演示：http://jsfiddle.net/ambiguous/gKmfh/1/

Answer 2

给你有一个简单的字符串一个级别阵列，我建议第一，然后依次通过它数组排序试图当前项目与下一个比较。 事情是这样的：

var fruit = [ 
    "apple", 
    "apple", 
    "apple", 
    "pear", 
    "pear", 
    "cantalope" 
]; 

var common = function(array){ 
    var mySortedArray = array.sort(); 
    var myResultArray = []; 

    for (var i = 0; i < mySortedArray.length - 1; i++) 
     if ((mySortedArray[i + 1] == mySortedArray[i]) && 
     (mySortedArray[i] != myResultArray[myResultArray.length-1])) 
     myResultArray.push(mySortedArray[i]); 

    return myResultArray; 
}; 

alert(common(fruit)); 

Answer 3

打开你的名单分成一个地图，然后打开地图到列表中。

var fruits = ["apple", // ... ]; 

function fruitCounter(countMap, fruit) { 
    if (countMap[fruit] == null) 
    countMap[fruit] = 1; 
    else 
    countMap[fruit]++; 
    return countMap; 
} 

function dupFinder(dupList, count, fruit) { 
    if (count > 1) 
    dupList.push(fruit); 
    return dupList; 
} 

var dups = _.reduce(_.reduce(fruits, fruitCounter, {}), dupFinder, []); 

这是排序的不幸的是，没有什么真的很喜欢“过滤器”为对象的属性的，但它也不是太糟糕了“减少”。

编辑 —从别人更好的突出了一个评论，而我指出，内部“减少”可以通过一个简单的“countBy”所取代：

var dups = _.reduce(_.countBy(fruits, function(f) { return f; }), dupFinder, []); 

Answer 4

var common = function(array){ 

    var tally = function(array){ 
     var make_object = {}; 
     _.each(array, function(item){ 
      make_object[item] = (typeof make_object[item] == "undefined") ? 1 : make_object[item] + 1; 
     }); 
     return make_object;   
    }(array); 

    var duplicates = function(obj){ 
     var duplicates = []; 
     _.each(obj, function(value, key){ 
      if(value > 1){ 
       duplicates.push(key); 
      } 
     }); 
     return duplicates; 
    }(tally); 

    return duplicates; 

}; 

Answer 5

这个想法非常简单。将项目按其值分组，然后查找哪个组具有多个项目。最后从每个组中选择一个项目。

lst = [ "apple", "apple", "pear", "pear", "kiwi", "peach"]; 
var result = _.chain(lst) 
    .groupBy(function (i) { return i; }) 
    .filter(function (v, k) { return v.length > 1; }) 
    .map(function(v){return v[0]; }) 
    .value(); 

>>["apple", "pear"] 

Answer 6

其中ARR是你的输入，你只是检查，看看是否该元素是obj对象上的关键 - 如果它是，它传递到输出数组和RELOOP，否则此键添加到对象：

function findDupes(arr) { 
    var obj = {}, newArr = []; 
    for (var i = 0, l = arr.length; i < l; i++) { 
    if (obj[arr[i]]) { newArr.push(arr[i]); continue; } 
    obj[arr[i]] = true; 
    } 
    return newArr; 
} 

var dupes = findDupes（arr）;

Answer 7

我从这个函数开始：https://stackoverflow.com/a/840849/1636522

function getDuplicates(arr) { 
    var i, 
     len = arr.length, 
     out = [], 
     obj = {}; 
    for (i = 0; i < len; i++) { 
     switch (obj[arr[i]]) { 
      case undefined: obj[arr[i]] = 1; break; 
      case 1: obj[arr[i]] = 2; out.push(arr[i]); break; 
     } 
    } 
    return out; 
}