对JavaScript中除一个元素之外的数组进行排序

我有一个数组，我正在对它进行排序，但我需要对数组中除一个元素以外的所有元素进行排序

我的阵列是：

var Comparison = [
    {key: "None", value: "None"},
    {key:"Geographical Area", value:"Geographical_Area"},
    {key:"Forests", value:"Forests"},
    {key:"Barren Unculturable Land", value:"Barren_Unculturable_Land"},
    {key:"Land put to Non agricultural use", value:"Land_put_to_Non_agricultural_use"},
    {key:"Land Area", value:"Land_Area"},
    {key:"Water Area", value:"Water_Area"},
    {key:"Culturable Waste", value:"Culturable_Waste"},
    {key:"Permanent Pastures", value:"Permanent_Pastures"},
    {key:"Land under Tree Crops", value:"Land_under_Tree_Crops"},
    {key:"Fallow Land excl Current Fallow", value:"Fallow_Land_excl_Current_Fallow"},
    {key:"Current Fallow", value:"Current_Fallow"},
    {key:"Total Unculturable Land", value:"Total_Unculturable_Land"},
    {key:"Net Sown Area", value:"Net_Sown_Area"},
    {key:"Gross Sown Area", value:"Gross_Sown_Area"},
    {key:"Cropping Intensity", value:"Cropping_Intensity"} ];

我正在使用以下代码对该数组进行排序：

var Comparison_sort = this.Comparison.sort(function (a, b) {
  if (a.key < b.key)
      return -1;
  if (a.key > b.key)
      return 1;
  return 0;
});

但我想要这样的结果：

   {key: "None", value: "None"}
   {key: "Barren Unculturable Land", value: "Barren_Unculturable_Land"}
   {key: "Cropping Intensity", value: "Cropping_Intensity"}
   {key: "Culturable Waste", value: "Culturable_Waste"}
    ....

我看到了答案，但我无法使用此答案解决我的问题。

var Comparison\u sort=this.Comparison.sort（函数（a，b）{
var Comparison_sort = this.Comparison.sort(function (a, b) {
  if(a.key == b.key) return 0;
  if (a.key == 'None') return -1;
  if (b.key == 'None') return 1;

  if (a.key < b.key)
      return -1;
  if (a.key > b.key)
      return 1;
  return 0;
});

如果（a.key==b.key）返回0；
如果（a.key=='None'），则返回-1；
如果（b.key=='None'），则返回1；
如果（a键b键）
返回1；
返回0；
});

---

告诉“执行常规排序，除非键为none，这意味着它必须先进行排序。”

只需在开头添加一个检查。如果是“无”对象，则将其移动到前面，而不执行检查

var Comparison_sort = this.Comparison.sort(function (a, b) {
    if (a.key == "None" && a.value == "None")
        return -1;
    if (b.key == "None" && b.value == "None")
        return 1;
    if (a.key < b.key)
            return -1;
    if (a.key > b.key)
            return 1;
    return 0;
});

var Comparison\u sort=this.Comparison.sort（函数（a，b）{
如果（a.key==“None”&&a.value==“None”）
返回-1；
如果（b.key==“None”&&b.value==“None”）
返回1；
如果（a键b键）
返回1；
返回0；
});

可能有更好的方法，但这应该是可行的：

从数组中筛选特殊值

在不使用特殊值的情况下对数组进行排序

将特殊值重新插入数组中

---

有关良好的工作示例，请参见

您可以使用

reduce

获得所需的输出：

