Calculating the total sum of values within a JSON array

Question

Calculating the total sum of values within a JSON array

Here is the data that I am working with:

input1 =

  [{

    "201609": 5,
    "201610": 7,
    "201611": 9,
    "201612": 10,
    "FY17": 24,
    "metric": "metric1",
    "careerLevelGroups": [{
        "201609": 3,
        "201610": 6,
        "201611": 9,
        "201612": 8
        "FY17": 18,
        "careerLevel": "Senior Managing Director",
        "careerLevels": [{
                "201609": 1,
                "201610": 2,
                "201611": 3,
                "201612": 5
                "FY17": 6,
                "careerLevel": "CL1"
            },
            {
                "201609": 2,
                "201610": 4,
                "201611": 6,
                "201612": 9
                "FY17": 12,
                "careerLevel": "CL2"
            }
        ]
    }]
}]

input2 =

   [{

        "201609": 4,
        "201610": 8,
        "201611": 12,

        "FY17": 24,
        "metric": "metric1",
        "careerLevelGroups": [{
            "201609": 9,
            "201610": 2,
            "201611": 7,
            "FY17": 18,
            "careerLevel": "Senior Managing Director",
            "careerLevels": [{
                    "201609": 3,
                    "201610": 6,
                    "201611": 9,
                    "FY17": 18,
                    "careerLevel": "CL1"
                },
                {
                    "201609": 7,
                    "201610": 8,
                    "201611": 9,
                    "FY17": 24,
                    "careerLevel": "CL2"
                }
            ]
        }]
    }]

output = input1 + input2.

The final output should be a sum of all the numeric values. Even if a key like "201612" does not match in both inputs, it should still be included in the output.

 [{

    "201609": 9,
    "201610": 15,
    "201611": 21,
    "201612": 10,
    "FY17": 48,
    "metric": "metric1",
    "careerLevelGroups": [{
        "201609": 12,
        "201610": 8,
        "201611": 16,
        "201612": 8,
        
        "FY17": 24,
        "careerLevel": "Senior Managing Director",
        "careerLevels": [{
                "201609": 4,
                "201610": 8,
                "201611": 12,
                "201612": 5,
                "FY17": 24,
                "careerLevel": "CL1"
            },
            {
                "201609": 9,
                "201610": 12,
                "201611": 15,
                "201612": 9,
                "FY17": 36,
                "careerLevel": "CL2"
            }
        ]
    }]
}]

This is my approach:

var output = [{}];

for(let i in input){    
  for (let key in input[i]){
      if (output[0].hasOwnProperty(key)) {

    output[0][key]+=input[i][key];
    }else{
    output[0][key]=input[i][key];
    }
 }
}

console.log(JSON.stringify(output)); // encountering errors

However, this method is not providing the desired outcome as it struggles to handle the hierarchical json structure depicted above.

javascript arrays json typescript

Answer 1

Answer №1

To begin, let's create the primary merge function:

function merge(x, y, fn) {

    if (isNotCompound(x) && isNotCompound(y)) {
        return fn(x, y);
    }

    if (isArray(x) && isArray(y)) {
        return mergeArray(x, y, fn);
    }

    if (isObject(x) && isObject(y)) {
        return mergeObject(x, y, fn);
    }

    throw new Error('the two input values are not of the same compound type');
}

The main functionality of the merge function lies in determining the type of the input values x and y. If both are determined to be primitive types (i.e., not arrays or objects), they are merged using the provided fn function. Otherwise, specific helper functions are selected for further processing.

Next, we need to define the necessary type predicates for the dispatching process:

   const isArray = x => Array.isArray(x);
   const isObject = x => Object.prototype.toString.call(x) === '[object Object]';
   const isNotCompound = x => !isArray(x) && !isObject(x);

With these predicates in place, we can proceed to implement the mergeArray and mergeObject functions. The following is one possible implementation for mergeArray:

