Stringa di istanti JavaScript con formato hh: mm: ss

Voglio convertire una durata di tempo, cioè un numero di secondi in una stringa di tempo separata da due punti (hh: mm: ss)

Ho trovato alcune risposte utili qui, ma tutte parlano della conversione in formato x ore e x minuti.

Quindi c’è un piccolo frammento che fa questo in jQuery o solo JavaScript grezzo?

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

Puoi usarlo ora come:

 alert("5678".toHHMMSS()); 

Snippet di lavoro:

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

Puoi farlo senza alcuna libreria JS esterna con l’aiuto del metodo JS Date come segue:

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

Per ottenere la parte relativa al tempo nel formato hh:MM:ss , puoi usare questa espressione regolare:

(Questo è stato menzionato sopra nello stesso post da qualcuno, grazie per quello.)

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

Raccomando il javascript ordinario, usando l’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); 

(Naturalmente, l'object Data creato avrà una data effettiva associata ad esso, ma quei dati sono estranei, quindi per questi scopi, non devi preoccuparti di questo.)

Una ricerca su Google ha mostrato questo risultato :

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

Variazione su un tema. Gestisce i secondi a cifra singola in modo leggermente diverso

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

Mi piace la prima risposta. Alcune ottimizzazioni per lui:

  • i dati di origine sono un numero, non è necessario ricalcolare.
  • molto eccesso di calcolo

Codice risultato:

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

Utilizzando la fantastica libreria 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); } 

Questo ti permette di specificare qualsiasi durata sia ore, minuti, secondi, mulini, e restituisce una versione leggibile dall’uomo.

Ecco una versione moderna di 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(':'); } 

Risultati aspettati:

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

risultato 15:08:03

È abbastanza facile,

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

risultato:

 1d 10h 17m 36s 

Ho adorato la risposta di Powtac, ma volevo usarla in Angular, quindi ho creato un filtro usando il suo codice.

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

È funzionalmente identico, tranne che ho aggiunto un campo decimale opzionale per visualizzare i secondi frazionari. Usalo come faresti con qualsiasi altro filtro:

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

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

Mi è piaciuta molto la risposta Webjins, quindi l’ho estesa per visualizzare giorni con suffisso annuncio, resi condizionali e inclusi come suffisso in semplici secondi:

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

restituisce “3d 16:32:12” o “16:32:12” o “32:12” o “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; } 

Esempi

     toHHMMSS (111); 
     "1:51"

     toHHMMSS (4444);
     "01:14:04"

     toHHMMSS (33);
     "0:33"

Ecco un’altra versione, che gestisce anche i giorni:

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

È ansible utilizzare un’espressione regolare per associare la sottostringa dell’ora nella stringa restituita dal metodo toString() dell’object Date, che è formattato come segue: “Gio 05 lug 2012 02:45:12 GMT + 0100 (GMT Daylight Time) “. Si noti che questa soluzione utilizza il tempo trascorso dall’epoca: la mezzanotte del 1 ° gennaio 1970. Questa soluzione può essere un one-liner, anche se dividerlo lo rende molto più facile da capire.

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

Ecco come l’ho fatto. Sembra funzionare abbastanza bene ed è estremamente compatto. (Utilizza però molti operatori ternari)

 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 per la formattazione delle stringhe ...

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

È ansible utilizzare la seguente funzione per convertire il tempo (in secondi) in 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 : ':' ); } 

Senza passare un separatore, utilizza : come separatore (predefinito):

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

Se si desidera utilizzare - come separatore, basta passarlo come secondo parametro:

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

dimostrazione

 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') + '

';

C’è un nuovo metodo per le stringhe sul blocco: padStart

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

Ecco un esempio di caso d’uso: durata di YouTube in 4 righe di JavaScript

Penso che per quanto riguarda le prestazioni questo sia di gran lunga il più veloce:

 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 

Personalmente preferisco l’unità principale (giorni, ore, minuti) senza zeri iniziali. Ma i secondi dovrebbero sempre essere guidati da minuti (0:13), questa presentazione è facilmente considerata come ‘durata’, senza ulteriori spiegazioni (marcatura come min, sec (s), ecc.), Utilizzabile in varie lingue (internazionalizzazione).

  // 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 la formattazione della durata del lato server (.net, C #) come:

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

Puoi utilizzare Momement.js con un plug -in formato momento-durata :

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

Questo è come l’ho fatto

 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) restituirà ‘258d 14h 5m 38s’

Eviterei la risposta di artem, ma sono un nuovo poster. Ho ampliato la sua soluzione, anche se non ciò che l’OP chiedeva come segue

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

Ottenere

04 ottobre 16:31:28 PDT

Questo funziona per me …

Ma se si inizia con una quantità di tempo, io uso due funzioni; uno per formattare e riempire e uno per calcolare:

 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 conosci il numero di secondi che hai, questo funzionerà. Utilizza anche l’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; } 

Versione non prototipale di 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; } 

Ecco la mia visione della soluzione. Puoi provare il mio snippet qui sotto.

 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'