Converti HH: MM: stringa SS in secondi solo in javascript

Ho un requisito simile a questo: convertire il tempo in HH: MM: formato SS solo in secondi?

ma in javascript. Ho visto molti esempi di conversione dei secondi in diversi formati ma non HH: MM: SS in secondi. Qualsiasi aiuto sarebbe apprezzato.

Prova questo:

var hms = '02:04:33';   // your input string
var a = hms.split(':'); // split it at the colons

// minutes are worth 60 seconds. Hours are worth 60 minutes.
var seconds = (+a[0]) * 60 * 60 + (+a[1]) * 60 + (+a[2]); 

console.log(seconds);

Questa funzione gestisce "HH: MM: SS" così come "MM: SS" o "SS".

function hmsToSecondsOnly(str) {
    var p = str.split(':'),
        s = 0, m = 1;

    while (p.length > 0) {
        s += m * parseInt(p.pop(), 10);
        m *= 60;
    }

    return s;
}

Questo può essere fatto abbastanza resilientemente con quanto segue:

'01:02:03'.split(':').reduce((acc,time) => (60 * acc) + +time);

Questo perché ogni unità di tempo all'interno di ore, minuti e secondi è un multiplo di 60 maggiore dell'unità più piccola. Il tempo viene suddiviso in componenti di ore, minuti e secondi, quindi ridotto a secondi utilizzando il valore accumulato delle unità superiori moltiplicato per 60 mentre passa attraverso ciascuna unità.

Il +timeviene utilizzato per lanciare il tempo di un numero.

Fondamentalmente finisce per fare: (60 * ((60 * HHHH) + MM)) + SS

Se vengono passati solo secondi, il risultato sarebbe una stringa, quindi per risolvere il problema potremmo eseguire il cast dell'intero risultato a un int:

+('03'.split(':').reduce((acc,time) => (60 * acc) + +time));

Poiché la funzione getTime dell'oggetto Date ottiene i millisecondi dal 01/01/1970, possiamo farlo:

var time = '12:23:00';
var seconds = new Date('1970-01-01T' + time + 'Z').getTime() / 1000;

Converti la hh:mm:ssstringa in secondi in una riga. È consentito anche il h:m:sformato e mm:ss, m:secc

'08:45:20'.split(':').reverse().reduce((prev, curr, i) => prev + curr*Math.pow(60, i), 0)

provare

time="12:12:12";
tt=time.split(":");
sec=tt[0]*3600+tt[1]*60+tt[2]*1;

Il metodo statico di Javascript Date.UTC()fa il trucco:

alert(getSeconds('00:22:17'));

function getSeconds(time)
{
    var ts = time.split(':');
    return Date.UTC(1970, 0, 1, ts[0], ts[1], ts[2]) / 1000;
}

Ecco forse una forma un po 'più leggibile sulla risposta originale approvata.

const getSeconds = (hms: string) : number => {
  const [hours, minutes, seconds] = hms.split(':');
  return (+hours) * 60 * 60 + (+minutes) * 60 + (+seconds);
};

new Date(moment('23:04:33', "HH:mm")).getTime()

Uscita: 1499755980000 (in millisecondi) (1499755980000/1000) (in secondi)

Nota: questo output calcola la differenza da 1970-01-01 12: 0: 0 ad ora e dobbiamo implementare moment.js

Questa funzione funziona anche per MM: SS:

const convertTime = (hms) => {
        if (hms.length <3){
         return hms
        } else if (hms.length <6){
          const a = hms.split(':')
          return hms = (+a[0]) * 60 + (+a[1])
        } else {
          const a = hms.split(':')
          return hms = (+a[0]) * 60 * 60 + (+a[1]) * 60 + (+a[2])
        }
      }

Tratto dalla soluzione data da Paul https://stackoverflow.com/a/45292588/1191101 ma utilizzando la vecchia notazione di funzione quindi può essere utilizzato anche in altri motori js (es. Java Rhino)

function strToSeconds (stime)
{
   return +(stime.split(':').reduce(function (acc,time) { return +(60 * acc) + +time }));
}

o solo questo più leggibile

function strToSeconds (stime)
{
  var tt = stime.split(':').reverse ();
  return ((tt.length >= 3) ? (+tt[2]): 0)*60*60 + 
         ((tt.length >= 2) ? (+tt[1]): 0)*60 + 
         ((tt.length >= 1) ? (+tt[0]): 0);
}

Puoi farlo dinamicamente - nel caso in cui incontri non solo: HH: mm: ss, ma anche, mm: ss, o anche solo ss.

var str = '12:99:07';
var times = str.split(":");
times.reverse();
var x = times.length, y = 0, z;
for (var i = 0; i < x; i++) {
    z = times[i] * Math.pow(60, i);
    y += z;
}
console.log(y);