Post History

Create a hash map and precalculate the sort key in it:

```js
// Set up: Create mock input
let u = ['4', '16', '8', '2', '6'];

function expensive_key_fn(x) {
  console.log("Doing expensive operation on: " + x)
  return String(x);
}

// Create an optimized sort function
let sortKey = {}
u.forEach(function(i) {
  sortKey[i] = expensive_key_fn(i)
});

// Use it as sort key
u.sort((a, b) => sortKey[a] - sortKey[b]);

// Show reuslt
console.log(u);
```

This is basically the poor man's memoization - in fact, simple memoization is often implemented just like this, with a hash map, but lazily, to keep up the illusion/abstraction of the "function call". However, I don't find the abstraction that helpful in this context, so despite being familiar with memoization, I often prefer this idiom just because it's simpler, more accessible to novice programmers who might read my code, and has less cognitive load for me.

Constructing the hash map is `O(N)`, which pales in comparison to `O(NlogN)` for sorting (assuming JS uses an efficient sorting implementation). That means the work of constructing the hash map is negligible. There is an extra memory cost of `O(N)` for the map, but it stores only a hash and a result value, not the whole element (if the elements are large).