function mergeArray(xs, ys, fn) {
    if (xs.length !== ys.length) throw new Error('the two arrays must be of the same size');
    let r = [];
    for (let i = 0; i < xs.length; i++) {
      r.push(merge(xs[i], ys[i], fn));
    }  
    return r;
}

In this implementation, mergeArray requires that the two arrays have the same length. As for mergeObject, a possible implementation could look like this:

function mergeObject(obj1, obj2, fn) {
  let r = {};
  for (let key of Object.keys(obj1)) {
    r[key] = obj2[key] ? merge(obj1[key], obj2[key], fn) : obj1[key];
  }
  for (let key of Object.keys(obj2)) {
    if (r[key]) continue;
    r[key] = obj2[key];
  }
  return r;
}

For common keys, property values are combined while unshared properties are directly included in the resulting object.

Finally, the desired merging behavior can be achieved by defining the input function as follows:

const isNumber = x => typeof x === 'number';
const add = (x, y) => isNumber(x) && isNumber(y) ? x + y : (x || y);

If both primitive input values are numbers, it returns their sum; otherwise, it returns whichever value is defined.

To complete the process, execute the following:

console.log(JSON.stringify(merge(input1, input2, add)));

The full source code is presented below.

const isArray = x => Array.isArray(x);
const isObject = x => Object.prototype.toString.call(x) === '[object Object]';
const isNotCompound = x => !isArray(x) && !isObject(x);

function merge(x, y, fn) {

  if (isNotCompound(x) && isNotCompound(y)) {
    return fn(x, y);
  }

  if (isArray(x) && isArray(y)) {
    return mergeArray(x, y, fn);
  }

  if (isObject(x) && isObject(y)) {
    return mergeObject(x, y, fn);
  }

  throw new Error('the two input values are not of the same compound type');
}; 

function mergeArray(xs, ys, fn) {
    if (xs.length !== ys.length) throw new Error('the two arrays must be of the same size');
    let r = [];
    for (let i = 0; i < xs.length; i++) {
      r.push(merge(xs[i], ys[i], fn));
    }  
    return r;
}

function mergeObject(obj1, obj2, fn) {
  let r = {};
  for (let key of Object.keys(obj1)) {
    r[key] = obj2[key] ? merge(obj1[key], obj2[key], fn) : obj1[key];
  }
  for (let key of Object.keys(obj2)) {
    if (r[key]) continue;
    r[key] = obj2[key];
  }
  return r;
}


let input1 = [{...

...merge(input1, input2, add)));

Answer 2

To begin, let's create the primary merge function:

function merge(x, y, fn) {

    if (isNotCompound(x) && isNotCompound(y)) {
        return fn(x, y);
    }

    if (isArray(x) && isArray(y)) {
        return mergeArray(x, y, fn);
    }

    if (isObject(x) && isObject(y)) {
        return mergeObject(x, y, fn);
    }

    throw new Error('the two input values are not of the same compound type');
}

The main functionality of the merge function lies in determining the type of the input values x and y. If both are determined to be primitive types (i.e., not arrays or objects), they are merged using the provided fn function. Otherwise, specific helper functions are selected for further processing.

Next, we need to define the necessary type predicates for the dispatching process:

   const isArray = x => Array.isArray(x);
   const isObject = x => Object.prototype.toString.call(x) === '[object Object]';
   const isNotCompound = x => !isArray(x) && !isObject(x);

With these predicates in place, we can proceed to implement the mergeArray and mergeObject functions. The following is one possible implementation for mergeArray:

function mergeArray(xs, ys, fn) {
    if (xs.length !== ys.length) throw new Error('the two arrays must be of the same size');
    let r = [];
    for (let i = 0; i < xs.length; i++) {
      r.push(merge(xs[i], ys[i], fn));
    }  
    return r;
}

In this implementation, mergeArray requires that the two arrays have the same length. As for mergeObject, a possible implementation could look like this:

