Benchmark: Lodash orderBy vs array.prototype.sort vs vanila orderBy _ smart vs QuickSort add slice

Lodash orderBy vs array.prototype.sort vs vanila orderBy _ smart vs QuickSort add slice (version: 0)

Comparing performance of: _.orderBy asc vs array.prototype.sort asc vs _.orderBy desc vs array.prototype.sort desc vs array.prototype.sort desc + check type vs array.prototype.sort asc + check type vs _.orderBy asc st vs _.orderBy desc st vs quickSort

Created: 7 months ago by: Guest

Jump to the latest result

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>

Script Preparation code:

function getRandomInt(max) {
  return Math.floor(Math.random() * Math.floor(max));
}

var arr = [];
for(var i = 0; i < 100000; i++){
  arr.push({value:getRandomInt(100)});
}

function generateRandomString(length) {
  var characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
  return Array.from({ length }, () => characters.charAt(Math.floor(Math.random() * characters.length))).join('');
}

var arrStr = Array.from({ length: 100000 }, () => ({value: generateRandomString(10)}));

function orderBy(arr, props, orders) {
  return arr.slice().sort((a, b) => {
    for (let i = 0; i < props.length; i++) {
      const prop = props[i];
      const order = orders && orders[i] ? orders[i] : 'asc';
      
      // Handle prop as a function or a string
      const valueA = typeof prop === 'function' ? prop(a) : a[prop];
      const valueB = typeof prop === 'function' ? prop(b) : b[prop];

      // Normalize string values for case-insensitive comparison
      const normalizedA = typeof valueA === 'string' ? valueA.toLowerCase() : valueA;
      const normalizedB = typeof valueB === 'string' ? valueB.toLowerCase() : valueB;

      if (normalizedA < normalizedB) return order === 'asc' ? -1 : 1;
      if (normalizedA > normalizedB) return order === 'asc' ? 1 : -1;
    }
    return 0;
  });
}

function compareStringFn(a, b) {
  if (a < b) {
    return -1;
  } else if (a > b) {
    return 1;
  }
  return 0;
}
function compareNumbersFn(a, b) {
  return a - b
}

function quickSort(arr, left = 0, right = arr.length - 1) {
  if (left < right) {
    const pivotIndex = randomPartition(arr, left, right);
    quickSort(arr, left, pivotIndex - 1);
    quickSort(arr, pivotIndex + 1, right);
  }
}

function randomPartition(arr, left, right) {
  const pivotIndex = Math.floor(Math.random() * (right - left + 1)) + left;
  swap(arr, pivotIndex, right);
  return partition(arr, left, right);
}

function partition(arr, left, right) {
  const pivot = arr[right].value;
  let i = left - 1;

  for (let j = left; j < right; j++) {
    if (arr[j].value < pivot) {
      i++;
      swap(arr, i, j);
    }
  }

  swap(arr, i + 1, right);
  return i + 1;
}

function swap(arr, i, j) {
  const temp = arr[i].value;
  arr[i].value = arr[j].value;
  arr[j].value = temp;
}

Tests:

_.orderBy asc
_.orderBy(arr,(el) => el.value, "asc");
array.prototype.sort asc
arr.sort((a,b) => compareNumbersFn(a.value,b.value));
_.orderBy desc
_.orderBy(arr,(el) => el.value, "desc");
array.prototype.sort desc
arr.sort((a,b) => compareNumbersFn(b.value,a.value));
array.prototype.sort desc + check type
arrStr.sort((a,b) => compareStringFn(b.value,a.value));
array.prototype.sort asc + check type
arrStr.sort((a,b) => compareStringFn(a.value,b.value));
_.orderBy asc st
_.orderBy(arrStr,(el) => el.value, "asc");
_.orderBy desc st
_.orderBy(arrStr,(el) => el.value, "desc");
quickSort
quickSort(arrStr)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
_.orderBy asc
array.prototype.sort asc
_.orderBy desc
array.prototype.sort desc
array.prototype.sort desc + check type
array.prototype.sort asc + check type
_.orderBy asc st
_.orderBy desc st
quickSort

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 7 months ago)

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

Browser/OS: Chrome 126 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
_.orderBy asc	33.7 Ops/sec
array.prototype.sort asc	211.3 Ops/sec
_.orderBy desc	93.3 Ops/sec
array.prototype.sort desc	213.0 Ops/sec
array.prototype.sort desc + check type	164.3 Ops/sec
array.prototype.sort asc + check type	160.8 Ops/sec
_.orderBy asc st	86.6 Ops/sec
_.orderBy desc st	80.8 Ops/sec
quickSort	11.0 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 5 months ago):

LLMs can make mistakes. Check important info.

I'll provide an answer based on the data you've provided.

It appears that the test cases are measuring the performance of different JavaScript array sorting algorithms, including `sort`, `_.orderBy`, and custom quick sort functions.

The results show variations in execution speed across different browser versions, device platforms, and operating systems. For example:

* The Chrome 126 browser version performs significantly better on Mac OS X 10.15.7 compared to other browsers and operating systems.
* The `array.prototype.sort` function is faster than the custom quick sort functions, but slower than some of the primitive sorting functions like `_orderBy`.
* Some tests have variations with different test names, such as "sort desc + check type" vs. "_orderBy desc". These may be due to differences in how the algorithms are implemented or tested.

Without more information on the specific requirements and context of these tests, it's difficult to draw conclusions about which algorithm is most efficient or reliable. However, based on the data provided, here are some observations:

1. **Browser version**: The latest Chrome 126 browser version appears to be the fastest performer across all test cases.
2. **Device platform**: Desktop devices appear to perform faster than mobile devices, but this may not be representative of real-world usage scenarios.
3. **Operating system**: Mac OS X 10.15.7 is the fastest performing operating system, while other versions (e.g., Windows) are slower.

Please note that these observations are based on a limited dataset and should be taken with caution. Further analysis would require additional data points to draw more robust conclusions about algorithm performance and reliability.

Related benchmarks:

Lodash orderBy vs array.prototype.sort vs vanila orderBy _ smart vs QuickSort add slice (version: 0)

Comparing performance of: _.orderBy asc vs array.prototype.sort asc vs _.orderBy desc vs array.prototype.sort desc vs array.prototype.sort desc + check type vs array.prototype.sort asc + check type vs _.orderBy asc st vs _.orderBy desc st vs quickSort

Created: 7 months ago by: Guest

Jump to the latest result

_.orderBy asc

array.prototype.sort asc

_.orderBy desc

array.prototype.sort desc

array.prototype.sort desc + check type

array.prototype.sort asc + check type

_.orderBy asc st

_.orderBy desc st

quickSort

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 5 months ago):