Jak sumować liczby zmiennoprzecinkowe w formacie godzin i minut?

Jak sumować liczby zmiennoprzecinkowe w formacie godzin i minut?

Te. jeśli obliczymy dwie takie liczby, 0.35+3.45to powinno być = 4.20, nie3.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);
});

Wynik powinien wyglądać następująco:

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

Najlepszym sposobem radzenia sobie z takimi „szalonymi” formatami danych jest najpierw przekonwertowanie ich na rozsądny i łatwy do przetworzenia format, zrób wszystko, co musisz zrobić, używając przekonwertowanych danych, a na koniec (jeśli absolutnie musisz) przekonwertować wyniki z powrotem na oryginalny format.

(Oczywiście, prawdziwym rozwiązaniem jest całkowite zaprzestanie używania tak zwariowanych reprezentacji czasu. Ale to nie zawsze jest praktyczne, np. Ponieważ musisz połączyć się ze starszym systemem, którego nie możesz zmienić).

W twoim przypadku odpowiednim rozsądnym formatem twoich danych będzie np. Całkowita liczba minut. Po przekonwertowaniu danych na ten format możesz wykonywać na nim zwykłą arytmetykę.

// 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) )

Zauważ, że powyższy kod konwersji zwielokrotnia liczbę zmiennoprzecinkową przez 100 i zaokrągla ją do liczby całkowitej przed oddzieleniem części godziny i minut. Powinno to skutecznie obsłużyć dane wejściowe z możliwymi błędami zaokrąglania, unikając przy tym konieczności ich usztywnienia.

Powodem, dla którego należy zachować szczególną ostrożność, jest to, że liczba 0,01 = 1/100 (i większość jej wielokrotności) nie jest właściwie dokładnie reprezentowana w binarnym formacie zmiennoprzecinkowym używanym przez JavaScript. Tak więc nie możesz faktycznie mieć liczby JS, która byłaby dokładnie równa 0,01 - najlepszą, jaką możesz mieć, jest liczba tak bliska, że ​​konwersja jej na ciąg automatycznie ukryje błąd. Ale błąd zaokrąglania nadal występuje i może cię ugryźć, jeśli spróbujesz zrobić takie rzeczy, jak porównanie takich liczb z dokładnym progiem. Oto ładna i prosta demonstracja:

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)

Możesz użyć tej logiki po prostym dodaniu arytmetycznym, co spowoduje konwersję sumy do formatu czasu

Proszę bardzo, wdrożenie w Javascript ES6. Zapętliłem każdy element i dzieliłem godziny, minuty ., sprawdziłem, czy minuty nie istnieją, przypisz 0 policz sumę godzin i minut i zastosowałem niezbędne obliczenia.

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);

Musisz przeliczyć wszystko na godziny lub minuty, a następnie wykonać obliczenia matematyczne.

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!

Najpierw musisz przeliczyć je na godziny i minuty

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]));

Czy mogę wiedzieć, dlaczego chcesz, aby pierwszy wynik wynosił 0 ? Poniżej znajduje się sposób na zrobienie tego za pomocą pojedynczej pętli. Komentarze są w kodzie do wyjaśnienia. Z każdą pętlą dodajemy minuty, a jeśli są one większe niż 60, dodajemy godzinę, a następnie używamy % 60, aby uzyskać pozostałe minuty. Pływaki mogą być uciążliwe w pracy,

np. 1.1 + 2.2 === 3.3 jest fałszem

Przekształciłem więc liczby na ciąg znaków, a następnie z powrotem na liczbę całkowitą.

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);
}

Standardowym sposobem zmniejszenia modułu jest dodanie deficytu po dodaniu, jeśli nastąpiło przepełnienie. W ten sposób można dodawać BCD na przykład przy użyciu sprzętu binarnego.

Mimo, że można zrobić za pomocą pływaków dodatek w ten sposób, nie jest kwestia tego, czy powinien . Problemy z używaniem liczb zmiennoprzecinkowych do operowania na liczbach całkowitych są dobrze znane i nie zamierzam ich tutaj przerabiać.

Zwykle dodawanie ułamków swobodnych działa domyślnie z modułem 1,0, przelew z ułamka zwiększa część całkowitą. Jeśli interpretujemy punkt jako separator godzin. Minut, chcemy, aby ułamek przepełniał się przy 0,6. W tym celu należy dodać deficyt w wysokości 0,4.

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));
});

co daje następujący wynik, popraw w zaokrągleniu do tego, o co poprosił PO

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

Ostateczne formatowanie zostawiłem do dwóch miejsc po przecinku jako ćwiczenie dla czytelnika. 15 końcowych cyfr w całej okazałości ilustruje, dlaczego używanie pływaków nie jest najlepszym sposobem na zrobienie tego.

Zastanów się także, co się stanie, jeśli chcesz uwzględnić sekundy lub dni. Dwa raczej bardziej standardowe sposoby albo sekund zmiennoprzecinkowych, albo krotkę liczb całkowitych, nagle wyglądają na znacznie rozsądniejsze.