为什么 javascript 数组排序不会将所有元素相互比较？

Question

I'm trying to understand why Javascript array sort doesn't work with the following logic. I have no problems making my own algorithm to sort this array, but I'm trying to make it with the Javascript sort built-in method to understand it better.

In this code, I want to push entities that "belongs to" another entity to the bottom, so entities that "has" other entities appear on the top. But apparently, the sort method doesn't compare all elements with each other, so the logic doesn't work properly.

Am I doing something wrong, or it is the correct behavior for the Javascript sort method?

The code I'm trying to execute:

 let entities = [ { name: 'Permission2', belongsTo: ['Role'] }, { name: 'Another', belongsTo: ['User'] }, { name: 'User', belongsTo: ['Role', 'Permission2'] }, { name: 'Teste', belongsTo: ['User'] }, { name: 'Role', belongsTo: ['Other'] }, { name: 'Other', belongsTo: [] }, { name: 'Permission', belongsTo: ['Role'] }, { name: 'Test', belongsTo: [] }, ] // Order needs to be Permission, let sorted = entities.sort((first, second) => { let firstBelongsToSecond = first.belongsTo.includes(second.name), secondBelongsToFirst = second.belongsTo.includes(first.name) if(firstBelongsToSecond) return 1 if(secondBelongsToFirst) return -1 return 0 }) console.log(sorted.map(item => item.name))

As you can see, "Role" needs to appear before "User", "Other" before "Role", etc, but it doesn't work.

Thanks for your help! Cheers

Answer 1

You're running into literally how sorting is supposed to work: sort compares two elements at a time, so let's just take some (virtual) pen and paper and write out what your code is supposed to do.

If we use the simplest array with just User and Role, things work fine, so let's reduce your entities to a three element array that doesn't do what you thought it was supposed to do:

let entities = [
  {
    name: 'User',
    belongsTo: ['Role', 'Permission2']
  },
  {
    name: 'Test',
    belongsTo: []
  },
  {
    name: 'Role',
    belongsTo: ['Other']
  }
]

This will yield {User, Test, Role} when sorted, because it should ... so let's see why it should:

1. pick elements [0] and [1] from [user, test, role] for comparison
2. compare(user, test)
   • user does not belong to test
   • test does not belong to user
   • per your code: return 0, ie don't change the ordering
3. we slide the compare window over to [1] and [2]
4. compare(test, role)
   • test does not belong to role
   • role does not belong to test
   • per your code: return 0, ie don't change the ordering
5. we slide the compare window over to [2] and [3]
   • there is no [3], we're done
6. The sorted result is {user, test, role}, because nothing got reordered

So the "bug" is thinking that sort compares everything-to-everything: as User and Role are not adjacent elements, they will never get compared to each other. Only adjacent elements get compared.