JS中的频率排序对象数组和频率匹配基于对象属性排序

Question

I have Array of objects

[
    {"X" : {
        "price" : "5"
      }
    },
    {"Y" : {
        "price" : "3"
      }
    },
    {"Y" : {
        "price" : "3"
      }
    },
    {"Z" : {
        "price" : "4"
      }
    },
    {"Q" : {
        "price" : "2"
      }
    },
    {"X" : {
        "price" : "5"
      }
    },
    {"Z" : {
        "price" : "4"
      }
    },
    {"X" : {
        "price" : "5"
      }
    }
]

I want to frequency Sort the array so that i get like [object:count]

How do i get the array to Transform arr to the format:

// [{key: x, count: 3, price: 5}},{key: y:, count: 2, price: 3}

[{x:3},{y:2},{z:2},{q:1}]

But the problem i am facing is if the frequency matches then the sort has to check the object's property i:e in this case the price and if the price is more than the other matching element that should be given weight age so in this case z price is more than y so z should be given priority.

[{x:3},{z:2},{y:2},{q:1}]

This is what i have tried so far:

 var a = ["x", "v"], b = ["x", "y"], c = ["d", "y"]; var d = a.concat(b, c); function sortByFrequency(array) { var frequency = {}; array.forEach(function(value) { frequency[value] = 0; }); var uniques = array.filter(function(value) { return ++frequency[value] == 1; }); return uniques.sort(function(a, b) { return frequency[b] - frequency[a]; }); } var frequency = sortByFrequency(d); console.log(frequency); 

 .as-console-wrapper{min-height:100%} 

Update after answer

I still donot know how to transform the array to this format

  var arr = [ {"key":"X", "price" : "5", "count" :"3" } , {"key":"Y", "price" : "3", "count" :"2" } , {"key":"Z", "price" : "4", "count" : "2" } ]; var r = _.sortBy(_.sortBy(arr, 'price'), 'count'); console.log(JSON.stringify(r)); 

 <script src="https://cdnjs.cloudflare.com/ajax/libs/underscore.js/1.8.3/underscore.js"></script> 

now it works but how to get the object to this format from array

Answer 1

You could do it with the following ES6 code:

 function sortByFrequency(a) { return Array.from( a.reduce( (acc, o) => { const key = Object.keys(o)[0]; const obj = acc.get(key) || Object.assign({ key, count: 0 }, o[key]); obj.count++; return acc.set(key, obj); }, new Map), ([key, obj]) => obj ).sort( (a, b) => b.count - a.count || b.price - a.price ); } // Sample input const a = [{ X: { price: "5" } }, { Y: { price: "3" } }, { Y: { price: "3" } }, { Z: { price: "4" } }, { Q: { price: "2" } }, { X: { price: "5" } }, { Z: { price: "4" } }, { X: { price: "5" } }]; // Perform transformation & output const res = sortByFrequency(a); console.log(res); 

 .as-console-wrapper { max-height: 100% !important; top: 0; } 

Explanation

The code builds a Map to ensure one entry per key. It is created with reduce , which gets as starting value new Map and which is then referenced as acc .

reduce will iterate over the input array a , and for each entry, it will extract the key with Object.keys . Since there is (and should be) only one key per object, it is extracted with [0] from the resulting array of keys.

Then with acc.get it is verified whether we already have an entry for that key. If so, obj is set to the object we had previously stored for that key. If not -- and this is the case in the first iteration -- a new object is created with key and count properties which get the correct values, and this object is merged with the deeper object in the input array ( o[key] ). Practically this means the price key and value are added to the object that already has key and count .

In either case (whether we created a new object or retrieved it from the Map), its count property is incremented.

Then this object is stored in the Map at the corresponding key with acc.set(key, obj) . This is returned to the reduce internals (ie the updated acc is returned), and this will be the value of acc in the next iteration, as that is how reduce works.

