Este es un problema común pero no estoy seguro de cómo resolverlo. El siguiente código funciona bien.

var mind = time % (60 * 60);
var minutes = Math.floor(mind / 60);

var secd = mind % 60;
var seconds = Math.ceil(secd);

Sin embargo, cuando llego a 1 hora o 3600 segundos, devuelve 0 minutos y 0 segundos. ¿Cómo puedo evitar esto para que devuelva todos los minutos?

Gracias

Para obtener el número de minutos completos, divida el número de segundos totales por 60 (60 segundos / minuto):

var minutes = Math.floor(time / 60);

Y para obtener los segundos restantes, multiplique los minutos completos por 60 y reste del total de segundos:

var seconds = time - minutes * 60;

Ahora, si también desea obtener las horas completas, divida el número de segundos totales por 3600 (60 minutos / hora · 60 segundos / minuto) primero, luego calcule los segundos restantes:

var hours = Math.floor(time / 3600);
time = time - hours * 3600;

Luego calcula los minutos completos y los segundos restantes.

Prima:

Use el siguiente código para imprimir la hora bonita (sugerido por Dru)

function str_pad_left(string,pad,length) {
    return (new Array(length+1).join(pad)+string).slice(-length);
}

var finalTime = str_pad_left(minutes,'0',2)+':'+str_pad_left(seconds,'0',2);

Otra solución elegante:

function fancyTimeFormat(duration)
{   
    // Hours, minutes and seconds
    var hrs = ~~(duration / 3600);
    var mins = ~~((duration % 3600) / 60);
    var secs = ~~duration % 60;

    // Output like "1:01" or "4:03:59" or "123:03:59"
    var ret = "";

    if (hrs > 0) {
        ret += "" + hrs + ":" + (mins < 10 ? "0" : "");
    }

    ret += "" + mins + ":" + (secs < 10 ? "0" : "");
    ret += "" + secs;
    return ret;
}

~~es una abreviatura para Math.floorver este enlace para más información

Probar en línea

Para las personas que esperan obtener una solución rápida, simple y, por lo tanto, corta para formatear segundos en M:SS:

function fmtMSS(s){return(s-(s%=60))/60+(9<s?':':':0')+s}

hecho ..
La función acepta ya sea un Number(preferido) o una String(2 conversión penalties que se puede reducir a la mitad anteponiendo +en el argumento de la llamada de función para la sque en: fmtMSS(+strSeconds)), que representa segundos enteros positivos scomo argumento.

Ejemplos:

fmtMSS(    0 );  //   0:00
fmtMSS(   '8');  //   0:08
fmtMSS(    9 );  //   0:09
fmtMSS(  '10');  //   0:10
fmtMSS(   59 );  //   0:59
fmtMSS( +'60');  //   1:00
fmtMSS(   69 );  //   1:09
fmtMSS( 3599 );  //  59:59
fmtMSS('3600');  //  60:00
fmtMSS('3661');  //  61:01
fmtMSS( 7425 );  // 123:45

Descompostura:

function fmtMSS(s){   // accepts seconds as Number or String. Returns m:ss
  return( s -         // take value s and subtract (will try to convert String to Number)
          ( s %= 60 ) // the new value of s, now holding the remainder of s divided by 60 
                      // (will also try to convert String to Number)
        ) / 60 + (    // and divide the resulting Number by 60 
                      // (can never result in a fractional value = no need for rounding)
                      // to which we concatenate a String (converts the Number to String)
                      // who's reference is chosen by the conditional operator:
          9 < s       // if    seconds is larger than 9
          ? ':'       // then  we don't need to prepend a zero
          : ':0'      // else  we do need to prepend a zero
        ) + s ;       // and we add Number s to the string (converting it to String as well)
}

Nota: El rango negativo podría agregarse anteponiendo (0>s?(s=-s,'-'):'')+a la expresión de retorno (en realidad, (0>s?(s=-s,'-'):0)+también funcionaría).

También puede usar el objeto Fecha nativo:

var date = new Date(null);
date.setSeconds(timeInSeconds);

// retrieve time ignoring the browser timezone - returns hh:mm:ss
var utc = date.toUTCString();
// negative start index in substr does not work in IE 8 and earlier
var time = utc.substr(utc.indexOf(':') - 2, 8)

// retrieve each value individually - returns h:m:s
var time = date.getUTCHours() + ':' + date.getUTCMinutes() + ':' +  date.getUTCSeconds();

