根据元素的频率对数组进行排序

Question

我有一个包含重复数据的数组。我想根据频率对其进行排序（首先是重复次数最高的元素），然后删除重复项。

我尝试了下面的代码，它抛出了不同的顺序。

var arr=[
    {name: "Manage AAA Devices", sys_id: "7b491aad371adb003ef7a9c2b3990e22"},
    {name: "", sys_id: ""},
    {name: "Manage AAA - ISE Admin Functions", sys_id: "dc5f99a2dbb2b74019d81ffa68961933"},
    {name: "Manage AAA Devices", sys_id: "7b491aad371adb003ef7a9c2b3990e22"},
    {name: "Manage AAA - ISE Admin Functions", sys_id: "dc5f99a2dbb2b74019d81ffa68961933"},
    {name: "SNOW Change Request", sys_id: "325b08913783d6c4f4f4c97a43990e90"},
    {name: "", sys_id: ""},
    {name: "Manage AAA - ISE Admin Functions", sys_id: "dc5f99a2dbb2b74019d81ffa68961933"},
    {name: "Manage AAA - ISE Admin Functions", sys_id: "dc5f99a2dbb2b74019d81ffa68961933"},
    {name: "Incident Request", sys_id: "3ee543f61b363740f713ed7b2f4bcbc0"}
];

console.log(arr.reduce((x, y) => {
  if (x[y.name]) {
    x[y.name]++;
    return x;
  } else {
    var z = {};
    z[y.name] = 1;
    return Object.assign(x, z);
  }
}, {}))

Answer 1

不是最佳解决方案，但您可以以此为起点：

var arr = [{
    "name": "Manage AAA Devices",
    "sys_id": "7b491aad371adb003ef7a9c2b3990e22"
  },
  {
    "name": "",
    "sys_id": ""
  },
  {
    "name": "Manage AAA - ISE Admin Functions",
    "sys_id": "dc5f99a2dbb2b74019d81ffa68961933"
  },
  {
    "name": "Manage AAA Devices",
    "sys_id": "7b491aad371adb003ef7a9c2b3990e22"
  },
  {
    "name": "Manage AAA - ISE Admin Functions",
    "sys_id": "dc5f99a2dbb2b74019d81ffa68961933"
  },
  {
    "name": "SNOW Change Request",
    "sys_id": "325b08913783d6c4f4f4c97a43990e90"
  },
  {
    "name": "",
    "sys_id": ""
  },
  {
    "name": "Manage AAA - ISE Admin Functions",
    "sys_id": "dc5f99a2dbb2b74019d81ffa68961933"
  },
  {
    "name": "Manage AAA - ISE Admin Functions",
    "sys_id": "dc5f99a2dbb2b74019d81ffa68961933"
  },
  {
    "name": "Incident Request",
    "sys_id": "3ee543f61b363740f713ed7b2f4bcbc0"
  }
];

const noOfOccurencies = arr.reduce((x, y) => {
  if (x[y.name]) {
    x[y.name]++;
    return x;
  } else {
    var z = {};
    z[y.name] = 1;
    return Object.assign(x, z);
  }
}, {})

console.log(noOfOccurencies);

// Order an array of objects based on another array order
// https://gist.github.com/ecarter/1423674
function mapOrder(array, order, key) {
  array.sort(function(a, b) {
    var A = a[key],
      B = b[key];

    if (order.indexOf(A) > order.indexOf(B)) {
      return 1;
    } else {
      return -1;
    }
  });
  return array;
};

// sort noOfOccurencies
const itemOrder = Object.keys(noOfOccurencies).sort(function(a, b) {
  return noOfOccurencies[a] - noOfOccurencies[b]
})
// reverse noOfOccurencies (*highest duplicates element first*)
itemOrder.reverse();

console.log(itemOrder);

// order the original array based on itemOrder
let ordered_array = mapOrder(arr, itemOrder, 'name');

// remove duplicates from the new array ordered
const noDuplicatesArr = ordered_array.filter((v, i, a) => a.findIndex(t => (t.name === v.name)) === i)

console.log(noDuplicatesArr);

Answer 2

