How to find the minimum, maximum and average value of all property of array of objects-CodePudding

I have an array of objects with different values in it, I want to find the min, max, and average of the properties in that array

for eg if I have an array

const array = [{
    "a": "-0.06",
    "b": "0.25",
    "c": "-0.96",
    "d": "-0.14"
  },
  {
    "a": "-0.37",
    "b": "0.01",
    "c": "-0.77",
    "d": "-0.09"
  },
  {
    "a": "0.01",
    "b": "0.88",
    "c": "-0.53",
    "d": "-0.28"
  },
  {
    "a": "0.53",
    "b": "-0.62",
    "c": "0.02",
    "d": "0.74"
  },
  {
    "a": "0.79",
    "b": "-0.39",
    "c": "0.70",
    "d": "0.18"
  },
  {
    "a": "0.74",
    "b": "-0.14",
    "c": "0.22",
    "d": "-0.58"
  }
]

So the output will be as given below

const out = [{
  property: a,
  minValue: -0.37,
  maxValue: .79,
  avg: 0.2733333333333334
}, {
  property: b,
  minValue: -.62,
  maxValue: .88,
  avg: -0.0016666666666666496
}, {
  property: c,
  minValue: -.96,
  maxValue: .07,
  avg: -0.21999999999999997
}, {
  property: d,
  minValue: -.58,
  maxValue: .74,
  avg: -0.028333333333333332
}]

So to get the output we iterate to the array and find the minimum, maximum, and average value of a, b , c and d and store it in a new array

CodePudding user response：

here is a two step approach. First i grouped the array on property using reduce. Then I performed a map on the grouped object to get the min, max and the average

const array = [{    "a": "-0.06",    "b": "0.25",    "c": "-0.96",    "d": "-0.14"  },  {    "a": "-0.37",    "b": "0.01",    "c": "-0.77",    "d": "-0.09"  },{    "a": "0.01",    "b": "0.88",    "c": "-0.53",    "d": "-0.28"  },  {    "a": "0.53",    "b": "-0.62",    "c": "0.02",    "d": "0.74"  },  {    "a": "0.79",    "b": "-0.39",    "c": "0.70",    "d": "0.18"  },  {    "a": "0.74",    "b": "-0.14",    "c": "0.22",    "d": "-0.58"  }]

const grouped = array.reduce((acc,curr) => {
    Object.entries(curr).forEach(([property,v])=>{
    acc[property] = acc[property] || []
    acc[property].push( v) //  for convert to a number before pushing
  })
  return acc
},{})

const out = Object.entries(grouped).map(([property,v]) => {
    return {
    property,
    minValue: Math.min(...v),  // min of an array. v is the array of numbers
    maxValue: Math.max(...v),  //max of an array
    avg: v.reduce((a, b) => a   b) / v.length //average of an array
  }
})

console.log(out)

CodePudding user response：

You use Array.reduce and start with an object like the result but with extreme values, so for min there is the max. Or, depending on your spec it is undefined for any empty input array.

CodePudding user response：

Here's an approach, first we make a map that looks something like this

{ a : ['-0.06', '-0.06', '-0.37', '0.01', '0.53', '0.79', '0.74'] 
 b: ['0.25', '0.25', '0.01', '0.88', '-0.62', '-0.39', '-0.14'],
 ...
}

And then we run a single loop through every value in the map to find max, min and average.

const array = [{    "a": "-0.06",    "b": "0.25",    "c": "-0.96",    "d": "-0.14"  },  {    "a": "-0.37",    "b": "0.01",    "c": "-0.77",    "d": "-0.09"  },{    "a": "0.01",    "b": "0.88",    "c": "-0.53",    "d": "-0.28"  },  {    "a": "0.53",    "b": "-0.62",    "c": "0.02",    "d": "0.74"  },  {    "a": "0.79",    "b": "-0.39",    "c": "0.70",    "d": "0.18"  },  {    "a": "0.74",    "b": "-0.14",    "c": "0.22",    "d": "-0.58"  }]

const getStats = (data) => {
  const valueMap = {};

  data.forEach((item) => {
    Object.entries(item).forEach(([key, value]) => {
        if (!valueMap[key]) {
            valueMap[key] = [value];
        }
        valueMap[key].push(value);
     });
  });

 return Object.entries(valueMap).map(([key, value]) => ({
     property: key,
     ...getMinMaxAndAvg(value)
    }));
 };

const getMinMaxAndAvg = (arr) => {
 let minValue = Number.MAX_VALUE;
 let maxValue = Number.MIN_VALUE;
 let total = 0;

 arr.forEach((val) => {
     if (val > maxValue) {
         maxValue = val;
     }

     if (val < minValue) {
         minValue = val;
     }

     total  =  (val);
 });

 return {
     minValue,
     maxValue,
     avg: total / arr.length
  };
 };