// does not work in IE8 and below - returns hh:mm:ss
var time = date.toISOString().substr(11, 8);

// not recommended - only if seconds number includes timezone difference
var time = date.toTimeString().substr(0, 8);

Por supuesto, esta solución solo funciona durante timeInSeconds menos de 24 horas;)

2019 mejor variante

Formato hh:mm:ss

console.log(display(60 * 60 * 2.5 + 25)) // 2.5 hours + 25 seconds

function display (seconds) {
  const format = val => `0${Math.floor(val)}`.slice(-2)
  const hours = seconds / 3600
  const minutes = (seconds % 3600) / 60

  return [hours, minutes, seconds % 60].map(format).join(':')
}

function secondsToMinutes(time){
    return Math.floor(time / 60)+':'+Math.floor(time % 60);
}

Para agregar ceros a la izquierda, simplemente haría:

var minutes = "0" + Math.floor(time / 60);
var seconds = "0" + (time - minutes * 60);
return minutes.substr(-2) + ":" + seconds.substr(-2);

Agradable y corto

Limpie un revestimiento usando ES6

const secondsToMinutes = seconds => Math.floor(seconds / 60) + ':' + ('0' + Math.floor(seconds % 60)).slice(-2);

Un trazador de líneas (no funciona con horas):

 function sectostr(time) {
    return ~~(time / 60) + ":" + (time % 60 < 10 ? "0" : "") + time % 60;
 }

Segundos a h: mm: ss

var hours = Math.floor(time / 3600);
time -= hours * 3600;

var minutes = Math.floor(time / 60);
time -= minutes * 60;

var seconds = parseInt(time % 60, 10);

console.log(hours + ':' + (minutes < 10 ? '0' + minutes : minutes) + ':' + (seconds < 10 ? '0' + seconds : seconds));

La siguiente función lo ayudará a obtener días, horas, minutos, segundos

toDDHHMMSS(inputSeconds){
        const Days = Math.floor( inputSeconds / (60 * 60 * 24) );
        const Hour = Math.floor((inputSeconds % (60 * 60 * 24)) / (60 * 60));
        const Minutes = Math.floor(((inputSeconds % (60 * 60 * 24)) % (60 * 60)) / 60 );
        const Seconds = Math.floor(((inputSeconds % (60 * 60 * 24)) % (60 * 60)) % 60 );
        let ddhhmmss  = '';
        if (Days > 0){
            ddhhmmss += Days + ' Day ';
        }
        if (Hour > 0){
            ddhhmmss += Hour + ' Hour ';
        }

        if (Minutes > 0){
            ddhhmmss += Minutes + ' Minutes ';
        }

        if (Seconds > 0){
            ddhhmmss += Seconds + ' Seconds ';
        }
        return ddhhmmss;
    }
alert( toDDHHMMSS(2000));

Después de todo esto, otra solución más simple:

const time = new Date(null);
time.setSeconds(7530);
console.log(time.getHours(), time.getMinutes(), time.getSeconds());

Otra solución mucho más elegante para esto es la siguiente:

/**
 * Convert number secs to display time
 *
 * 65 input becomes 01:05.
 *
 * @param Number inputSeconds Seconds input.
 */
export const toMMSS = inputSeconds => {
    const secs = parseInt( inputSeconds, 10 );
    let minutes = Math.floor( secs / 60 );
    let seconds = secs - minutes * 60;

    if ( 10 > minutes ) {
        minutes = '0' + minutes;
    }
    if ( 10 > seconds ) {
        seconds = '0' + seconds;
    }

    // Return display.
    return minutes + ':' + seconds;
};

Para agregar ceros, realmente no veo la necesidad de tener otra función completa donde simplemente pueda usar, por ejemplo

var mins=Math.floor(StrTime/60);
var secs=StrTime-mins * 60;
var hrs=Math.floor(StrTime / 3600);
RoundTime.innerHTML=(hrs>9?hrs:"0"+hrs) + ":" + (mins>9?mins:"0"+mins) + ":" + (secs>9?secs:"0"+secs);

Es por eso que tenemos declaraciones condicionales en primer lugar.

(condición? si es verdadero: si es falso) así que si los segundos de ejemplo son más de 9 que solo mostrar segundos, agregue una cadena 0 antes.

intente esto: convirtiendo el segundo a HORAS, MIN y SEC.

