Run results for: Lodash orderBy vs array.prototype.sort vs vanila orderBy _ smart

Run details:

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Safari/605.1.15

Browser: Safari 17

Operating system: Mac OS X 10.15.7

Device Platform: Desktop

Date tested: 2 months ago

Test name	Executions per second
_.orderBy asc	22.0 Ops/sec
array.prototype.sort asc	31.3 Ops/sec
_.orderBy desc	35.7 Ops/sec
array.prototype.sort desc	23.0 Ops/sec
array.prototype.sort desc + check type	9.9 Ops/sec
array.prototype.sort asc + check type	10.5 Ops/sec
_.orderBy asc st	7.0 Ops/sec
_.orderBy desc st	8.8 Ops/sec

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].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
}

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");

Run results for: Lodash orderBy vs array.prototype.sort vs vanila orderBy _ smart

_.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