let arr = [
    {name: "Manage AAA Devices", sys_id: "7b491aad371adb003ef7a9c2b3990e22"},
    {name: "", sys_id: ""},
    {name: "Manage AAA - ISE Admin Functions", sys_id: "dc5f99a2dbb2b74019d81ffa68961933"},
    {name: "Manage AAA Devices", sys_id: "7b491aad371adb003ef7a9c2b3990e22"},
    {name: "Manage AAA - ISE Admin Functions", sys_id: "dc5f99a2dbb2b74019d81ffa68961933"},
    {name: "SNOW Change Request", sys_id: "325b08913783d6c4f4f4c97a43990e90"},
    {name: "", sys_id: ""},
    {name: "Manage AAA - ISE Admin Functions", sys_id: "dc5f99a2dbb2b74019d81ffa68961933"},
    {name: "Manage AAA - ISE Admin Functions", sys_id: "dc5f99a2dbb2b74019d81ffa68961933"},
    {name: "Incident Request", sys_id: "3ee543f61b363740f713ed7b2f4bcbc0"},
];

function sortByFrequency(arrayWithDuplicates) {
    let tempArray = [];
    let temp = [];

    arrayWithDuplicates.forEach((item) => {
            temp.push(JSON.stringify(item));
        }
    );

    (Array(...new Set(temp))).forEach((x) => {
        tempArray.push(arrayWithDuplicates.filter((y) => {
            return x === JSON.stringify(y);
        }));
    });

    tempArray.sort((a, b) => {
        return a.length - b.length;
    });

    temp = [];
    tempArray.forEach((item) => {
        temp.push({name: item[0].name, frequency: item.length});
    });

    return temp.reverse();
}

console.log(sortByFrequency(arr));

Answer 3

我认为最简单的方法可能是将原始项目保留为您正在创建的字典的一部分，然后您可以简单地使用该字典进行排序。无论如何，字典将不再有 1 项，并且它会有一个项目计数。

所以你会稍微改变reduce函数

function reduceWithCount( arr, prop ) {
  return arr.reduce( (agg, item) => {
    const key = item[prop];
    if (!agg[key]) {
      agg[key] = { count: 0, item };
    }
    agg[key].count++;
    return agg;
  }, {});
}

要从中创建一个新数组，按您记录的频率排序，您只需将项目映射回来并使用字典对象中先前保存的计数

function createArrayFromObject( countedDictionary, prop ) {
  return Object.keys( countedDictionary )
    .map( key => countedDictionary[key].item )
    .sort( (a, b) => countedDictionary[b[prop]].count - countedDictionary[a[prop]].count );
}

然而，这意味着使用这些函数，您必须将密钥传递两次，但我认为这不会造成太大的开销。

我稍微更改了 sn-p 的代码，使其不使用您的原始数组，而是使用随机生成的数组，以查看它将如何处理 50.000 个条目。

只要原始数组中没有 50000 个不同的名称，使用简单的字典查找就可以了。

const seed = {
  'Manage AAA Devices': '7b491aad371adb003ef7a9c2b3990e22',
  '': '',
  'Manage AAA - ISE Admin Functions': 'dc5f99a2dbb2b74019d81ffa68961933',
  'SNOW Change Request': '325b08913783d6c4f4f4c97a43990e90',
  'Incident Request': '3ee543f61b363740f713ed7b2f4bcbc0'
};

const seedKeys = Object.keys( seed );
const arr = [...new Array(50000)].map( _ => {
  let name = seedKeys[parseInt(Math.random() * seedKeys.length)];
  return { name, sysId: seed[name] };
} );

console.log(`array generated with ${arr.length} items`);

function reduceWithCount( arr, prop ) {
  return arr.reduce( (agg, item) => {
    const key = item[prop];
    if (!agg[key]) {
      agg[key] = { count: 0, item };
    }
    agg[key].count++;
    return agg;
  }, {});
}

function createArrayFromObject( countedDictionary, prop ) {
  return Object.keys( countedDictionary )
    .map( key => countedDictionary[key].item )
    .sort( (a, b) => countedDictionary[b[prop]].count - countedDictionary[a[prop]].count );
}

console.time('removeAndSort');
const removedDuplicates = reduceWithCount( arr, 'name' );
const sortedArray = createArrayFromObject( removedDuplicates, 'name' );
console.timeEnd('removeAndSort');
console.log( removedDuplicates );
console.log( sortedArray );