function convertTime(sec) {
    var hours = Math.floor(sec/3600);
    (hours >= 1) ? sec = sec - (hours*3600) : hours = '00';
    var min = Math.floor(sec/60);
    (min >= 1) ? sec = sec - (min*60) : min = '00';
    (sec < 1) ? sec='00' : void 0;

    (min.toString().length == 1) ? min = '0'+min : void 0;    
    (sec.toString().length == 1) ? sec = '0'+sec : void 0;    

    return hours+':'+min+':'+sec;
}

Si está utilizando Moment.js , puede usar el Durationobjeto incorporado

const duration = moment.duration(4825, 'seconds');

const h = duration.hours(); // 1
const m = duration.minutes(); // 20
const s = duration.seconds(); // 25

ACTUALIZACIÓN 2020

Usando matemáticas básicas y JavaScript simple, esto se puede hacer en solo unas pocas líneas de código.

EJEMPLO - Convertir 7735 secondsa HH:MM:SS.

MATEMÁTICAS:

Uso de cálculos:

1. Math.floor()- https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/floor

La Math.floor()función devuelve el entero más grande menor o igual a un número dado.

2. %operador aritmético (resto): https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Remainder

El operador restante devuelve el resto restante cuando un operando se divide por un segundo operando. Siempre toma el signo del dividendo.

Mira el código a continuación. Los segundos se dividen entre 3600para obtener el número de horas y el resto, que se utiliza para calcular el número de minutos y segundos.

HOURS => 7735 / 3600 = 2 remainder 535

MINUTES => 535 / 60 = 8 remainder 55

SECONDS => 55

CEROS A LA IZQUIERDA:

Muchas respuestas aquí usan métodos complicados para mostrar el número de horas, minutos y segundos de manera adecuada con cero a la izquierda 45, 04etc. Esto se puede hacer usando padStart(). Esto funciona para cadenas, por lo que el número debe convertirse a cadena usando toString().

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padStart

El padStart()método rellena la cadena actual con otra cadena (varias veces, si es necesario) hasta que la cadena resultante alcanza la longitud dada. El relleno se aplica desde el inicio de la cadena actual.

CÓDIGO:

function secondsToTime(e){
    var h = Math.floor(e / 3600).toString().padStart(2,'0'),
        m = Math.floor(e % 3600 / 60).toString().padStart(2,'0'),
        s = Math.floor(e % 60).toString().padStart(2,'0');
    
    return h + ':' + m + ':' + s;
}

console.log(secondsToTime(7735));  //02:08:55

/*
secondsToTime(SECONDS) => HH:MM:SS 

secondsToTime(8)       => 00:00:08 
secondsToTime(68)      => 00:01:08
secondsToTime(1768)    => 00:29:28
secondsToTime(3600)    => 01:00:00
secondsToTime(5296)    => 01:28:16
secondsToTime(7735)    => 02:08:55
secondsToTime(45296)   => 12:34:56
secondsToTime(145296)  => 40:21:36
secondsToTime(1145296) => 318:08:16
*/

Has hecho suficiente código para rastrear minutos y segundos porciones de tiempo.

Lo que podría hacer es agregar el factor horas en:

var hrd = time % (60 * 60 * 60);
var hours = Math.floor(hrd / 60);

var mind = hrd % 60;
var minutes = Math.floor(mind / 60);

var secd = mind % 60;
var seconds = Math.ceil(secd);

var moreminutes = minutes + hours * 60

Esto te daría lo que necesitas también.

Estaba pensando en una forma más rápida de hacer esto y esto es lo que se me ocurrió

var sec = parseInt(time);
var min=0;
while(sec>59){ sec-=60; min++;}

Si queremos convertir el "tiempo" en minutos y segundos, por ejemplo:

// time = 75,3 sec
var sec = parseInt(time); //sec = 75
var min=0;
while(sec>59){ sec-=60; min++;} //sec = 15; min = 1

Pon mis dos centavos en:

function convertSecondsToMinutesAndSeconds(seconds){
            var minutes;
            var seconds;
            minutes = Math.floor(seconds/60);
            seconds = seconds%60;

            return [minutes, seconds];
        }

Así que esto :

var minutesAndSeconds = convertSecondsToMinutesAndSeconds(101);

Tendrá el siguiente resultado:

[1,41];

Luego puede imprimirlo así:

console.log('TIME : ' +  minutesSeconds[0] + ' minutes, ' + minutesSeconds[1] + ' seconds');

