Post History

When using the compare function in Array.prototype.sort, how to avoid an element to be processed more than once?

When using the [`Array.prototype.sort` method](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort), we can pass a compare function as argument. Then, this function can be used to process array's elements, so the comparison is made using some custom criteria.

But I noticed that this can lead to some, let's say, redundancy. For instance, this code:

```javascript
function getSortKey(item) {
    console.log('getSortKey', item);
    return parseInt(item);
}

const array = ['4', '16', '8', '2', '6'];
array.sort((a, b) => getSortKey(a) - getSortKey(b));

console.log(array);
```

I've created the `getSortKey` function just to know when each string is converted to a number during sorting. The output is:

```none
getSortKey 16
getSortKey 4
getSortKey 8
getSortKey 16
getSortKey 8
getSortKey 16
getSortKey 8
getSortKey 4
getSortKey 2
getSortKey 8
getSortKey 2
getSortKey 4
getSortKey 6
getSortKey 8
getSortKey 6
getSortKey 4
[ '2', '4', '6', '8', '16' ]
```

Which means that all elements were processed by `getSortKey` more than once (that wouldn't be necessary, as each string always results in the same number).

<sup>_This was tested in Chrome. Different browsers/runtimes/implementations may use different sorting algorithms and the exact output might not be the same (but testing in other browsers, it has the same behaviour: the function being called more than once for each element)._</sup>


---

The example above was just to show this specific behaviour: the `getSortKey` function is called many times for the same elements.

But **let's suppose** that `getSortKey` is an expensive operation (it takes too much time and/or memory, etc), and the array has lots of elements, and these function calls are a bottleneck that needs to be fixed. The ideal situation is that `getSortKey` processed each element jut once. How to do that?