Javascript -从数组中删除唯一元素

对于ES6，您可以使用Array#map并使用Array#forEach计算值。

稍后使用Array#filter并检查计数

如果大于1，返回true(包含结果集)，否则返回false(不包含结果集)。

function getNotUnique(array) {
    var map = new Map();
    array.forEach(a => map.set(a, (map.get(a) || 0) + 1));
    return array.filter(a => map.get(a) > 1);
}
console.log(getNotUnique([1, 2, 2, 4, 4]));
console.log(getNotUnique([1, 2, 3] ));

下面是简单易懂的从数组中删除唯一元素的示例。

function removeUnique(arr) {
	var newArr = [];
	for (var i = 0; i < arr.length; i++) {
		var count = 0;
		for (var j = 0; j < arr.length; j++) {
			if (arr[j] == arr[i]) {
				count++;
			}
		}
		if (count >= 2) {
			newArr.push(arr[i]);
		}
	}
    return newArr;
}
console.log(removeUnique([1, 2, 2, 4, 4]));

应该可以了;

var arr = [1, 2, 2, 4, 4],
    unq = arr.map((e,i,a) => a.filter(f => f === e ).length)
             .reduce((p,c,i) => c === 1 ? p : p.concat(arr[i]) ,[]);
console.log(unq);

然而，转念一想，下面的代码可能更具可读性和效率。我们实际上是在使用一种罕见的情况，在这种情况下，我们可以通过短路来利用JS中的惰性。

var r = [1,2,2,4,4].filter((e,i,a) => a.lastIndexOf(e) != i || a.indexOf(e) != i);
console.log(r);

所以a.indexOf(e) != i部分只对唯一元素和最后遇到的非唯一元素运行。酷。

下面的代码返回所有重复的值

const getDuplicatedVals = (data) => data.filter( (x) => data.indexOf(x) != data.lastIndexOf(x))

下面是一个实现(使用https://stackoverflow.com/a/5668029/4202031)

function removeUnique(arr) {
  var counts = {}
  for(var i = 0; i< arr.length; i++) {
      var num = arr[i]
      counts[num] = counts[num] ? counts[num]+1 : 1
  }
  var result = []
  for(var key in counts) {
    if(Object.prototype.hasOwnProperty.call(counts, key) && counts[key] > 1 {
      result.push(key)
    }
  }
  return result
}

var arr = [1, 2, 3]
var arr2 = [1, 1, 2, 2, 4, 6, 4]
console.log(removeUnique(arr)) // []
console.log(removeUnique(arr2)) // [ '1', '2', '4' ]

你可以做这样的事情(严格使用数组):

var arr = [1,2,3,4,4];
var temp = [];
var to_keep = [];
for(var x = 0; x < arr.length; x++){
  if(temp.indexOf(arr[x]) > -1) {
    if(to_keep.indexOf(arr[x]) == -1)
      to_keep.push(arr[x]);
  } else if(temp.indexOf(arr[x]) == -1) temp.push(arr[x]);
}
for(var y = 0; y < arr.length; y++){
  if(to_keep.indexOf(arr[y]) == -1){
    arr.splice(y,1);
    y--;
  }
}
// arr = [4,4];

var arr = [1, 2, 2, 4, 4]
var dict_with_count = {}
for (var i=0; i<arr.length; i++){
   dict_with_count[arr[i]] = 0
}
for (var i=0; i<arr.length; i++){
   dict_with_count[arr[i]] += 1
}
var new_list = [];
for (key in dict_with_count){
   if (dict_with_count[key] > 1){
       for (var j=0; j<dict_with_count[key]; j++){
          new_list.push(key)
       }
   }
}
console.log(new_list)

遍历数组，使用该值作为对象的索引，并在原始值中每出现一次就增加一次。然后遍历对象并取出总数大于1的对象。应该适用于字符串和数字类型。

function dupsOnly(a) {
    var T = {};
    for (var i = 0; i < a.length; i++) {
        if (a[i] in T)
            T[a[i]] += 1;
        else
            T[a[i]] = 1;
    }
    var D = [];
    for (var t in T) {
        if (T[t] > 1)
            D.push(t);
        while (T[t] > 1) {
            T[t] -= 1;
            D.push(t);
       }
    }
    return D;
}

#include <stdio.h>
int main() {
    int n;
    printf("Enter the length of the array: ");
    scanf("%d", &n);
    int array[n];
    int frequency[1000] = {0}; // Assuming element range from 0 to 999
    printf("Enter the elements of the array:'n");
    for (int i = 0; i < n; i++) {
        scanf("%d", &array[i]);
        frequency[array[i]]++;
    }
    int newSize = 0;
    // Remove unique elements directly in the original array
    for (int i = 0; i < n; i++) {
        if (frequency[array[i]] > 1) {
            array[newSize] = array[i];
            newSize++;
            frequency[array[i]] = 0; // Mark as copied
        }
    }
    printf("Array after deleting unique elements:'n");
    for (int i = 0; i < newSize; i++) {
        printf("%d ", array[i]);
    }
    return 0;
}