//TIME : 1 minutes, 41 seconds

strftime.js ( strftime github ) es una de las mejores bibliotecas de formato de tiempo. Es extremadamente ligero, 30 KB, y efectivo. Utilizándolo, puede convertir segundos en tiempo fácilmente en una línea de código, confiando principalmente en la clase Date nativa.

Al crear una nueva Fecha, cada argumento opcional es posicional de la siguiente manera:

new Date(year, month, day, hours, minutes, seconds, milliseconds);

Entonces, si inicializa una nueva Fecha con todos los argumentos como cero hasta los segundos, obtendrá:

var seconds = 150;
var date = new Date(0,0,0,0,0,seconds);
=> Sun Dec 31 1899 00:02:30 GMT-0500 (EST)

Puede ver que 150 segundos son 2 minutos y 30 segundos, como se ve en la fecha de creación. Luego, utilizando un formato de tiempo de ejecución ("% M:% S" para "MM: SS"), generará la cadena de minutos.

var mm_ss_str = strftime("%M:%S", date);
=> "02:30"

En una línea, se vería así:

var mm_ss_str = strftime('%M:%S', new Date(0,0,0,0,0,seconds));
=> "02:30"

Además, esto le permitiría un soporte intercambiable HH: MM: SS y MM: SS en función de la cantidad de segundos. Por ejemplo:

# Less than an Hour (seconds < 3600)
var seconds = 2435;
strftime((seconds >= 3600 ? '%H:%M:%S' : '%M:%S'), new Date(0,0,0,0,0,seconds));
=> "40:35"

# More than an Hour (seconds >= 3600)
var seconds = 10050;
strftime((seconds >= 3600 ? '%H:%M:%S' : '%M:%S'), new Date(0,0,0,0,0,seconds));
=> "02:47:30"

Y, por supuesto, puede simplemente pasar el formato que desee a medio tiempo si desea que la cadena de tiempo sea más o menos semántica.

var format = 'Honey, you said you\'d be read in %S seconds %M minutes ago!';
strftime(format, new Date(0,0,0,0,0,1210));
=> "Honey, you said you'd be read in 10 seconds 20 minutes ago!"

Espero que esto ayude.

export function TrainingTime(props) {
    const {train_time } = props;
    const hours = Math.floor(train_time/3600);
    const minutes = Math.floor((train_time-hours * 3600) / 60);
    const seconds = Math.floor((train_time%60));

    return `${hours} hrs  ${minutes} min  ${seconds} sec`;
}

Sugiero otra solución:

function formatTime(nbSeconds, hasHours) {
    var time = [],
        s = 1;
    var calc = nbSeconds;

    if (hasHours) {
        s = 3600;
        calc = calc / s;
        time.push(format(Math.floor(calc)));//hour
    }

    calc = ((calc - (time[time.length-1] || 0)) * s) / 60;
    time.push(format(Math.floor(calc)));//minute

    calc = (calc - (time[time.length-1])) * 60;
    time.push(format(Math.round(calc)));//second


    function format(n) {//it makes "0X"/"00"/"XX"
        return (("" + n) / 10).toFixed(1).replace(".", "");
    }

    //if (!hasHours) time.shift();//you can set only "min: sec"

    return time.join(":");
};
console.log(formatTime(3500));//58:20
console.log(formatTime(305));//05:05
console.log(formatTime(75609, true));//21:00:09
console.log(formatTime(0, true));//00:00:00

Sé que se ha resuelto de muchas maneras. Necesitaba esta función para un script de After Effects, donde la velocidad o la contaminación del espacio de nombres no es un problema. Lo dejo aquí para alguien que necesita algo similar. También escribí algunas pruebas y funcionó bien. Así que aquí está el código:

Number.prototype.asTime = function () {
    var hour = Math.floor(this / 3600),
        min = Math.floor((this - hour * 3600) / 60),
        sec = this - hour * 3600 - min * 60,
        hourStr, minStr, secStr;
    if(hour){
        hourStr = hour.toString(),
        minStr = min < 9 ? "0" + min.toString() : min.toString();
        secStr = sec < 9 ? "0" + sec.toString() : sec.toString();
        return hourStr + ":" + minStr + ":" + secStr + "hrs";
    }
    if(min){
        minStr = min.toString();
        secStr = sec < 9 ? "0" + sec.toString() : sec.toString();
        return  minStr + ":" + secStr + "min";
    }
    return sec.toString() + "sec";
}