Como somar números flutuantes no formato de horas e minutos?

Como somar números flutuantes no formato de horas e minutos?

Essa. se calcular dois desses números 0.35+3.45, deve ser = 4.20, não3.80

var arr = [0.15, 0.2, 3.45, 0.4, 2, 0.3, 5.2, 1, 1.4, 1.1, 2.4, 1, 3.4]
    
var sum = 0.0;
    
arr.forEach(function(item) {
  console.log(sum);
  sum += parseFloat(item);
});

O resultado deve ser assim:

0
0.15
0.35
4.20
5.0
7.0
7.30
12.50
13.50
15.30
16.40
19.20
20.20

A melhor maneira de lidar com formatos de dados "malucos" como esse é primeiro convertê-los em um formato sadio e facilmente processável, fazer o que for necessário usando os dados convertidos e finalmente (se for necessário) converter os resultados novamente para o formato original.

(Obviamente, a solução real é parar de usar essas representações de tempo totalmente loucas. Mas isso nem sempre é prático, por exemplo, porque você precisa interagir com um sistema legado que não pode mudar.)

No seu caso, um formato adequado para os seus dados seria, por exemplo, um número integral de minutos. Depois de converter seus dados para esse formato, você poderá fazer aritmética comum.

// converts a pseudo-float of the form hh.mm into an integer number of minutes
// robust against floating-point roundoff errors, also works for negative numbers
function hhMmToMinutes(x) {
  const hhmm = Math.round(100 * x)  // convert hh.mm -> hhmm
  return 60 * Math.trunc(hhmm / 100) + (hhmm % 100)
}

// convert minutes back to hh.mm pseudo-float format
// use minutesToHhMm(minutes).toFixed(2) if you want trailing zeros
function minutesToHhMm(minutes) {
  return Math.trunc(minutes / 60) + (minutes % 60) / 100
}

const arr = [0.15, 0.2, 3.45, 0.4, 2, 0.3, 5.2, 1, 1.4, 1.1, 2.4, 1, 3.4]

let sum = 0
console.log( arr.map(hhMmToMinutes).map(x => sum += x).map(minutesToHhMm) )

Observe que o código de conversão acima primeiro multiplica o valor flutuante da entrada por 100 e o arredonda para um número inteiro antes de separar as partes da hora e do minuto. Isso deve manipular de maneira robusta as entradas com possíveis erros de arredondamento, evitando a necessidade de especificar as entradas.

O motivo para ter cuidado extra aqui é porque o número 0,01 = 1/100 (e a maioria de seus múltiplos) não é exatamente representável no formato de ponto flutuante binário usado pelo JavaScript. Portanto, você não pode realmente ter um número JS que seria exatamente igual a 0,01 - o melhor que você pode ter é um número tão próximo que a conversão em uma string ocultará automaticamente o erro. Mas o erro de arredondamento ainda existe, e você pode mordê-lo se você tentar fazer coisas como comparar esses números com um limite exato. Aqui está uma demonstração agradável e simples:

console.log(Math.trunc(100 * 0.29))  // you'd think this would be 29...

// We got this after simple addition
// Now we want to change it into 4.2
sample = 3.8

// Now here are the minutes that the float currently shows
minutes = (sample % 1) * 100

// And the hours
hours = Math.floor(sample)

// Here are the number of hours that can be reduced from minutes
AddHours = Math.floor(minutes / 60)

// Adding them to the hours count
hours += AddHours

// Reducing mintues
minutes %= 60

// Finally formatting hour and minutes into your format
final = hours + (minutes / 100.0)
console.log(final)

Você pode usar essa lógica depois de fazer uma adição aritmética simples, isso converterá a soma em formato de hora

Aqui está, implementação em Javascript ES6. Passei um loop em cada elemento e divido horas, minutos por ., verifiquei se minutos não existem, ou seja, atribua 0 a contar o total de horas e minutos e apliquei a computação necessária.

const resultObj = [0.35, 3.45].reduce((a, e) => {
  const [hours, minutes] = e.toString().split('.');
  a.h += +hours;
  a.m += (+(minutes.padEnd(2, 0)) || 0); 
  return a;
}, {h: 0, m: 0});


const result = resultObj.h + Math.floor(resultObj.m / 60) + ((resultObj.m % 60) / 100);
console.log(result);

Você precisa converter tudo em horas ou minutos e depois fazer as contas.

Example: 0.35 + 3.45
Convert 0.35 to Hours Number((35/60).toFixed(2))
= 0.58

Then convert 3hours 45 minutes into hours
= 3 + Number((45/60).toFixed(2))
= 3hours + 0.75 hours
= 3.75

Add the 2 conversions
= 0.58 + 3.75
= 4.33 hours

Convert the 0.33 back to minutes by multiplying by 60
= 4 hours 19.8 minutes ~ 20 mins

