Javascript 使用动态键对嵌套的对象数组进行排序

我试图创建一个排序函数，对嵌套的对象数组进行排序，同时动态地给出一个键（具有不同的深度）

sortByKey（数组，键）{
var splitKey=key.split（“.”）；
如果（splitKey.length=2）{
返回array.sort（函数（a，b）{
变量x=a[splitKey[0]][splitKey[1]]；变量y=b[splitKey[0]][splitKey[1]]；
回报率（（xy）？1:0）；
});
}否则{
返回array.sort（函数（a，b）{
变量x=a[key]；变量y=b[key]；
回报率（（xy）？1:0）；
});
}
}

我想去掉

if-else

，改为使用

for

循环。目标是该函数与“name”、“name.first”和“name.first.other”一起工作（例如）。有没有一种方法可以动态地做到这一点

---

换句话说，我想对不同的数组使用相同的函数。因此，我想用一个数组对它进行排序，调用sortByKey（array1，'name'），用另一个sortByKey（array2，'location.address'），也许用第三个sortByKey（array3，'location.address.postalcode'）或类似的东西。

提取属性提取函数

function prop(key) {
  var keys = key.split('.');

  return keys.reduce.bind(keys, function(obj, name) {
    return obj[name]
  })
}

并使用它很好地提取值：）

sortByKey（数组，键）{
var getKey=prop（key）；
返回array.sort（函数（a，b）{
变量x=getKey（a）；变量y=getKey（b）；
回报率（（xy）？1:0）；
})
}

我想你的意思是这样的：

function sortByKey(array, key){
    var splitKey = key.split(".");

    return array.sort(function(a, b) {
        var ta = a;
        var tb = b;
        for (var i=0; i<splitKey.length; i++) {
            ta = ta[splitKey[i]];
        };
        /// return ((a < b) ? -1 : ((a > b) ? 1 : 0)); // Too complex ;-)
        return a - b;

    });

};

函数排序键（数组，键）{
var splitKey=key.split（“.”）；
返回array.sort（函数（a，b）{
var ta=a；
var-tb=b；
对于（VARI=0；IB）？1:0））；//太复杂；-）
返回a-b；
});
};

您的问题是一个误用的作业，应该是一个比较

if (splitKey.length === 2) {
//                  ^^^

可以使用更短的方法

函数排序键（数组，键）{
var getValue=函数（o，k）{返回o[k]；}，
keys=key.split（“.”）；
返回array.sort（函数（a，b）{
返回keys.reduce（getValue，a）-keys.reduce（getValue，b）；
});
}
var数组=[{a:5，b:{c:2}，{a:7，b:{c:1}，{a:1，b:{c:3}]；
sortByKey（数组，'a'）；
console.log（数组）；
sortByKey（数组，'b.c'）；
console.log（数组）

如果（splitKey.length=2）

不太可能做你想做的事。你能提供一个你想做的事情的例子吗？这个解决方案非常简单和优雅，值得更多的投票：）

.reduce.bind（）

（以及随后的

getKey（）

）-感谢你展示了一个很好的例子！

function sortByKey(array, key){
    var splitKey = key.split(".");

    return array.sort(function(a, b) {
        var ta = a;
        var tb = b;
        for (var i=0; i<splitKey.length; i++) {
            ta = ta[splitKey[i]];
        };
        /// return ((a < b) ? -1 : ((a > b) ? 1 : 0)); // Too complex ;-)
        return a - b;

    });

};

if (splitKey.length === 2) {
//                  ^^^