Question

我在JavaScript中有一个名字列表。我想要做的是获取唯一名称列表，但是对于该唯一名称列表，还会提供我原始列表中有多少名称的计数。此外，我需要按降序排序我的最终唯一名称列表（如果某些具有相同的计数，则按名称按升序排序）。

这里是我所拥有的只是一个简单的字符串列表，然后给我一个唯一名称列表。从这里开始，我不确定从何处获取计数或如何按计数对唯一列表进行排序。我认为最终的结果将是一个二维数组的名称和计数或两个独立的数组，但我不知道如何以最好和最有效的方式实现这一目标。

这是我到目前为止所做的：

Array.prototype.contains = function(v) {
  for (var i = 0; i < this.length; i++) {
    if (this[i] === v) return true;
  }
  return false;
};

Array.prototype.unique = function() {
  var arr = [];
  for (var i = 0; i < this.length; i++) {
    if (!arr.contains(this[i])) {
      arr.push(this[i]);
    }
  }
  return arr;
}

var uniqueAuthorNames = allAuthorNames.unique();
uniqueAuthorNames.sort();

Answer 1

使用hash map for counting unique elements然后sort the unique elements by two criteria：

var names = ["eve", "carl", "adam", "carl"];

var counts = names.reduce((counts, name) => {
  counts[name] = (counts[name] || 0) + 1;
  return counts;
}, {});

var uniques = Object.keys(counts);

uniques.sort((a, b) => counts[a] == counts[b] ? a.localeCompare(b) : counts[b] - counts[a]);

console.log(counts);
console.log(uniques);

Answer 2

假设你的名字数组在arr：

var i;
var o = {};
var len = arr.length;
for (i=0; i<len; i++) {
  o[arr[i]] = (o[arr[i]] || 0) + 1; 
}

在此阶段，o将保留每个唯一名称及其计数。然后，您可以使用Sorting JavaScript Object by property value

中的解决方案

这将是

var sortable = [];
for (var name in o) {
  sortable.push([name, o[name]])
}
sortable.sort(function(a, b) {return b[1] - a[1]})

Answer 3

这应该可以满足您的需求。

Object.defineProperty (Array.prototype, 'getUniqueSorted', {
    enumerable: false,

    value: function () {
        var uniqarr = [];

        for (var i in this) {
            var index = uniqarr.indexOf (this.[i]);
            if (index == -1) {
                uniqarr.push (this [i])
            } else {
                uniqarr [index].count = uniqarr.count ? 2 : uniqarr.count+1;
            }             
        }

        uniqarr = uniqarr.sort(function(a, b){
            return (a.count | 1) - (b.count | 1)
        });

        return uniqarr;
    }
});

还有其他一些选择可以让你更优雅。

    Object.defineProperty (Array.prototype, 'removeDuplicated', {
    enumerable: false,

    value: function () {
        var uniqarr = [];

        this.reduce(function(accum, current) {
            if (accum.indexOf(current) < 0) {
                accum.push(current);
            }

            return accum;
        }, uniqarr);

        return uniqarr.sort(function(a, b){
            return a.count - b.count
        });          
    }
});

Answer 4

    var names = ['john', 'paul', 'zack', 'john', 'sam', 'jill', 'paul', 'zack', 'zack'];
    var myNames = names.slice(0); // duplicate the array for getCount function otherwise sort will mess it up. 

    var myNames = names.sort(function(a, b) {
      if (getCount(a) !== getCount(b)) {
        return getCount(b) - getCount(a); // b - a to list larger counts first
      }
      if (a > b) {
        return 1;
      }
      return -1; // no case for if a == b because thats caught by getCount()
    });

/** 
** This function computes the number of times an element occur inside the array 
**/  
    function getCount(element) {
      var count = 0;
      for (var n = 0; n < myNames.length; n++) {
        if (myNames[n] === element) {
          count++;
        }
      }

      return count;
    }

console.log(myNames); // output your results

JavaScript数组中的唯一计数，按计数排序

4 个答案: