Run results for: Simple Sort tests

Run details:

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36

Browser: Chrome 63

Operating system: Mac OS X 10.13.3

Device Platform: Other

Date tested: 2025 years ago

Test name	Executions per second
Number, many functions	980770.3 Ops/sec
Number, straight	2391758.2 Ops/sec
Number, straight, with direction	2371559.5 Ops/sec
Number, many functions, no direction	1034592.5 Ops/sec
Number, many functions, no lookup direction	815556.0 Ops/sec
Number, straight, with Enum Direction	498722.7 Ops/sec

HTML Preparation code:

<script src="https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.20.1/moment.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/decimal.js/9.0.1/decimal.min.js"></script>

Script Preparation code:

var sortDirections = {
  DEFAULT: -1,
  ASC: 1,
  DESC: -1,
};

var numberArrayToSort = [1, 4, 3, 2, 5, 6, 9, 10, 5, 8, 7];
var momentArrayToSort = numberArrayToSort.map((value) => moment(value));
console.log(momentArrayToSort[1].isBefore);
var decimalArrayToSort = numberArrayToSort.map((value) => new Decimal(value));
console.log(decimalArrayToSort);

var compare = (lessThan, equalTo) => {
  if (lessThan) {
    return -1;
  } else if (equalTo) {
    return 0;
  }

  return 1;
};

var primitiveTypeComparator = (a, b) => compare(a < b, a === b);

var genericComparator = (comparator = primitiveTypeComparator) => (a, b) => {
  return comparator(a, b);
};
var genericDirectionComparator = (comparator = primitiveTypeComparator) => (a, b, direction = sortDirections.ASC) => {
  return direction * comparator(a, b);
};
var genericHoistDirectionComparator = (comparator = primitiveTypeComparator, direction = sortDirections.ASC) => (a, b) => {
  return direction * comparator(a, b);
};

var sortByNumberComparator = genericDirectionComparator();

var sortByDecimalComparator = genericDirectionComparator(
  (decimalA, decimalB) => compare(decimalA.lessThan(decimalB), decimalA.equals(decimalB))
);

var sortByMomentComparator = genericDirectionComparator(
  (momentA, momentB) => compare(momentA.isBefore(momentB), momentA.isSame(momentB))
);

Tests:

Number, many functions
numberArrayToSort.sort((a, b) => sortByNumberComparator(a, b, sortDirections.ASC));
Number, straight
numberArrayToSort.sort((a, b) => (a - b))
Number, straight, with direction
numberArrayToSort.sort((a, b) => a === b ? 0 : a < b ? -1 : 1)
Number, many functions, no direction
genericComparator()(numberArrayToSort);
Number, many functions, no lookup direction
genericHoistDirectionComparator()(numberArrayToSort);
Number, straight, with Enum Direction
numberArrayToSort.sort((a, b) => a === b ? 0 : a < b ? -sortDirections.ASC : sortDirections.ASC)
Number, many functions,
genericDirectionComparator()(numberArrayToSort);
var direction = sortDirections.ASC; numberArrayToSort.sort((a, b) => a === b ? 0 : a < b ? -direction : direction)

Run results for: Simple Sort tests

Number, many functions

Number, straight

Number, straight, with direction

Number, many functions, no direction

Number, many functions, no lookup direction

Number, straight, with Enum Direction

Number, many functions,