var比较=[{key:“地理区域”，value:“地理区域”}，{key:“森林”，value:“森林”}，{key:“贫瘠的非耕地”，value:“贫瘠的非耕地”}，{key:“无”，value:“无”}，{key:“土地非农业利用”，value:“土地非农业利用”}，{key:“土地面积”，value:“土地面积”}，{key:“水域”，价值：“水域”，价值：{key:“可养殖废弃物”，价值：{key:“永久牧场”，价值：{key:“永久牧场”}，价值：{key:“树木下的土地”，价值：{key:“树木下的土地”}，价值：{key:“休耕土地，不包括当前休耕地”，价值：{key:“休耕土地，不包括当前休耕地”}，价值：{key:“当前休耕地”}，{key:“总非耕地”，价值：“总非耕地”}，{关键字：“净播种面积”，价值：“净播种面积”}，{关键字：“总播种面积”，价值：“总播种面积”}，{关键字：“种植强度”，价值：“种植强度”}，]
变量比较\排序=比较
.sort（（a，b）=>a.key.localeCompare（b.key））
.减少（（acc，e）=>{
e、 按键==‘无’？加速取消换档（e）：加速推动（e）；
返回acc；
}, []);
console.log（Comparison_sort）；

或者，您可以过滤掉none并对其他元素进行排序。然后在末尾将它们重新连接起来

const comparison=[{key:“无”，value:“无”}，{key:“地理区域”，value:“地理区域”}，{key:“森林”，value:“森林”}，{key:“贫瘠的未开垦土地”，value:“贫瘠的未开垦土地”}，{key:“土地非农业利用”，value:“土地非农业利用”}，{key:“土地面积”，value:“土地面积”}，{key:“水域”，value:“水域”}，{key:“可养殖废弃物”，value:“可养殖废弃物”}，{key:“永久牧场”，value:“永久牧场”}，{key:“树木下的土地”，value:“树木下的土地”}，{key:“不包括当前休耕的休耕土地”，value:“休耕土地不包括当前休耕”}，{key:“当前休耕”，value:“当前休耕”}，{key:“总非耕地”，value:“总非耕地”}，{key:“净播种面积”，value:“净播种面积”}，{key:“总播种面积”，value:“总播种面积”}，{key:“种植强度”，value:“种植强度”}；
常量结果=比较
.filter（e=>e.key=='None'）
康卡特先生(
comparison.filter（e=>e.key！=='None'）
.sort（（a，b）=>a.key.localeCompare（b.key））
);
console.log（result）；

这并不奇怪，但一种非常简单的方法是删除特殊元素，对数组进行排序，然后将特殊元素插入到所需的任何索引中

var比较=[{key:“无”，value:“无”}，{key:“地理区域”，value:“地理区域”}，{key:“森林”，value:“森林”}，{key:“贫瘠的未开垦土地”，value:“贫瘠的未开垦土地”}，{key:“土地非农业用途”，value:“土地非农业用途”}，{key:“土地面积”，value:“土地面积”“}，{key:“水域”，value:“水域”}，{key:“可养殖废弃物”，value:“可养殖废弃物”}，{key:“永久牧场”，value:“永久牧场”}，{key:“树木下的土地”，value:“树木下的土地”}，{key:“不包括当前休耕的休耕土地”，value:“休耕土地，不包括当前休耕的土地”}，{key:“当前休耕的土地”，value:“当前休耕地”}，{key:“总非耕地”}，value:“总非耕地”}，{key:“净播种面积”}，value:“净播种面积”}，{key:“总播种面积”，value:“总播种面积”}，{key:“种植强度”，value:“种植强度”}，]；
const idx=Comparison.findIndex（a=>a.key=='None'）；
const none=比较拼接（idx，1）；
比较.sort（（a，b）=>a.key.localeCompare（b.key））；
比较：拼接（0,0，无[0]）；
console.log（Comparison）；

.sort函数将回调作为参数。此回调将传递两个值。回调的任务是确定哪个值更大。它通过返回一个数值来执行此操作

假设传递给回调函数的参数被称为

a

和

b

。我已将回调函数在每种情况下应返回的值用粗体表示

• a

  小于0

• a>b

  大于0

• a=b

  等于0

这很容易记住，因为

var Comparison_sort = this.Comparison.sort(function (a, b) {
    if (a.key == "None" && a.value == "None")
        return -1;
    if (b.key == "None" && b.value == "None")
        return 1;
    if (a.key < b.key)
            return -1;
    if (a.key > b.key)
            return 1;
    return 0;
});

Comparison.sort(function(a, b) {
  // Our extra code
  if(a.key === b.key) return 0; // Zero (a = b)
  if(a.key === "None") return -1; // Negative (a < b)
  if(b.key === "None") return 1; // Positive (b < a)

  // Old sort
  if(a.key < b.key) return -1;
  if(b.key < a.key) return 1;  
})

if(a.key < b.key) return -1;
if(b.key < a.key) return 1;

return (b.key < a.key) - (a.key < b.key)

this.Comparison.sort(function (a, b) {
  if(a.key == b.key) return 0;
  if (a.key == 'None' || b.key == 'None') return -1;

  if (a.key < b.key)
      return -1;
  if (a.key > b.key)
      return 1;
  return 0;
});

const array1 = this.Comparison.filter(e => e.key === 'None');
const array2 = this.Comparison
            .filter(e => e.key !== 'None')
            .sort((a, b) => a.key.localeCompare(b.key));

this.Comparison = [].concat(array1, array2);