After the final iteration reduce will return the completed Map. This is then converted to an array with Array.from . During its execution we transform each entry, because by default a Map entry will be converted to a key/value pair (array), but we only want to keep the value (since it now contains the key property). So that is what happens in the callback argument provided to Array.from :

([key, obj]) => obj

Now we have an array of objects, where each object has the three desired properties. The only thing remaining is the sorting.

For that we subtract the counts of the two objects that are being compared (just as you already had done). However, when they are equal, we need to do more. In that case the difference is zero, which is falsy, and so with a boolean || we force JavaScript to evaluate what follows after it. In that case we sort by the price, again by subtracting the prices from each other. Note that your prices are strings, but the subtraction operator will convert them to numbers on the fly.

Answer 2

Try this one using reduce and then sort .

Explaination

In order to achieve the desired result you can break down the task in below steps.

1. Grouping - Group by the items in the array using the Property names (x,y,z)
2. Sorting - Sort the Result from Step1 in descending order where the first criteria is the count of items and the second criteria is the price.

1.Grouping - There isn't a native group by function in javascript. Therefore, we can make use of the reduce function which basically runs a function over the sequence of array and also returns the accumulated value.

a. In the reduce function, the accumulator will start with an empty array as mentioned in comments in code towards the end of the reduce function.

b. We get the property name like "x", "y", "z" by traversing the object. Also, we use the zeroth index as there is only one property like "x", "y", "z".

c. After that we check if the property is already in the Array or not.

d. If the Property is not in the array, then we need to add the property to the Array.

e. We create a object to handle the count and price information which would be used later.

f. If the Property already exists as mentioned in step c, then we need to increment the count of that property elementInArray[propName].count++;

2. Sorting
a. sort function takes a comparer function. In that function we compare the 2 items firsly by their count . If count is equal then we compare them by the price .

 var arr = [ {"X" : { "price" : "5" } }, {"Y" : { "price" : "3" } }, {"Y" : { "price" : "3" } }, {"Z" : { "price" : "4" } }, {"Q" : { "price" : "2" } }, {"X" : { "price" : "5" } }, {"Z" : { "price" : "4" } }, {"X" : { "price" : "5" } } ]; var frequency = arr.reduce(function (accumulatorObject, currentValue) { var propName = Object.keys(currentValue)[0]; var elementInArray = accumulatorObject.find((element) => Object.keys(element)[0] === propName); if (elementInArray) { elementInArray[propName].count++; } else { var newObject = {}; newObject[propName] = {}; newObject[propName].count = 1; newObject[propName].price = +currentValue[propName].price; accumulatorObject.push(newObject); } return accumulatorObject; }, []); // // Accumulator starts with Empty array. frequency.sort(function(first,second){ var diff = second[Object.keys(second)].count - first[Object.keys(first)].count; if( diff === 0) { return second[Object.keys(second)].price - first[Object.keys(first)].price; } return diff;}); console.log(frequency); 

Answer 3

I'm just giving you the skeleton, but the _.sortBy method in lodash or underscore will perform a stable sort (ie preserve previous sorts) and let you apply multiple sorts.

function sortByFrequency(arr) {
    // Transform arr to the format: 
    // [{key: x, count: 3, price: 5}},{key: y:, count: 2, price: 3}, ... 

    arr = _.sortBy(_.sortBy(arr, 'price'), 'count'); 
    // in lodash, this is arr = _.sortBy(arr, ['price', 'count'])

    // transform arr into the format that you want 
    return arr.map(x => /* function */)

}

Answer 4

Just an Update to the Comment of John On Agalo Answer

Mapping each of the object keys into new object

In the Else block you can write this

 var newObject = {};  
    newObject[propName]  = {};
    newObject[propName].count = 1;
  Object.assign(newObject[propName], currentValue[propName]); // this line should do the trick also you need not convert proce to number as while sorting it is done at runtime .
    //newObject[propName].price = +currentValue[propName].price;
  accumulatorObject.push(newObject);