C'est un problème courant, mais je ne sais pas comment le résoudre. Le code ci-dessous fonctionne bien.

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

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

Cependant, quand j'arrive à 1 heure ou 3600 secondes, il renvoie 0 minute et 0 seconde. Comment puis-je éviter cela pour qu'il renvoie toutes les minutes?

Merci

Pour obtenir le nombre de minutes complètes, divisez le nombre total de secondes par 60 (60 secondes / minute):

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

Et pour obtenir les secondes restantes, multipliez les minutes complètes par 60 et soustrayez du nombre total de secondes:

var seconds = time - minutes * 60;

Maintenant, si vous souhaitez également obtenir les heures complètes, divisez d'abord le nombre total de secondes par 3600 (60 minutes / heure · 60 secondes / minute), puis calculez les secondes restantes:

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

Ensuite, vous calculez les minutes complètes et les secondes restantes.

Prime:

Utilisez le code suivant pour bien imprimer l'heure (suggéré par 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);

Une autre solution sophistiquée:

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

~~est un raccourci pour Math.floor, voir ce lien pour plus d'informations

Essayez en ligne

Pour les personnes souhaitant une solution rapide, simple et donc courte pour formater les secondes en M:SS:

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

fait ..
La fonction accepte soit un Number( de préférence) ou un String(2 conversion « pénalités » que vous pouvez réduire de moitié par préfixer +dans l'argument de l'appel de fonction pour scomme dans: fmtMSS(+strSeconds)), représentant secondes entiers positifs scomme argument.

Exemples:

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

Panne:

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

Remarque: une plage négative pourrait être ajoutée en ajoutant (0>s?(s=-s,'-'):'')+le préfixe à l'expression de retour (en fait, (0>s?(s=-s,'-'):0)+cela fonctionnerait également).

Vous pouvez également utiliser l'objet Date natif:

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

Bien sûr, cette solution ne fonctionne que pour timeInSeconds moins de 24 heures;)

Meilleure variante 2019

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

Pour ajouter des zéros non significatifs, je ferais simplement:

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

Nice et court

Nettoyez une doublure avec ES6

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

Une seule doublure (ne fonctionne pas avec des heures):

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

Secondes à 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 fonction suivante vous aidera à obtenir les jours, heures, minutes, secondes

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

Après tout cela, encore une autre solution simple:

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

Une autre solution bien plus élégante pour cela est la suivante:

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

Pour ajouter des zéros, je ne vois vraiment pas la nécessité d'avoir une autre fonction complète où vous pouvez simplement utiliser par exemple

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

C'est pourquoi nous avons des déclarations conditionnelles en premier lieu.

(condition? si vrai: si faux) donc si l'exemple de secondes est supérieur à 9, affichez simplement les secondes sinon ajoutez une chaîne 0 avant.

essayez ceci: Conversion de Second en HOURS, MIN et 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 vous utilisez Moment.js, vous pouvez utiliser l' Durationobjet intégré

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

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

MISE À JOUR 2020

En utilisant des mathématiques de base et du javascript simple, cela peut être fait en quelques lignes de code.

EXEMPLE - Convertir 7735 secondsen HH:MM:SS.

MATH:

Les calculs utilisent:

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

La Math.floor()fonction renvoie le plus grand entier inférieur ou égal à un nombre donné.

2. %opérateur arithmétique (Remainder) - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Remainder

L'opérateur reste renvoie le reste restant lorsqu'un opérande est divisé par un second opérande. Il prend toujours le signe du dividende.

Consultez le code ci-dessous. Les secondes sont divisées par 3600pour obtenir le nombre d'heures et un reste, qui est utilisé pour calculer le nombre de minutes et de secondes.

HOURS => 7735 / 3600 = 2 remainder 535

MINUTES => 535 / 60 = 8 remainder 55

SECONDS => 55

ZÉROS DE TÊTE:

De nombreuses réponses ici utilisent des méthodes compliquées pour afficher correctement le nombre d'heures, de minutes et de secondes avec un zéro non significatif - 45, 04etc. Cela peut être fait en utilisant padStart(). Cela fonctionne pour les chaînes, donc le nombre doit être converti en chaîne à l'aide de toString().

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

La padStart()méthode complète la chaîne actuelle avec une autre chaîne (plusieurs fois, si nécessaire) jusqu'à ce que la chaîne résultante atteigne la longueur donnée. Le remplissage est appliqué à partir du début de la chaîne actuelle.

CODE:

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

Vous avez fait suffisamment de code pour suivre des portions de temps en minutes et en secondes.

Ce que vous pouvez faire, c'est ajouter le facteur heures dans:

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

Cela vous donnerait également ce dont vous avez besoin.

Je pensais à un moyen plus rapide de faire cela et c'est ce que j'ai proposé

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

Si nous voulons convertir le "temps" en minutes et secondes, par exemple:

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

Mettez mes deux cents dans:

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

            return [minutes, seconds];
        }

Donc ça :

var minutesAndSeconds = convertSecondsToMinutesAndSeconds(101);

Aura la sortie suivante:

[1,41];

Ensuite, vous pouvez l'imprimer comme ceci:

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

//TIME : 1 minutes, 41 seconds

strftime.js ( strftime github ) est l'une des meilleures bibliothèques de formatage de temps. Il est extrêmement léger - 30 Ko - et efficace. En l'utilisant, vous pouvez facilement convertir des secondes en temps en une seule ligne de code, en vous appuyant principalement sur la classe Date native.

Lors de la création d'une nouvelle date, chaque argument facultatif est positionnel comme suit:

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

Donc, si vous initialisez une nouvelle date avec tous les arguments à zéro jusqu'aux secondes, vous obtiendrez:

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

Vous pouvez voir que 150 secondes correspondent à 2 minutes et 30 secondes, comme le montre la date de création. Puis en utilisant un format strftime ("% M:% S" pour "MM: SS"), il affichera la chaîne de vos minutes.

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

En une seule ligne, cela ressemblerait à:

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

De plus, cela vous permettrait de prendre en charge interchangeables HH: MM: SS et MM: SS en fonction du nombre de secondes. Par exemple:

# 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"

Et bien sûr, vous pouvez simplement transmettre le format que vous souhaitez strftime si vous voulez que la chaîne de temps soit plus ou moins sémantique.

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!"

J'espère que cela t'aides.

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

Je propose une autre solution:

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

Je sais que cela a été résolu de plusieurs façons. J'avais besoin de cette fonction pour un script After Effects, où la vitesse ou la pollution de l'espace de noms n'est pas un problème. Je le laisse ici pour quelqu'un qui a besoin de quelque chose de similaire. J'ai également écrit quelques tests et j'ai bien fonctionné. Alors voici le code:

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