Run results for: Lodash_4.17.21.sortBy vs .sort vs custom insertion vs custom quick

Test name	Executions per second
✓ stdSort	695,100 Ops/sec
Lodash_4.17.21.sortBy	95,266 Ops/sec
InsertionSort	45,205 Ops/sec
QuickSort	42,749 Ops/sec

Script Preparation code:

var arr = [{
  name: "Ваня",
  date: "2024-12-01 18:00",
  curr: "RUB",
  level: 12,
},
{
  name: "Маня",
  date: "2024-12-01 02:00",
  curr: "KZT",
  level: 3,
},
{
  name: "Петя",
  date: "2024-12-01 12:00",
  curr: "USD",
  level: 7,
},
{
  name: "Вика",
  date: "2024-12-01 05:00",
  curr: "RUB",
  level: 9,
},
{
  name: "Лера",
  date: "2024-12-01 11:00",
  curr: "RUB",
  level: 2,
},
{
  name: "Каша",
  date: "2024-12-01 15:00",
  curr: "KZT",
  level: 10,
},
{
  name: "Паша",
  date: "2024-12-01 17:00",
  curr: "USD",
  level: 1,
},
{
  name: "Даша",
  date: "2024-12-01 10:00",
  curr: "RUB",
  level: 8,
},
{
  name: "Вера",
  date: "2024-12-01 00:00",
  curr: "RUB",
  level: 5,
},
{
  name: "Саша",
  date: "2024-12-01 14:00",
  curr: "USD",
  level: 11,
},
{
  name: "Маша",
  date: "2024-12-01 10:00",
  curr: "KZT",
  level: 4,
},
{
  name: "Ваня",
  date: "2024-12-01 15:00",
  curr: "USD",
  level: 6,
},
];

var CURR_ORDER = {
  RUB: 1,
  USD: 2,
  KZT: 3,
};

var CONDITIONS = [
  (a, b) => CURR_ORDER[a.curr] - CURR_ORDER[b.curr],
  (a, b) => new Date(a.date) - new Date(b.date),
];

var compare = (conditions) => (a, b) => {
  for (let i = 0; i < conditions.length; i++) {
    const condition = conditions[i];
    const type = typeof condition;
    if (type === "string") {
      if (typeof a[condition] === "string") {
        const result = a[condition].localeCompare(b[condition]);
        if (!result) continue;
        return result;
      } else if (typeof a[condition] === "number") {
        const result = a[condition] - b[condition];
        if (!result) continue;
        return result;
      }
    } else if (type === "function") {
      const result = condition(a, b);
      if (!result) continue;
      return result;
    }
  }

  return 0;
};

var stdSort = (arr, conditions) => {
  const newArr = [...arr];
  newArr.sort(compare);
  return newArr;
};

var insertionSort = (arr, conditions) => {
  const newArr = [...arr];

  for (let i = 1, l = newArr.length; i < l; i++) {
    const current = arr[i];
    let j = i;
    const comp = compare(conditions);
    while (j > 0 && comp(newArr[j - 1], current)) {
      newArr[j] = newArr[j - 1];
      j--;
    }
    newArr[j] = current;
  }
  return newArr;
};

var partition = (arr, start, end, compare) => {
  const pivotValue = arr[end];
  let pivotIndex = start;


  for (let i = start; i < end; i++) {
    if (compare(arr[i], pivotValue) < 0) {
      [arr[i], arr[pivotIndex]] = [arr[pivotIndex], arr[i]];
      pivotIndex++;
    }
  }

  [arr[pivotIndex], arr[end]] = [arr[end], arr[pivotIndex]];
  return pivotIndex;
};

var quickSortIterative = (arr, conditions) => {
  const newArr = [...arr];
  const stack = [0, arr.length - 1];
  const comp = compare(conditions);

  while (stack[stack.length - 1] >= 0) {
    end = stack.pop();
    start = stack.pop();

    pivotIndex = partition(newArr, start, end, comp);

    if (pivotIndex - 1 > start) {
      stack.push(start);
      stack.push(pivotIndex - 1);
    }

    if (pivotIndex + 1 < end) {
      stack.push(pivotIndex + 1);
      stack.push(end);
    }
  }

  return newArr;
};

Run results for: Lodash_4.17.21.sortBy vs .sort vs custom insertion vs custom quick

Lodash_4.17.21.sortBy

stdSort

InsertionSort

QuickSort