Benchmark: Simple Sort tests

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)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
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,

Fastest: N/A

Slowest: N/A

ⓘ Get performance results from real users on your website with Request Metrics.

Website Performance Monitoring by Request Metrics

Latest run results:

Run details: (Test run date: 2024 years ago)

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/OS: Chrome 63 on Mac OS X 10.13.3

View result in a separate tab

Test name	Executions per second
Many functions	0.0 Ops/sec
Straight sort	2207715.0 Ops/sec

Simple Sort tests (version: 20)

Comparing performance of: Number, many functions vs Number, straight vs Number, straight, with direction vs Number, many functions, no direction vs Number, many functions, no lookup direction vs Number, straight, with Enum Direction vs Number, many functions, vs

Created: 6 years ago by: Registered User

Jump to the latest result

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,

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A