递归求和对象中的children属性

Question

Hi I have the following object:

const ob = 
{
   "children": [
     {
        "children": [],
        "code": "123",
        "estimateTime": 20,
        "groupId": 20,
        "id": 2044,
        "name": "1.1. CON ABC",
        "order": 2,
        "parentId": 2043
        },
     {
        "children": [
            {
            "children": [],
            "code": "123",
            "estimateTime": 20,
            "groupId": 20,
            "id": 2044,
            "name": "1.1. CON ABC",
            "order": 2,
            "parentId": 2043
          }
        ],
        "code": "123",
        "estimateTime": 20,
        "groupId": 20,
        "id": 2044,
        "name": "1.1. CON ABC",
        "order": 2,
        "parentId": 2043
        },
   ],
  "code": "CONG VIEC 1",
  "estimateTime": 50,
  "groupId": 20,
  "id": 2043,
  "name": "1. abc",
  "order": 1,
  "parentId": null
};

the children property is itself an array containing the same objects as their parent.

How would I recursively sum all the estimateTime value inside the children and display it into the parent's estimateTime?

I tried the following but it not sum all the values of estimateTime:

let estimateTime = ob.estimateTime;
function sumRecur(obj){
    if(obj.hasOwnProperty("children")){
      for(var i = 0;i<obj["children"].length;i++){
        estimateTime += obj.children[i].estimateTime
      } 
      return estimateTime;
    } 
  return sumRecur(obj.children);
}

It returns 90 instead of 110.

I would really appreciate any help

Answer 1

You're trying to do too much work here. Think of it this way: the total estimate for an element is its estimated time plus the sum of the total estimatess for each of its children. That converts almost directly to code.

 const sum = (nbrs) => nbrs .reduce ((a, b) => a + b, 0) const totalEstimate = (ob) => ob .estimateTime + sum (ob .children .map (totalEstimate) ) const ob = {"children": [{"children": [], "code": "123", "estimateTime": 20, "groupId": 20, "id": 2044, "name": "1.1. CON ABC", "order": 2, "parentId": 2043}, {"children": [{"children": [], "code": "123", "estimateTime": 20, "groupId": 20, "id": 2044, "name": "1.1. CON ABC", "order": 2, "parentId": 2043}], "code": "123", "estimateTime": 20, "groupId": 20, "id": 2044, "name": "1.1. CON ABC", "order": 2, "parentId": 2043}], "code": "CONG VIEC 1", "estimateTime": 50, "groupId": 20, "id": 2043, "name": "1. abc", "order": 1, "parentId": null}; console .log ( totalEstimate (ob) ) 

I think the extraction of the sum helper function makes this more readable, and sum is clearly a useful function on its own. But if you prefer, you could inline it:

const totalEstimate = (ob) => 
  ob .estimateTime + 
  ob .children .map (totalEstimate) .reduce ((a, b) => a + b, 0)

This question results in one of those pleasant recursions where the base case is handled automatically -- because sum on an empty array returns 0. But if instead of containing an empty array as a children property, an element with no children simply had no children property, then the change would be relatively simple:

const totalEstimate = (ob) => 
  ob .estimateTime + (ob .children ? sum (ob .children .map (totalEstimate) ) : 0)

Note also how easily this can now be abstracted to total on an arbitrary property:

 const sum = (nbrs) => nbrs .reduce ((a, b) => a + b, 0) const totalProp = (prop) => (ob) => ob [prop] + sum (ob .children .map (totalProp (prop) )) const ob = {"children": [{"children": [], "code": "123", "estimateTime": 20, "groupId": 20, "id": 2044, "name": "1.1. CON ABC", "order": 2, "parentId": 2043}, {"children": [{"children": [], "code": "123", "estimateTime": 20, "groupId": 20, "id": 2044, "name": "1.1. CON ABC", "order": 2, "parentId": 2043}], "code": "123", "estimateTime": 20, "groupId": 20, "id": 2044, "name": "1.1. CON ABC", "order": 2, "parentId": 2043}], "code": "CONG VIEC 1", "estimateTime": 50, "groupId": 20, "id": 2043, "name": "1. abc", "order": 1, "parentId": null}; console .log ( totalProp ('estimateTime') (ob) ) 

This function can now be used to sum a recursive tree on any named property. And there are other abstractions that can easily be carried out here. (What if it were "subitems" rather than "children" , for instance?)