Segundos do JavaScript para string de hora com formato hh: mm: ss

Eu quero converter uma duração de tempo, ou seja, número de segundos para a seqüência de tempo separados por dois pontos (hh: mm: ss)

Eu encontrei algumas respostas úteis aqui, mas todas elas falam sobre a conversão para o formato x horas e x minutos.

Então, há um pequeno trecho que faz isso em jQuery ou apenas JavaScript bruto?

String.prototype.toHHMMSS = function () { var sec_num = parseInt(this, 10); // don't forget the second param var hours = Math.floor(sec_num / 3600); var minutes = Math.floor((sec_num - (hours * 3600)) / 60); var seconds = sec_num - (hours * 3600) - (minutes * 60); if (hours < 10) {hours = "0"+hours;} if (minutes < 10) {minutes = "0"+minutes;} if (seconds < 10) {seconds = "0"+seconds;} return hours+':'+minutes+':'+seconds; } 

Você pode usá-lo agora como:

 alert("5678".toHHMMSS()); 

Snippet de trabalho:

 String.prototype.toHHMMSS = function () { var sec_num = parseInt(this, 10); // don't forget the second param var hours = Math.floor(sec_num / 3600); var minutes = Math.floor((sec_num - (hours * 3600)) / 60); var seconds = sec_num - (hours * 3600) - (minutes * 60); if (hours < 10) {hours = "0"+hours;} if (minutes < 10) {minutes = "0"+minutes;} if (seconds < 10) {seconds = "0"+seconds;} return hours + ':' + minutes + ':' + seconds; } console.log("5678".toHHMMSS()); 

Você pode conseguir fazer isso sem qualquer biblioteca JS externa com a ajuda do método JS Date, como segue:

 var date = new Date(null); date.setSeconds(45); // specify value for SECONDS here var timeString = date.toISOString().substr(11, 8); console.log(timeString) 

Para obter a parte do tempo no formato hh:MM:ss , você pode usar esta expressão regular:

(Isso foi mencionado acima no mesmo post por alguém, obrigado por isso.)

  var myDate = new Date().toTimeString().replace(/.*(\d{2}:\d{2}:\d{2}).*/, "$1"); console.log(myDate) 

Eu recomendo javascript comum, usando o object Date:

 var seconds = 9999; // multiply by 1000 because Date() requires miliseconds var date = new Date(seconds * 1000); var hh = date.getUTCHours(); var mm = date.getUTCMinutes(); var ss = date.getSeconds(); // If you were building a timestamp instead of a duration, you would uncomment the following line to get 12-hour (not 24) time // if (hh > 12) {hh = hh % 12;} // These lines ensure you have two-digits if (hh < 10) {hh = "0"+hh;} if (mm < 10) {mm = "0"+mm;} if (ss < 10) {ss = "0"+ss;} // This formats your string to HH:MM:SS var t = hh+":"+mm+":"+ss; document.write(t); 

(Obviamente, o object Date criado terá uma data real associada a ele, mas esses dados são irrelevantes, portanto, para esses propósitos, você não precisa se preocupar com isso.)

Uma pesquisa do Google revelou este resultado :

 function secondsToTime(secs) { secs = Math.round(secs); var hours = Math.floor(secs / (60 * 60)); var divisor_for_minutes = secs % (60 * 60); var minutes = Math.floor(divisor_for_minutes / 60); var divisor_for_seconds = divisor_for_minutes % 60; var seconds = Math.ceil(divisor_for_seconds); var obj = { "h": hours, "m": minutes, "s": seconds }; return obj; } 

Variação sobre um tema. Lida com um dígito de segundo um pouco diferente

 seconds2time(0) -> "0s" seconds2time(59) -> "59s" seconds2time(60) -> "1:00" seconds2time(1000) -> "16:40" seconds2time(4000) -> "1:06:40" function seconds2time (seconds) { var hours = Math.floor(seconds / 3600); var minutes = Math.floor((seconds - (hours * 3600)) / 60); var seconds = seconds - (hours * 3600) - (minutes * 60); var time = ""; if (hours != 0) { time = hours+":"; } if (minutes != 0 || time !== "") { minutes = (minutes < 10 && time !== "") ? "0"+minutes : String(minutes); time += minutes+":"; } if (time === "") { time = seconds+"s"; } else { time += (seconds < 10) ? "0"+seconds : String(seconds); } return time; } 

Eu gosto da primeira resposta. Algumas otimizações para ele:

  • os dados de origem são um número, não há necessidade de recalcular.
  • muito excesso de computação

Código do resultado:

 Number.prototype.toHHMMSS = function () { var seconds = Math.floor(this), hours = Math.floor(seconds / 3600); seconds -= hours*3600; var minutes = Math.floor(seconds / 60); seconds -= minutes*60; if (hours < 10) {hours = "0"+hours;} if (minutes < 10) {minutes = "0"+minutes;} if (seconds < 10) {seconds = "0"+seconds;} return hours+':'+minutes+':'+seconds; } 

Usando a incrível biblioteca moment.js :

 function humanizeDuration(input, units ) { // units is a string with possible values of y, M, w, d, h, m, s, ms var duration = moment().startOf('day').add(units, input), format = ""; if(duration.hour() > 0){ format += "H [hours] "; } if(duration.minute() > 0){ format += "m [minutes] "; } format += " s [seconds]"; return duration.format(format); } 

Isso permite que você especifique qualquer duração, seja horas, minutos, segundos, moinhos e retorna uma versão legível.

Aqui está uma versão moderna do ES6:

 function formatTime(seconds) { const h = Math.floor(seconds / 3600); const m = Math.floor((seconds % 3600) / 60); const s = seconds % 60; return [ h, m > 9 ? m : (h ? '0' + m : m || '0'), s > 9 ? s : '0' + s, ].filter(a => a).join(':'); } 

Resultados esperados:

 expect(formatTime(0)).toEqual('0:00'); expect(formatTime(1)).toEqual('0:01'); expect(formatTime(599)).toEqual('9:59'); expect(formatTime(600)).toEqual('10:00'); expect(formatTime(3600)).toEqual('1:00:00'); expect(formatTime(360009)).toEqual('100:00:09'); 

new Date().toString().split(" ")[4];

resultado 15:08:03

É bem fácil

 function toTimeString(seconds) { return (new Date(seconds * 1000)).toUTCString().match(/(\d\d:\d\d:\d\d)/)[0]; } 
 s2t=function (t){ return parseInt(t/86400)+'d '+(new Date(t%86400*1000)).toUTCString().replace(/.*(\d{2}):(\d{2}):(\d{2}).*/, "$1h $2m $3s"); } s2t(123456); 

resultado:

 1d 10h 17m 36s 

Eu amei a resposta do Powtac, mas eu queria usá-lo no Angular, então criei um filtro usando o código dele.

 .filter('HHMMSS', ['$filter', function ($filter) { return function (input, decimals) { var sec_num = parseInt(input, 10), decimal = parseFloat(input) - sec_num, hours = Math.floor(sec_num / 3600), minutes = Math.floor((sec_num - (hours * 3600)) / 60), seconds = sec_num - (hours * 3600) - (minutes * 60); if (hours < 10) {hours = "0"+hours;} if (minutes < 10) {minutes = "0"+minutes;} if (seconds < 10) {seconds = "0"+seconds;} var time = hours+':'+minutes+':'+seconds; if (decimals > 0) { time += '.' + $filter('number')(decimal, decimals).substr(2); } return time; }; }]) 

É funcionalmente idêntica, exceto que eu adicionei em um campo decimais opcional para exibir os segundos fracionários. Use como você faria com qualquer outro filtro:

{{ elapsedTime | HHMMSS }} {{ elapsedTime | HHMMSS }} exibe: 01:23:45

{{ elapsedTime | HHMMSS : 3 }} {{ elapsedTime | HHMMSS : 3 }} exibe: 01:23:45.678

Eu gostei de Webjins responder mais, então eu estendi para exibir dias com sufixo de anúncio, feito exibição condicional e incluído como sufixo em segundos simples:

 function sec2str(t){ var d = Math.floor(t/86400), h = ('0'+Math.floor(t/3600) % 24).slice(-2), m = ('0'+Math.floor(t/60)%60).slice(-2), s = ('0' + t % 60).slice(-2); return (d>0?d+'d ':'')+(h>0?h+':':'')+(m>0?m+':':'')+(t>60?s:s+'s'); } 

retorna “3d 16:32:12” ou “16:32:12” ou “32:12” ou “12s”

 function formatTime(seconds) { return [ parseInt(seconds / 60 / 60), parseInt(seconds / 60 % 60), parseInt(seconds % 60) ] .join(":") .replace(/\b(\d)\b/g, "0$1") } 
 function toHHMMSS(seconds) { var h, m, s, result=''; // HOURs h = Math.floor(seconds/3600); seconds -= h*3600; if(h){ result = h<10 ? '0'+h+':' : h+':'; } // MINUTEs m = Math.floor(seconds/60); seconds -= m*60; result += m<10 ? '0'+m+':' : m+':'; // SECONDs s=seconds%60; result += s<10 ? '0'+s : s; return result; } 

Exemplos

     para HHMMSS (111); 
     "01:51"

     para HHMMSS (4444);
     "01:14:04"

     para HHMMSS (33);
     "00:33"

Uma expressão regular pode ser usada para corresponder a subseqüência de tempo na seqüência de caracteres retornada do toString() do object Date, que é formatado da seguinte maneira: “Thu Jul 05 2012 02:45:12 GMT + 0100 (GMT Daylight Time) “. Observe que essa solução usa o tempo desde a época: meia-noite de 1º de janeiro de 1970. Essa solução pode ser uma única linha, embora a divisão seja muito mais fácil de entender.

 function secondsToTime(seconds) { var start = new Date(1970, 1, 1, 0, 0, 0, 0).getTime(); var end = new Date(1970, 1, 1, 0, 0, parseInt(seconds), 0).getTime(); var duration = end - start; return new Date(duration).toString().replace(/.*(\d{2}:\d{2}:\d{2}).*/, "$1"); } 

Aqui está outra versão, que lida com os dias também:

 function FormatSecondsAsDurationString( seconds ) { var s = ""; var days = Math.floor( ( seconds / 3600 ) / 24 ); if ( days >= 1 ) { s += days.toString() + " day" + ( ( days == 1 ) ? "" : "s" ) + " + "; seconds -= days * 24 * 3600; } var hours = Math.floor( seconds / 3600 ); s += GetPaddedIntString( hours.toString(), 2 ) + ":"; seconds -= hours * 3600; var minutes = Math.floor( seconds / 60 ); s += GetPaddedIntString( minutes.toString(), 2 ) + ":"; seconds -= minutes * 60; s += GetPaddedIntString( Math.floor( seconds ).toString(), 2 ); return s; } function GetPaddedIntString( n, numDigits ) { var nPadded = n; for ( ; nPadded.length < numDigits ; ) { nPadded = "0" + nPadded; } return nPadded; } 

Existe um novo método para strings no bloco: padStart

 const str = '5'; str.padStart(2, '0'); // 05 

Aqui está um exemplo de caso de uso: durações do YouTube em quatro linhas de JavaScript

Eu acho que desempenho sábio é de longe o mais rápido:

 var t = 34236; // your seconds var time = ('0'+Math.floor(t/3600) % 24).slice(-2)+':'+('0'+Math.floor(t/60)%60).slice(-2)+':'+('0' + t % 60).slice(-2) //would output: 09:30:36 

Aqui está como eu fiz isso. Parece funcionar razoavelmente bem e é extremamente compacto. (Ele usa um monte de operadores ternários, no entanto)

 function formatTime(seconds) { var hh = Math.floor(seconds / 3600), mm = Math.floor(seconds / 60) % 60, ss = Math.floor(seconds) % 60; return (hh ? (hh < 10 ? "0" : "") + hh + ":" : "") + ((mm < 10) && hh ? "0" : "") + mm + ":" + (ss < 10 ? "0" : "") + ss } 

... e para formatar strings ...

 String.prototype.toHHMMSS = function() { formatTime(parseInt(this, 10)) }; 

Eu pessoalmente prefiro a unidade principal (dias, horas, minutos) sem zeros à esquerda. Mas os segundos devem sempre ser liderados por minutos (0:13), esta apresentação é facilmente considerada como ‘duração’, sem maiores explicações (marcação min, seg (s), etc.), utilizável em vários idiomas (internacionalização).

  // returns (-)dh:mm:ss(.f) // (-)h:mm:ss(.f) // (-)m:ss(.f) function formatSeconds (value, fracDigits) { var isNegative = false; if (isNaN(value)) { return value; } else if (value < 0) { isNegative = true; value = Math.abs(value); } var days = Math.floor(value / 86400); value %= 86400; var hours = Math.floor(value / 3600); value %= 3600; var minutes = Math.floor(value / 60); var seconds = (value % 60).toFixed(fracDigits || 0); if (seconds < 10) { seconds = '0' + seconds; } var res = hours ? (hours + ':' + ('0' + minutes).slice(-2) + ':' + seconds) : (minutes + ':' + seconds); if (days) { res = days + '.' + res; } return (isNegative ? ('-' + res) : res); } 

// imitando a formatação de duração do lado do servidor (.net, C #) como:

  public static string Format(this TimeSpan interval) { string pattern; if (interval.Days > 0) pattern = @"d\.h\:mm\:ss"; else if (interval.Hours > 0) pattern = @"h\:mm\:ss"; else pattern = @"m\:ss"; return string.Format("{0}", interval.ToString(pattern)); } 

Você pode usar a seguinte function para converter o tempo (em segundos) para o formato HH:MM:SS :

 var convertTime = function (input, separator) { var pad = function(input) {return input < 10 ? "0" + input : input;}; return [ pad(Math.floor(input / 3600)), pad(Math.floor(input % 3600 / 60)), pad(Math.floor(input % 60)), ].join(typeof separator !== 'undefined' ? separator : ':' ); } 

Sem passar um separador, ele usa : como o separador (padrão):

 time = convertTime(13551.9941351); // --> OUTPUT = 03:45:51 

Se você quiser usar - como separador, basta passá-lo como segundo parâmetro:

 time = convertTime(1126.5135155, '-'); // --> OUTPUT = 00-18-46 

Demonstração

 var convertTime = function (input, separator) { var pad = function(input) {return input < 10 ? "0" + input : input;}; return [ pad(Math.floor(input / 3600)), pad(Math.floor(input % 3600 / 60)), pad(Math.floor(input % 60)), ].join(typeof separator !== 'undefined' ? separator : ':' ); } document.body.innerHTML = '
' + JSON.stringify({ 5.3515555 : convertTime(5.3515555), 126.2344452 : convertTime(126.2344452, '-'), 1156.1535548 : convertTime(1156.1535548, '.'), 9178.1351559 : convertTime(9178.1351559, ':'), 13555.3515135 : convertTime(13555.3515135, ',') }, null, '\t') + '

';

Você pode usar Momement.js com o plugin de formato de duração de momento :

 var seconds = 3820; var duration = moment.duration(seconds, 'seconds'); var formatted = duration.format("hh:mm:ss"); console.log(formatted); // 01:03:40 
     
 secToHHMM(number: number) { debugger; let hours = Math.floor(number / 3600); let minutes = Math.floor((number - (hours * 3600)) / 60); let seconds = number - (hours * 3600) - (minutes * 60); let H, M, S; if (hours < 10) H = ("0" + hours); if (minutes < 10) M = ("0" + minutes); if (seconds < 10) S = ("0" + seconds); return (H || hours) + ':' + (M || minutes) + ':' + (S || seconds); } 

É assim que eu fiz

 function timeFromSecs(seconds) { return( Math.floor(seconds/86400)+'d :'+ Math.floor(((seconds/86400)%1)*24)+'h : '+ Math.floor(((seconds/3600)%1)*60)+'m : '+ Math.round(((seconds/60)%1)*60)+'s'); } 

timeFromSecs (22341938) retornará ‘258d 14h 5m 38s’

Eu teria votado a resposta de artem, mas sou um novo pôster. Eu expandi sua solução, embora não o que o OP pediu da seguinte forma

  t=(new Date()).toString().split(" "); timestring = (t[2]+t[1]+' '+t[4]+' '+t[6][1]+t[7][0]+t[8][0]); 

Para obter

04Out 16:31:28 PDT

Isso funciona para mim …

Mas se você está começando com apenas uma quantidade de tempo, eu uso duas funções; um para formatar e preencher e um para calcular:

 function sec2hms(timect){ if(timect=== undefined||timect==0||timect === null){return ''}; //timect is seconds, NOT milliseconds var se=timect % 60; //the remainder after div by 60 timect = Math.floor(timect/60); var mi=timect % 60; //the remainder after div by 60 timect = Math.floor(timect/60); var hr = timect % 24; //the remainder after div by 24 var dy = Math.floor(timect/24); return padify (se, mi, hr, dy); } function padify (se, mi, hr, dy){ hr = hr<10?"0"+hr:hr; mi = mi<10?"0"+mi:mi; se = se<10?"0"+se:se; dy = dy>0?dy+"d ":""; return dy+hr+":"+mi+":"+se; } 

Se você souber o número de segundos que você tem, isso funcionará. Ele também usa o object nativo Date ().

 function formattime(numberofseconds){ var zero = '0', hours, minutes, seconds, time; time = new Date(0, 0, 0, 0, 0, numberofseconds, 0); hh = time.getHours(); mm = time.getMinutes(); ss = time.getSeconds() // Pad zero values to 00 hh = (zero+hh).slice(-2); mm = (zero+mm).slice(-2); ss = (zero+ss).slice(-2); time = hh + ':' + mm + ':' + ss; return time; } 

Versão não protótipo de toHHMMSS:

  function toHHMMSS(seconds) { var sec_num = parseInt(seconds); var hours = Math.floor(sec_num / 3600); var minutes = Math.floor((sec_num - (hours * 3600)) / 60); var seconds = sec_num - (hours * 3600) - (minutes * 60); if (hours < 10) {hours = "0"+hours;} if (minutes < 10) {minutes = "0"+minutes;} if (seconds < 10) {seconds = "0"+seconds;} var time = hours+':'+minutes+':'+seconds; return time; } 

Aqui está a minha visão de solução. Você pode tentar meu trecho abaixo.

 function secToHHMM(sec) { var d = new Date(); d.setHours(0); d.setMinutes(0); d.setSeconds(0); d = new Date(d.getTime() + sec*1000); return d.toLocaleString('en-GB').split(' ')[1]; }; alert( 'One hour: ' + secToHHMM(60*60) ); // '01:00:00' alert( 'One hour five minutes: ' + secToHHMM(60*60 + 5*60) ); // '01:05:00' alert( 'One hour five minutes 23 seconds: ' + secToHHMM(60*60 + 5*60 + 23) ); // '01:05:23'