function mergeObject(obj1, obj2, fn) {
  let r = {};
  for (let key of Object.keys(obj1)) {
    r[key] = obj2[key] ? merge(obj1[key], obj2[key], fn) : obj1[key];
  }
  for (let key of Object.keys(obj2)) {
    if (r[key]) continue;
    r[key] = obj2[key];
  }
  return r;
}

For common keys, property values are combined while unshared properties are directly included in the resulting object.

Finally, the desired merging behavior can be achieved by defining the input function as follows:

const isNumber = x => typeof x === 'number';
const add = (x, y) => isNumber(x) && isNumber(y) ? x + y : (x || y);

If both primitive input values are numbers, it returns their sum; otherwise, it returns whichever value is defined.

To complete the process, execute the following:

console.log(JSON.stringify(merge(input1, input2, add)));

The full source code is presented below.

const isArray = x => Array.isArray(x);
const isObject = x => Object.prototype.toString.call(x) === '[object Object]';
const isNotCompound = x => !isArray(x) && !isObject(x);

function merge(x, y, fn) {

  if (isNotCompound(x) && isNotCompound(y)) {
    return fn(x, y);
  }

  if (isArray(x) && isArray(y)) {
    return mergeArray(x, y, fn);
  }

  if (isObject(x) && isObject(y)) {
    return mergeObject(x, y, fn);
  }

  throw new Error('the two input values are not of the same compound type');
}; 

function mergeArray(xs, ys, fn) {
    if (xs.length !== ys.length) throw new Error('the two arrays must be of the same size');
    let r = [];
    for (let i = 0; i < xs.length; i++) {
      r.push(merge(xs[i], ys[i], fn));
    }  
    return r;
}

function mergeObject(obj1, obj2, fn) {
  let r = {};
  for (let key of Object.keys(obj1)) {
    r[key] = obj2[key] ? merge(obj1[key], obj2[key], fn) : obj1[key];
  }
  for (let key of Object.keys(obj2)) {
    if (r[key]) continue;
    r[key] = obj2[key];
  }
  return r;
}


let input1 = [{...

...merge(input1, input2, add)));

Answer 3

Answer №2

Implement a recursive function that utilizes the forEach method to iterate through an array. The logic is as follows - rather than iterating over both the arrays input1 and input2, loop through one of them. If a key's value is a number, add it to the corresponding key's value in the other array. If a key's value is an array, recursively call the same function with new arguments.

var input1 = [{
  "201609": 5,
  "201610": 7,
  ...
  
  // Rest of the code removed for brevity

Answer 4

Implement a recursive function that utilizes the forEach method to iterate through an array. The logic is as follows - rather than iterating over both the arrays input1 and input2, loop through one of them. If a key's value is a number, add it to the corresponding key's value in the other array. If a key's value is an array, recursively call the same function with new arguments.

var input1 = [{
  "201609": 5,
  "201610": 7,
  ...
  
  // Rest of the code removed for brevity

Calculating the total sum of values within a JSON array

Answer №1

Answer №2

Similar questions

Unable to successfully call a directive function from a nested child directive

An excellent user interface that enables the user to easily reset a field to its original default value

Storing client-requested data locally

What is the best way to embed HTML code within an amp-list component?

Issue with Typescript and react-create-app integration using Express

Modifying the attributes/properties within a class of a bootstrap button

Encountering a TypeError while attempting to retrieve an instance of AsyncLocalStorage

Reposition the checked box to the top of the list

I am unable to employ filtering in TypeScript

A guide on initiating a get request with URL in React

React components need to refresh after fetching data from an API

What is the best method to close a polygon infowindow when hovering over a map marker?

The map buttons are located underneath the map, and unfortunately, it seems that setting the map height to 100% using Angular is

PHP: A Guide to Retrieving Specific JSON Data Points

React Native implementation of multiple checkboxes

How can esbuild be used to load .wglsl files in Typescript files?

RC6 - What is the significance of encountering an 'Unexpected token <' error message?

Switching on and off a class in Next.js

The extent of a nameless function when used as a parameter

Convert a single JSONObject into a JSONArray