console.log(getStats(array));

CodePudding user response：

Use the following function: `

const createNewObj = (previous, current) => ({
  minValue: Math.min(previous, current,
  maxValue: Math.max(previous, current,
  total: previous   current,
  length: previous.length   1,
  avg: (previous   current) / (previous.length   1)
})

const default = {
  minValue: 0,
  maxValue: 0,
  total: 0,
  length: 0,
  avg: 0
}

array.reduce((previous, current) => {
a: createNewObj(previous[a], current[a]), 
b: createNewObj(previous[b], current[b]), 
c: createNewObj(previous[c], current[c]), 
d: createNewObj(previous[d], current[d])
}
, {
a: default,
b: default, 
c: default, 
d: default
})

CodePudding user response：

I have followed a two step process -

Group the values of each property (using reduce for this)
Loop through all the properties and compute the required result.

const array = [{    "a": "-0.06",    "b": "0.25",    "c": "-0.96",    "d": "-0.14"  },  {    "a": "-0.37",    "b": "0.01",    "c": "-0.77",    "d": "-0.09"  },{    "a": "0.01",    "b": "0.88",    "c": "-0.53",    "d": "-0.28"  },  {    "a": "0.53",    "b": "-0.62",    "c": "0.02",    "d": "0.74"  },  {    "a": "0.79",    "b": "-0.39",    "c": "0.70",    "d": "0.18"  },  {    "a": "0.74",    "b": "-0.14",    "c": "0.22",    "d": "-0.58"  }]

const out = [];

const newObj = array.reduce((prevValue, currValue) => {
  Object.keys(currValue).forEach((el) => {
    if (prevValue[el]) {
      prevValue[el].push(Number(currValue[el]));
    } else {
      prevValue[el] = [Number(currValue[el])];
    }
  });
  return prevValue;
}, {});

Object.keys(newObj).forEach((el) => {
  out.push({
    property: el,
    minValue: Math.min(...newObj[el]),
    maxValue: Math.max(...newObj[el]),
    avg: newObj[el].reduce((a, b) => a   b, 0) / newObj[el].length
  });
});

console.log(out);

CodePudding user response：

const array = [{
    "a": "-0.06",
    "b": "0.25",
    "c": "-0.96",
    "d": "-0.14"
  },
  {
    "a": "-0.37",
    "b": "0.01",
    "c": "-0.77",
    "d": "-0.09"
  },
  {
    "a": "0.01",
    "b": "0.88",
    "c": "-0.53",
    "d": "-0.28"
  },
  {
    "a": "0.53",
    "b": "-0.62",
    "c": "0.02",
    "d": "0.74"
  },
  {
    "a": "0.79",
    "b": "-0.39",
    "c": "0.70",
    "d": "0.18"
  },
  {
    "a": "0.74",
    "b": "-0.14",
    "c": "0.22",
    "d": "-0.58"
  }
]

var out = [

]

Object.keys(array[0]).map(v=>{//this is so it runs for all 4 properties 
    let temp = {
  property:v
  }
  //sort array to get min and max
  let ary = [...array].sort((a,b)=>{
    return a-b
  })
  /* console.log(ary) */
  let avg = 0;
  ary.map(i=>{
    avg = avg Number(i[v]);
  })
  temp.avg = avg/array.length
  temp.minValue = ary.pop()[v]
  temp.maxValue = ary.shift()[v]
  out.push(temp)
})
console.log(out)

see fiddel

CodePudding user response：

Below is the code snippet you can use

const array = [{
  "a": "-0.06",
  "b": "0.25",
  "c": "-0.96",
  "d": "-0.14"
},
{
  "a": "-0.37",
  "b": "0.01",
  "c": "-0.77",
  "d": "-0.09"
},
{
  "a": "0.01",
  "b": "0.88",
  "c": "-0.53",
  "d": "-0.28"
},
{
  "a": "0.53",
  "b": "-0.62",
  "c": "0.02",
  "d": "0.74"
},
{
  "a": "0.79",
  "b": "-0.39",
  "c": "0.70",
  "d": "0.18"
},
{
  "a": "0.74",
  "b": "-0.14",
  "c": "0.22",
  "d": "-0.58"
}
]


const grouped = array.reduce((acc, curr) => {
  for(let key in curr) {
    if(!acc[key]) {
      acc[key] = []
    }else {
      acc[key].push(curr[key])
    }
  }
  return acc;
}, {})

const output = []
for(let key in grouped) {
  const obj = {}
  const integers = grouped[key].map(el => parseFloat(el, 10))
  obj["property"] = key
  obj["minValue"] = Math.min(...integers)
  obj["maxValue"] = Math.max(...integers)
  obj["avg"] = (integers.reduce((prev, curr) => prev   curr) ) / integers.length;
  output.push(obj)
}
console.log(output)