Javascript 阵列中每小时的平均值

我有一个每分钟更新一次的数组。当我想在一天内展示它时，我想得到当天每小时的平均值

最近一分钟是添加数组的末尾

    //get the last elements from the array
    var hours= (this.today.getHours() + 1) * 60
    var data = Array.from(this.temps.data)
    let lastData = data.slice(Math.max(data.length - hours))

    let newData: any

    // calculate the average of every hour
    for (let i = 0; i < minutes; i++) {
      var cut = i * 60
      for (let i = cut; i < (cut + 60); i++) {
        newData = newData + lastData[i];
        let test = newData/60
        console.log(test);
      }
    }

我拥有的阵列每分钟更新一次。所以我需要平均每60个元素得到一个小时

数组看起来像这样

data[25,33,22,33]

这是每一分钟从一个星期这么长

这对我很有效

    var arrays = [], size = 60;

    while (arr.length > 0){
        arrays.push(arr.splice(0, size));
    }

    for (let i = 0; i < (arrays.length - 1); i++) {
      var sum = 0
        for (let b = 0; b < 60; b++) {
          sum += arrays[i][b]
        }
        let avg = sum/60
        arr2.push(avg)            
    }

var数组=[]，大小=60；
而（arr.length>0）{
阵列推送（阵列拼接（0，大小））；
}
for（设i=0；i<（arrays.length-1）；i++）{
var总和=0
for（设b=0；b<60；b++）{
总和+=数组[i][b]
}
设平均值=总和/60
arr2.推力（平均值）
}

这只是将数组每60个元素拆分一次。现在我可以计算出每60个的平均值。 副本

---

谢谢你的帮助

您可以按小时减少数据和分组，然后简单地映射以获得每个小时的平均值。我正在使用moment解析下面的日期，您可以使用您喜欢的任何lib/js来解析这些日期

const arr=Array.from（{length:100}，（）=>（{time:moment（）.subtract（Math.floor（Math.random（）*10），'hours'），value:Math.floor（Math.random（）*100））；
const group=[…arr.reduce（（a，b）=>{
设o=a.get（b.time.get（'hour'））|{value:0，qty:0}；
a、 set（b.time.get（'hour'），{value:o.value+b.value，qty:o.qty+1}）；
返回a；
}，新映射）].Map（[k，v]）=>({
[k] ：v.值/v.数量
}));
console.log（分组）

---

您可以按小时减少数据和分组，然后简单地映射以获得每个小时的平均值。我正在使用moment解析下面的日期，您可以使用您喜欢的任何lib/js来解析这些日期

const arr=Array.from（{length:100}，（）=>（{time:moment（）.subtract（Math.floor（Math.random（）*10），'hours'），value:Math.floor（Math.random（）*100））；
const group=[…arr.reduce（（a，b）=>{
设o=a.get（b.time.get（'hour'））|{value:0，qty:0}；
a、 set（b.time.get（'hour'），{value:o.value+b.value，qty:o.qty+1}）；
返回a；
}，新映射）].Map（[k，v]）=>({
[k] ：v.值/v.数量
}));
console.log（分组）

---

要测量每60个元素拆分阵列所需的平均值。 这就是我找到的解决方案

//Calculate the average of every 60 elements to get the average of an hour
var arr2: number[] = []
var arr: number[] = []
arr = Array.from(this.temps.data)
var arrays = [], size = 60;

while (arr.length > 0){
    arrays.push(arr.splice(0, size));
}

for (let i = 0; i < (arrays.length - 1); i++) {
  var sum = 0
    for (let b = 0; b < 60; b++) {
      sum += arrays[i][b]
    }
    let avg = sum/60
    arr2.push(avg)            
}

//计算每60个元素的平均值，得到一小时的平均值
var arr2:编号[]=[]
var arr:编号[]=[]
arr=Array.from（this.temps.data）
变量数组=[]，大小=60；
而（arr.length>0）{
阵列推送（阵列拼接（0，大小））；
}
for（设i=0；i<（arrays.length-1）；i++）{
var总和=0
for（设b=0；b<60；b++）{
总和+=数组[i][b]
}
设平均值=总和/60
arr2.推力（平均值）
}

---

毕竟，我认为获取数组的最后元素是愚蠢的，因为这是一个更好的解决方案。但是谢谢你的帮助

为了测量平均值，我需要每60个元素分割一次数组。 这就是我找到的解决方案

//Calculate the average of every 60 elements to get the average of an hour
var arr2: number[] = []
var arr: number[] = []
arr = Array.from(this.temps.data)
var arrays = [], size = 60;

while (arr.length > 0){
    arrays.push(arr.splice(0, size));
}

for (let i = 0; i < (arrays.length - 1); i++) {
  var sum = 0
    for (let b = 0; b < 60; b++) {
      sum += arrays[i][b]
    }
    let avg = sum/60
    arr2.push(avg)            
}

//计算每60个元素的平均值，得到一小时的平均值
var arr2:编号[]=[]
var arr:编号[]=[]
arr=Array.from（this.temps.data）
变量数组=[]，大小=60；
而（arr.length>0）{
阵列推送（阵列拼接（0，大小））；
}
for（设i=0；i<（arrays.length-1）；i++）{
var总和=0
for（设b=0；b<60；b++）{
总和+=数组[i][b]
}
设平均值=总和/60
arr2.推力（平均值）
}

---

毕竟，我认为获取数组的最后元素是愚蠢的，因为这是一个更好的解决方案。但是谢谢你的帮助

通过分组然后减少，您可以像下面这样做

函数groupBy（列表，keyGetter）{
常量映射={}；
list.forEach（（项目）=>{
const key=keyGetter（项目）；
如果（！映射[键]）{
映射[键]=[项]；
}否则{
映射[键]。推送（项）；
}
});
返回图；
}
常量数据=[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]；
const now=（新日期（））.getTime（）；
常数步长=60000*1；
constwithtime=data.reverse（）.map（（x，i）=>{return{time:newdate（now-stepSize*i），temp:x}）；
const grouped=groupBy（withTime，x=>new Date（x.time.getFullYear（），x.time.getMonth（），x.time.getDate（），x.time.getHours（））.valueOf（））；
const avg=Object.entries（grouped.map）（x）=>{
返回{
时间：新日期（编号（x[0]），
temp:x[1]。映射（y=>y.temp）。减少（（acc，val）=>acc+val）*（1.0/x[1]。长度）
}
});
控制台日志（平均值）通过分组然后减少，您可以像下面这样做


函数groupBy（列表，keyGetter）{
常量映射={}；
list.forEach（（项目）=>{
const key=keyGetter（项目）；
如果（！映射[键]）{
映射[键]=[项]；
}否则{
映射[键]。推送（项）；
}
});
返回图；
}
常量数据=[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]；
const now=（新日期（））.getTime（）；
常数步长=60000*1；
constwithtime=data.reverse（）.map（（x，i）=>{return{time:newdate（now-stepSize*i），temp:x}）；
const grouped=groupBy（withTime，x=>new Date（x.time.getFullYear（），x.time.getMonth（），x.time.getDate（），x.time.getHours（））.valueOf（））；
const avg=Object.entries（grouped.map）（x）=>{
返回{
时间：新日期（编号（x[0]），
temp:x[1]。映射（y=>y.temp）。减少（（acc，val）=>acc+val）*（1.0/x[1]。长度）
}
});
控制台日志（平均值）我是函数式编程库的忠实粉丝。（免责声明：我是它的作者之一。）我倾向于从简单、可重用的函数的角度来思考

当我想到如何解决这个问题时，我是用拉姆达的观点来思考的。我可能会这样解决这个问题：


const avgHour=管道(
每（60）个，
地图（平均值），
)
//一些随机数据
常量数据=范围（0,7*24*60）.map（=>Math.floor（Math.random（）*20+10））
console.log（avgHour（数据））

const{pipe，splitEvery，map，mean，range}=R
我非常喜欢函数式程序