Hope that helps!

Você precisa convertê-los para horas e minutos primeiro

var arr = [0.15, 0.2, 3.45, 0.4, 2, 0.3, 5.2, 1, 1.4, 1.1, 2.4, 1, 3.4];

function add(arr) {
  var hm = arr
    .map(v => [Math.floor(v), (v % 1).toFixed(2) * 100])  // Map the array to values having [hours, minutes]
    .reduce((t, v) => { //  reduce the array of [h, m] to a single object having total hours and minutes
      t = {
        h: t.h + v[0],
        m: t.m + v[1]
      };
      return t;
    }, {
      h: 0,
      m: 0
    });

  // final result would be = 
  // total hours from above
  // + hours from total minutes (retrived using Math.floor(hm.m / 60)) 
  // + minutes (after converting it to be a decimal part)
  return (parseFloat(hm.h + Math.floor(hm.m / 60)) + parseFloat(((hm.m % 60) / 100).toFixed(2))).toFixed(2);
}

// adding `arr` array
console.log(add(arr));

// adding 0.35+3.45
console.log(add([0.35, 3.45]));

Posso saber por que você deseja que o primeiro resultado seja 0 ? Abaixo está uma maneira de fazer isso com um único loop. Os comentários estão no código para explicar. A cada loop, adicionamos os minutos e, se forem maiores que 60, adicionamos uma hora e usamos % 60 para obter os minutos restantes. Flutuar pode ser uma dor de se trabalhar,

por exemplo, 1,1 + 2,2 === 3,3 é falso

Então, converti os números em uma string e depois voltei a um int.

var arr = [0.15, 0.2, 3.45, 0.4, 2, 0.3, 5.2, 1, 1.4, 1.1, 2.4, 1, 3.4];
let hoursTally = 0;
let minutesTally = 0;

for(var i = 0; i < arr.length; i++) {
  // Convert the float to a string, as floats can be a pain to add together
  let time = arr[i].toString().split('.');
  // Tally up the hours.
  hoursTally += parseInt(time[0]);
  // Tally up the minutes;
  let minute = time[1];
  if(minute) {
    // We do this so we add 20 minutes, not 2 minutes
    if(minute.length < 2) {
      minutesTally += parseInt(minute) * 10;
    } else {
      minutesTally += parseInt(minute);
    }
    // If the minutesTally is greater than 60, add an hour to hours
    if(minutesTally >= 60) {
      hoursTally++;
      // Set the minutesTally to be the remainder after dividing by 60
      minutesTally = minutesTally % 60;
    }
  }
  console.log(hoursTally + "." + minutesTally);
}

A maneira padrão de reduzir um módulo é adicionar o déficit após o acréscimo se um estouro foi causado. É assim que você faria a adição do BCD usando hardware binário, por exemplo.

Embora você possa fazer acréscimos usando carros alegóricos dessa maneira, há uma questão de saber se você deveria . Os problemas com o uso de números flutuantes para operar em quantidades basicamente inteiras são bem conhecidos, e não vou reformulá-los aqui.

Normalmente, a adição em frações flutuantes funciona implicitamente com um módulo de 1,0, um excesso da fração incrementa a parte inteira. Se interpretarmos o ponto como o separador hours.minutes, queremos que a fração transborde em 0,6. Isso precisa que o déficit de 0,4 seja adicionado no momento apropriado.

function add_float_hours_minutes(a, b)
{
  var trial_sum = a+b;
  // did an actual overflow occur, has the integer part incremented?
  if ( Math.floor(trial_sum) > Math.floor(a)+Math.floor(b) )  {
    trial_sum += 0.4;
  }
  // has the fractional part exceeded its allotted 60 minutes?
  if ( trial_sum-Math.floor(trial_sum) >= 0.6)  {
    trial_sum += 0.4;
  }
  return trial_sum;
}

var arr = [0.15, 0.2, 3.45, 0.4, 2, 0.3, 5.2, 1, 1.4, 1.1, 2.4, 1, 3.4]

var sum = 0.0;

arr.forEach(function(item) {
  console.log(sum);
  // sum += parseFloat(item);
  sum = add_float_hours_minutes(sum, parseFloat(item));
});

que produz a seguinte saída, correta dentro de um arredondamento para o que o OP solicitou

0
0.15
0.35
4.2
5.000000000000001
7.000000000000001
7.300000000000001
12.5
13.5
15.3
16.400000000000002
19.2
20.2

Deixei a formatação final com duas casas decimais como exercício para o leitor. Os 15 dígitos à direita em toda a sua glória ilustram parte do motivo pelo qual usar carros alegóricos não é a melhor maneira de fazer isso.

Além disso, considere o que acontece quando você deseja incluir segundos ou dias. As duas maneiras mais comuns de segundos flutuantes ou uma tupla de números inteiros parecem subitamente muito mais sensatas.