按与另一个值相关的值的升序对对象数组进行排序

Question

我希望按与另一个值相关的值的升序对 JSON 对象数组进行排序。听起来令人困惑，因为它是。我在数组中的每个对象中都有属性“列”和“顺序”。我需要的顺序是： 第 1 列中的最小数字，第 2 列中的最小数字，第 3 列中的最小数字，第 1 列中的第二小数字，第 2 列中的第二小数字，第 3 列中的第二小数字，然后继续。当 'order' 具有完全相同的值时，这很容易，您可以使用如下排序函数：

function sortCourses(a, b){
    if (a.order == b.order) {
        return (a.column - b.column);
    } else {
        return (a.order - b.order);
    }
}

问题是我并不总是这样设置它们。这是一个示例数组：

[
    {
        column: 2,
        order: 5
    },
    {
        column: 1,
        order: 1
    },
    {
        column: 3,
        order: 2
    },
    {
        column: 3,
        order: 1
    },
    {
        column: 1,
        order: 4
    },
    {
        column: 2,
        order: 1
    },
    {
        column: 3,
        order: 3
    },
    {
        column: 1,
        order: 3
    },
    {
        column: 2,
        order: 3
    },
    {
        column: 1,
        order: 2
    }
]

排序后，我需要这个数组看起来像：

[
    {
        column: 1,
        order: 1
    },
    {
        column: 2,
        order: 1
    },
    {
        column: 3,
        order: 1
    },
    {
        column: 1,
        order: 2
    },
    {
        column: 2,
        order: 3
    },
    {
        column: 3,
        order: 2
    },
    {
        column: 1,
        order: 3
    },
    {
        column: 2,
        order: 5
    },
    {
        column: 3,
        order: 3
    },
    {
        column: 1,
        order: 4
    }
]

关于如何实现这一点的任何想法？

Answer 1

可能会快一点，但希望很容易理解。

const data = [
    { column: 2, order: 5 }, { column: 1, order: 1 }, { column: 3, order: 2 },
    { column: 3, order: 1 }, { column: 1, order: 4 }, { column: 2, order: 1 },
    { column: 3, order: 3 }, { column: 1, order: 3 }, { column: 2, order: 3 },
    { column: 1, order: 2 }
];

// Sort by order.
data.sort(function (a, b) {
  return (a.order - b.order);
});

// Group by column.
const groups = data.reduce(
  function (acc, value) {
    if (!acc[value.column]) {
      acc[value.column] = [];
    }
    acc[value.column].push(value);
    return acc;
  }, {});

// Get sorted columns.
const cols = Object.keys(groups).map(Number).sort();

// Loop over columns taking lowest value until we're out of values.
const out = [];
while (out.length < data.length) {
  cols.forEach(
    function (col) {
      if (groups[col].length) {
        out.push(groups[col].shift(0));
      }
    });
}

console.log(out);

Answer 2

一种相当冗长的方式，但我所做的只是将每个“组”（列）分组到一个对象中，将它们的订单推送到一个数组中。然后我只是将它们排序并粘贴进去。

var array = [
    {
        column: 2,
        order: 5
    },
    {
        column: 1,
        order: 1
    },
    {
        column: 3,
        order: 2
    },
    {
        column: 3,
        order: 1
    },
    {
        column: 1,
        order: 4
    },
    {
        column: 2,
        order: 1
    },
    {
        column: 3,
        order: 3
    },
    {
        column: 1,
        order: 3
    },
    {
        column: 2,
        order: 3
    },
    {
        column: 1,
        order: 2
    }
];

var new_array = {}

for (let item of array)
{
  if (item.column in new_array)
  {
    new_array[item.column].push(item.order);
  }
  else
  {
    new_array[item.column] = [item.order];
  }
}

let max = 0;
for (let key in new_array)
{
  max = (max < new_array[key].length) ? new_array[key].length : max;
  new_array[key].sort();
}

var final = [];

for (let i = 0; i < max; i++)
{
  for (let key in new_array)
  {
    if (i < new_array[key].length)
    {
      final.push({column: key, order: new_array[key][i]});
    }
  }
}


console.log(final);