Question

我在排序这些嵌套对象时遇到问题;我的目标是：

Array of objects: [Object, Object]

在这个数组中有两个对象，这些对象里面有一个对象：2016-5:Object 2016-6:Object

在两个对象中，每个对象都是内部只有1个数字的数组：

shift0:Array[1]
shift1:Array[1]
shift2:Array[1]
shift3:Array[1]

并且数组内部只有一个这样的数字（所有数组的索引为0）：

shift0:Array[1] -> 26
shift1:Array[1] -> 42
shift2:Array[1] -> 53
shift3:Array[1] -> 31

我希望能够对数字进行排序 - 26,42,53,31

所以它看起来像

var source = [{'2016-5': [{shift0: [26]}, 
                       {shift1: [42]}, 
                       {shift2: [53]}, 
                       {shift3: [31]}]},
           {'2016-6':  [{shift0: [33]}, 
                        {shift1: [15]}, 
                        {shift2: [13]}, 
                        {shift3: [66]}]}
 ];

我想要的结果应该是：

var source = [{'2016-5': [{shift0: [26]}, 
                           {shift3: [31]}, 
                           {shift1: [42]}, 
                           {shift2: [53]}]},
               {'2016-6':  [{shift2: [13]}, 
                            {shift1: [15]}, 
                            {shift0: [33]}, 
                            {shift3: [66]}]}
     ];

Answer 1

试试这个

var source =  [{'2016-5': [{shift0: [26]}, 
                       {shift1: [42]}, 
                       {shift2: [53]}, 
                       {shift3: [31]}]},
           {'2016-6':  [{shift0: [33]}, 
                        {shift1: [15]}, 
                        {shift2: [13]}, 
                        {shift3: [66]}]}
 ];

source.forEach( function(obj){
   Object.keys(obj).forEach( function(key){
      console.log(obj[key]);
      obj[key].sort( function(a,b){
         return a[ Object.keys(a)[0] ]  - b[ Object.keys(b)[0] ] ;
      })
   });
});

document.body.innerHTML += JSON.stringify(source, 0, 4 );

Answer 2

您提供的JSON无效，假设您的JSON如下：

var source = [{'2016-5': [{shift0: [26]}, 
                           {shift0: [42]}, 
                           {shift0: [53]}, 
                           {shift0: [31]}]},
               {'2016-6':  [{shift0: [33]}, 
                            {shift0: [15]}, 
                            {shift0: [13]}, 
                            {shift0: [66]}]}
 ];

然后你可以尝试：

var result =
         source.map(function(item){
                    Object.keys(item)
                          .map(function(key){
                                 item[key] = 
                                      item[key].sort(function(p, c){
                                             return p.shift0[0]-c.shift0[0];
                                      });
                           });
                     return item;
         });

如何排序两个嵌套对象？

2 个答案: