用 2-3 个嵌套对数组进行排序 javascript/lodash

Question

无法理解如何对这种在嵌套数组中包含数组的数据进行排序...

var data = {
   d1: [{
      nest1: {a:5, b:2},
      nest2: {a:3, b:1},
   }],
   d3: [{
      nest1: {a:7, b:9},
      nest2: {a:1, b:22},
   }],
   d2: [{
      nest1: {a:1, b:9},
      nest2: {a:11, b:22},
   }],
}

所以基本上，想要按 a、b、键排序。

所以首先，我迭代了所有对象以获得一个数组（以便能够按键排序）

现在数据看起来像（只是示例）

data = [{
   key: "d1",
   obj: [{
      nest1: {a:1, b:2},
      nest2: {a:3, b:12},
   }]}],
  [{
   key: "d2",
   obj: [{
      nest1: {a:11, b:12},
      nest2: {a:13, b:22},
   }]}]

所以现在我可以轻松地按键排序 -

_.orderBy(vm.summaryData, 'key')

还是一头雾水，如何按data.obj.nest1.a排序？？

期望：按键本身排序：

data = {
   d1: [{
      nest1: {a:5, b:2},
      nest2: {a:3, b:1},
   }],
   d2: [{
      nest1: {a:1, b:9},
      nest2: {a:11, b:22},
   }],
   d3: [{
      nest1: {a:7, b:9},
      nest2: {a:1, b:22},
   }],
}

期望值：按 nest1.a:

排序

data = {
   d2: [{
      nest1: {a:1, b:9},
      nest2: {a:11, b:22},
   }],
   d1: [{
      nest1: {a:5, b:2},
      nest2: {a:3, b:1},
   }],
   d3: [{
      nest1: {a:7, b:9},
      nest2: {a:1, b:22},
   }],
}

预期：按 nest2.a:

排序

data = {
   d3: [{
      nest1: {a:7, b:9},
      nest2: {a:1, b:22},
   }],
   d1: [{
      nest1: {a:5, b:2},
      nest2: {a:3, b:1},
   }],
   d2: [{
      nest1: {a:1, b:9},
      nest2: {a:11, b:22},
   }],
}

等等...nest1.b, nest2.b.....

Answer 1

可以取属性的路径用字符串排序，用点隔开排序

function convert(object) {
    return Object
        .keys(object)
        .map(function (key) {
            return { key: key, obj: object[key] };
        });
}

var data = { d1: { nest1: { a: 1, b: 2 }, nest2: { a: 3, b: 12 } }, d2: { nest1: { a: 11, b: 1 }, nest2: { a: 13, b: 22 } } },
    result = convert(data);

console.log(_.orderBy(result, 'obj.nest1.b'));

.as-console-wrapper { max-height: 100% !important; top: 0; }

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.15.0/lodash.min.js"></script>

Answer 2

JavaScript 个对象未排序。尝试 "sort" 它们是没有意义的。但是，如果您使用排序键创建一个新对象，它将起作用。

var data = {d1: [{nest1: {a:5, b:2},nest2: {a:3, b:1},}],d3: [{nest1: {a:7, b:9},nest2: {a:1, b:22},}],d2: [{nest1: {a:1, b:9},nest2: {a:11, b:22},}],};

let sortData = (data, path) => {
  let sortedKey = !path ? Object.keys(data).sort() :
                 Object.keys(data).sort((ka,kb) => {
                 let key1 = path.split('.').reduce((o,i) => o[i],data[ka][0]),
                     key2 = path.split('.').reduce((o,i) => o[i],data[kb][0]);
                 return key1 - key2; 
                });

   return sortedKey.reduce((r,k) => { r[k] = data[k]; return r; },{})
}

console.log(sortData(data));
console.log(sortData(data,'nest1.a'));
console.log(sortData(data,'nest2.a'));

.as-console-wrapper { max-height: 100% !important; top: 0; }

用 2-3 个嵌套对数组进行排序 javascript/lodash

sorting an arrray with 2-3 nests javascript/lodash

javascript

arrays

sorting

underscore.js

lodash