在javascript数组中计数和删除重复项

我有一个正整数数组。有些是独一无二的，有些是重复的。我正在尝试创建一个函数，该函数将计算重复数并将其与相关数字配对

例如，如果我从这个数组开始：

arr = [89, 1, 1, 2, 89, 89];

我试图得到这样的结果：

res = [
       {"id" : 1, "count" : 2 },
       {"id" : 2, "count" : 1 },
       {"id" : 89, "count" : 3 }
      ];

这是我编写的函数，但它不起作用，我觉得有更好的解决方案：

    function cons_dupes(arr) {
    //Consolidate duplicates by deleting everything but one of each.
    //Also adds a count of total duplicates with each index.
    var out = {};

    for (i=0;i<arr.length;i++)
    {
        if (arr[i] !== 'null') 
        {

            out[i] = {
                data: arr[i],
                count: 1
            };

            for (ii=0; ii<arr.length; ii++) 
            {
                if (arr[i]==arr[ii])
                {
                    arr[ii] = 'null';
                    out[i].count++;
                }
            }
        }
        else
        {
        console.log('null value: arr['+ii+']');
        }
    }

    return out;
}

_.map(_.groupBy(arr), function(value, key) {
  return {
    id: key,
    count: value.length
  }
});

function cons_dupes(arr) {
  var p = {};
  arr.forEach(function (x) { p[x] = (p[x] || 0) + 1; });
  return Object.keys(p).map(function (x) { return { id: x, count: p[x] }; });
}

功能重复（arr）{
//通过删除除其中一项之外的所有内容来合并重复项。
//还为每个索引添加总重复数。
var out={}；
对于（i=0；i您可能希望分两步执行此操作：1）创建一个包含每个id计数的对象，然后2）创建最终的对象数组。例如：

var a = [89, 1, 1, 2, 89];
var counts = {};
var final = [];

for (var i = 0; i < a.length; i++) {
    if(counts[a[i]] != undefined) {
        counts[a[i]] = 1;
    } else {
        counts[a[i]]++;
    }
}

for (var num in counts) {
    final.push({'id': num, 'count': counts[num]});
}

// final has what you want here

var a=[89,1,1,2,89]；
变量计数={}；
var final=[]；
对于（变量i=0；i
您可能需要分两步执行此操作：1）创建一个包含每个id计数的对象，然后2）创建最终的对象数组。例如：

var a = [89, 1, 1, 2, 89];
var counts = {};
var final = [];

for (var i = 0; i < a.length; i++) {
    if(counts[a[i]] != undefined) {
        counts[a[i]] = 1;
    } else {
        counts[a[i]]++;
    }
}

for (var num in counts) {
    final.push({'id': num, 'count': counts[num]});
}

// final has what you want here

var a=[89,1,1,2,89]；
变量计数={}；
var final=[]；
对于（变量i=0；i
如果您不介意使用，这里有一个简单的解决方案：

    function cons_dupes(arr) {
    //Consolidate duplicates by deleting everything but one of each.
    //Also adds a count of total duplicates with each index.
    var out = {};

    for (i=0;i<arr.length;i++)
    {
        if (arr[i] !== 'null') 
        {

            out[i] = {
                data: arr[i],
                count: 1
            };

            for (ii=0; ii<arr.length; ii++) 
            {
                if (arr[i]==arr[ii])
                {
                    arr[ii] = 'null';
                    out[i].count++;
                }
            }
        }
        else
        {
        console.log('null value: arr['+ii+']');
        }
    }

    return out;
}

_.map(_.groupBy(arr), function(value, key) {
  return {
    id: key,
    count: value.length
  }
});

function cons_dupes(arr) {
  var p = {};
  arr.forEach(function (x) { p[x] = (p[x] || 0) + 1; });
  return Object.keys(p).map(function (x) { return { id: x, count: p[x] }; });
}

如果您不介意使用，这里有一个简单的解决方案：

    function cons_dupes(arr) {
    //Consolidate duplicates by deleting everything but one of each.
    //Also adds a count of total duplicates with each index.
    var out = {};

    for (i=0;i<arr.length;i++)
    {
        if (arr[i] !== 'null') 
        {

            out[i] = {
                data: arr[i],
                count: 1
            };

            for (ii=0; ii<arr.length; ii++) 
            {
                if (arr[i]==arr[ii])
                {
                    arr[ii] = 'null';
                    out[i].count++;
                }
            }
        }
        else
        {
        console.log('null value: arr['+ii+']');
        }
    }

    return out;
}

_.map(_.groupBy(arr), function(value, key) {
  return {
    id: key,
    count: value.length
  }
});

function cons_dupes(arr) {
  var p = {};
  arr.forEach(function (x) { p[x] = (p[x] || 0) + 1; });
  return Object.keys(p).map(function (x) { return { id: x, count: p[x] }; });
}

arr=[89,1,1,2,89,89]；
arr.sort（）；//它会改变原始数组。所以要小心
var newArr=[]；
var计数=1；
对于（i=0；i
arr=[89,1,1,2,89,89]；
arr.sort（）；//它会改变原始数组。所以要小心
var newArr=[]；
var计数=1；
对于（i=0；i注意你的
对于（ii=0；ii注意你的
对于（ii=0；ii你有“在javascript数组中计数和删除重复项”在主题中，但在问题正文中未提及删除。您应确保问题正文完整，不依赖标题中的信息，并且标题与正文匹配

这里的大多数答案不会删除重复项

无论如何，假设您希望删除成员计数和重复项，可以执行以下操作：

// Removes duplicates from an array and returns an object
// with a count of the members
function removeDupes(arr) {
  var result = {};
  var i = arr.length;

  while (i--) {

    // If member is a duplicate, increment count and delete it      
    if (result.hasOwnProperty(arr[i])) {
      result[arr[i]]++;
      arr.splice(i, 1);

    // Otherwise, just add it to the results 
    } else {
      result[arr[i]] = 1;
    }
  }

  // convert results to the desired object format
  return Object.keys(result).map(function (p){return {id: p, count: result[p]};});
}

您在主题中有“在javascript数组中计数并删除重复项”，但在问题正文中没有提及删除。您应该确保问题正文是完整的，不依赖标题中的信息，并且标题与正文匹配

这里的大多数答案不会删除重复项

无论如何，假设您希望删除成员计数和重复项，可以执行以下操作：

// Removes duplicates from an array and returns an object
// with a count of the members
function removeDupes(arr) {
  var result = {};
  var i = arr.length;

  while (i--) {

    // If member is a duplicate, increment count and delete it      
    if (result.hasOwnProperty(arr[i])) {
      result[arr[i]]++;
      arr.splice(i, 1);

    // Otherwise, just add it to the results 
    } else {
      result[arr[i]] = 1;
    }
  }

  // convert results to the desired object format
  return Object.keys(result).map(function (p){return {id: p, count: result[p]};});
}

从原件中删除副本的步骤在哪里？从原件中删除副本的步骤在哪里？