在C＃中创建嵌套的对象在javascript像groupby＃

Question

IList<Customer> Customers = 
      flat.GroupBy(cust => new { cust.ReferenceNumber, cust.Name, cust.Address }) 
       .Select(c => new Customer() 
       { 
        ReferenceNumber = c.Key.ReferenceNumber, 
        Name = c.Key.Name, 
        Address = c.Key.Address, 
        Orders = c.Select(o => new Order() 
        { 
         OrderId = o.OrderId, 
         ProductName = o.ProductName, 
         Description = o.Description, 
         Amount = o.Amount 
        }).ToList() 
       }).ToList() 

正在采取一个扁平列表并将其转换为一个嵌套的对象可能在Javascript中？ 一个通用的解决方案是??

Answer 1

是的。

您可以在JavaScript中传递函数，这与C＃代码中的lambda表达式具有相同的用途。就拿使用jQuery的“每个”作为一个例子：

$('div.several').each(function() { 
    // Do something with the current div. 
}); 

您还可以创建嵌套的对象很容易：

var outer = { 
    inner1: { 
     val1: 'a', 
     val2: 'b' 
    }, 
    inner2: { 
     val1: 'c', 
     val2: 'd' 
    } 
}; 

当然，你也可以做到这一点动态的，而不是一下子：

var outer = {}; 
outer.inner1 = {}; 
outer.inner1.val1 = 'a'; 
... 

然后，你要查找的内容，你需要使用数组：

var result = []; 
for (var i=0; i<x; ++i) { 
    result[result.length] = GetIndividualResult(i); 
} 

Answer 2

尽管这是一个老问题，我想我会提供了一个更优雅的解决方案：

/** 
* Groups an array of objects by one or more keys 
* 
* @param array arr  The array of objects to group 
* 
* @param string|function A string representing the child property to group by 
*      or a function that returns an array of one or more properties. 
* 
* @returns    An object with keys representing the grouping properties, 
*      finally holding an array of records that fell into 
*      those groups. 
*/ 
var group = function(items, by) { 
    var groups = {}, 
     group, 
     values, 
     i = items.length, 
     j, 
     key, 
     group_keys; 

    // make sure we specified how we want it grouped 
    if(!by) { return items; } 
    while(i--) { 

     // find out group values for this item 
     values = (typeof(by) === "function" && by(items[i]) || 
        typeof items[i] === "object" && items[i][by] || 
        items[i]); 

     // make sure our group values are an array 
     values = values instanceof Array && values || [ values ]; 

     // recursively group 
     group = groups; 
     for(j = 0; j < values.length; j++) { 
      key = values[j]; 
      group = (group [key] || (group [key] = j === values.length - 1 && [] || {})); 
     } 

     // for the last group, push the actual item onto the array 
     group = (group instanceof Array && group || []).push(items[i]); 
    } 

    return groups; 
}; 

与此调用它：

var items = [ 
    { "id" : 1, "name" : "foo", "category" : "a" }, 
    { "id" : 2, "name" : "foo", "category" : "a" }, 
    { "id" : 3, "name" : "bar", "category" : "b" }, 
    { "id" : 4, "name" : "free", "category" : "a" }, 
    { "id" : 5, "name" : "beer", "category" : "b" }, 
    { "id" : 6, "name" : "foo", "category" : "b" } 
]; 

var groups = group(items, function(item) { return [ item.category, item.name ]; }); 

此息率：

{ 
    b: { 
     foo: [ 
      { 
       id: 6 
       name: foo 
       category: b 
      } 
     ] 
     beer: [ 
      { 
       id: 5 
       name: beer 
       category: b 
      } 
     ] 
     bar: [ 
      { 
       id: 3 
       name: bar 
       category: b 
      } 
     ] 
    } 
    a: { 
     free: [ 
      { 
       id: 4 
       name: free 
       category: a 
      } 
     ] 
     foo: [ 
      { 
       id: 2 
       name: foo 
       category: a 
      } 
      { 
       id: 1 
       name: foo 
       category: a 
      } 
     ] 
    } 
} 

无论如何，希望这可以帮助别人。