基于两层对对象数组进行排序

Question

I want to sort this array of objects where each object should be ascending in each unit and units should be sorted ascending based on order too:

 const userCards = [ { unit: 5, order: 1, }, { unit: 5, order: 3, }, { unit: 5, order: 2, }, { unit: 6, order: 2, }, { unit: 6, order: 1, }, { unit: 6, order: 3, }, { unit: 7, order: 1, }, { unit: 4, order: 2, }, { unit: 1, order: 1, }, { unit: 1, order: 2, }, { unit: 1, order: 3, }, { unit: 1, order: 4, }, { unit: 3, order: 2, } ] function compare(a, b) { if (a.unit > b.unit && a.order > b.order) return 1; if (a.unit < b.unit) return -1; return 0; } const res = userCards.sort(compare); console.log(res)

For instance the desired result would be :

{
   unit: 5,
   order: 1,
},

{
   unit: 5,
   order: 2,
},

{
   unit: 6,
   order: 1,
},

{
   unit: 6,
   order: 2,
},

As you see so far this is not happening!

How can I fix this?

Answer 1

function compare(a, b) {
  if (a.unit == b.unit) {
        return a.order - b.order;
    }

  return a.unit - b.unit;
}

Answer 2

Details are commented in example below

 const userCards = [{ unit: 5, order: 1, }, { unit: 5, order: 2, }, { unit: 6, order: 2, }, { unit: 6, order: 1, }, { unit: 6, order: 3, }, { unit: 7, order: 1, }, { unit: 5, order: 3, }, { unit: 4, order: 2, }, { unit: 1, order: 1, }, { unit: 1, order: 2, }, { unit: 1, order: 3, }, { unit: 1, order: 4, }, { unit: 3, order: 2, } ]; /* Create a reference object array that stores the keys needed to be in order */ let orderKey = [{ key: 'unit' }, { key: 'order' }]; // Pass both object arrays function compare(objArray, sortOrder) { // Start with .sort() return objArray.sort((a, b) => { // Define counter and ternary value initial defaults let i = 0, result = 0; /* As long as counter is less than sortOrder total AND ternary is 0 ...Define A as previous value of current key... ...Define B as current value of current key... ...If A is less than B return -1 (A and B stay)... ...if A is greater than B return 1 (A and B swap)... ...else return 0 (A and B stay)... ...increment counter... */ while (i < sortOrder.length && result === 0) { let A = a[sortOrder[i].key], B = b[sortOrder[i].key]; result = A < B ? -1 : A > B ? 1 : 0; i++; } return result; }); } console.log(JSON.stringify(compare(userCards, orderKey)));

Answer 3

A	B	a.unit > b.unit && a.order > b.order	a.unit > b.unit	value returned
{unit: 5, order: 3}	{unit: 4, order: 1}	True		1 <-- meaning A > B
{unit: 5, order: 3}	{unit: 5, order: 1}	False	False	0 <-- meaning same value
{unit: 4, order: 1}	{unit: 3, order: 2}	False	True	-1 <-- meaning A > B
{unit: 1, order: 1}	{unit: 3, order: 2}	False	True	0 <-- meaning same value

As you can see on this example, your condition does not work as you want since it has return 0 2 times.

---

Reading the Array#sort documentation the return of the sort function is the following

compareFunction(a, b) return value	sort order
> 0	sort b before a
< 0	sort a before b
=== 0	keep original order of a and b

So here you can just do the following :

• if the unit are equals, return the dufference between the orders
• else return the difference between the units

function compare(a, b) {
  if(a.unit === b.unit) return a.order - b.order 
  else return a.unit - b.unit
}

Or with one line using ternary

function compare = (a, b) => a.unit === b.unit ? a.order - b.order : a.unit - b.unit

Working example

 const userCards = [ { unit: 5, order: 1, }, { unit: 5, order: 3, }, { unit: 5, order: 2, }, { unit: 6, order: 2, }, { unit: 6, order: 1, }, { unit: 6, order: 3, }, { unit: 7, order: 1, }, { unit: 4, order: 2, }, { unit: 1, order: 1, }, { unit: 1, order: 2, }, { unit: 1, order: 3, }, { unit: 1, order: 4, }, { unit: 3, order: 2, } ] const compare = (a, b) => a.unit === b.unit ? a.order - b.order : a.unit - b.unit const res = userCards.sort(compare); console.log(JSON.stringify(res))