Dies ist ein häufiges Problem, aber ich bin mir nicht sicher, wie ich es lösen soll. Der folgende Code funktioniert einwandfrei.

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

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

Wenn ich jedoch 1 Stunde oder 3600 Sekunden erreiche, werden 0 Minuten und 0 Sekunden zurückgegeben. Wie kann ich dies vermeiden, damit alle Minuten zurückgegeben werden?

Vielen Dank

Teilen Sie die Anzahl der Gesamtsekunden durch 60 (60 Sekunden / Minute), um die Anzahl der vollen Minuten zu erhalten:

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

Und um die verbleibenden Sekunden zu erhalten, multiplizieren Sie die vollen Minuten mit 60 und subtrahieren Sie von den gesamten Sekunden:

var seconds = time - minutes * 60;

Wenn Sie nun auch die vollen Stunden erhalten möchten, teilen Sie zuerst die Anzahl der Gesamtsekunden durch 3600 (60 Minuten / Stunde · 60 Sekunden / Minute) und berechnen Sie dann die verbleibenden Sekunden:

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

Dann berechnen Sie die vollen Minuten und verbleibenden Sekunden.

Bonus:

Verwenden Sie den folgenden Code, um die Zeit hübsch auszudrucken (vorgeschlagen von 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);

Eine weitere ausgefallene Lösung:

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

~~ist eine Abkürzung für Math.floor, siehe diesen Link für weitere Informationen

Versuchen Sie es online

Für Leute, die in der Hoffnung auf eine schnelle, einfache und damit kurze Lösung zum Formatieren von Sekunden vorbeischauen M:SS:

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

erledigt ..
Die Funktion akzeptiert entweder a Number(bevorzugt) oder eine String(2 Konvertierungs- 'Strafen', die Sie halbieren können, indem Sie +dem Argument des Funktionsaufrufs swie in :) voranstellen fmtMSS(+strSeconds), was positive ganzzahlige Sekunden sals Argument darstellt.

Beispiele:

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

Nervenzusammenbruch:

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

Hinweis: Ein negativer Bereich kann durch Voranstellen (0>s?(s=-s,'-'):'')+des Rückgabeausdrucks hinzugefügt werden (würde tatsächlich (0>s?(s=-s,'-'):0)+auch funktionieren).

Sie können auch ein natives Datumsobjekt verwenden:

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

Natürlich funktioniert diese Lösung nur für timeInSeconds weniger als 24 Stunden;)

2019 beste Variante

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

Um führende Nullen hinzuzufügen, würde ich einfach Folgendes tun:

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

Schön kurz

Reinigen Sie einen Liner mit ES6

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

Ein Einzeiler (funktioniert nicht mit Stunden):

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

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

Mit der folgenden Funktion können Sie Tage, Stunden, Minuten und Sekunden abrufen

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

Nach all dem noch eine einfache Lösung:

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

Eine andere, aber viel elegantere Lösung hierfür ist wie folgt:

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

Zum Hinzufügen von Nullen sehe ich wirklich keine Notwendigkeit für eine vollständige andere Funktion, die Sie zum Beispiel einfach verwenden können

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

Deshalb haben wir in erster Linie bedingte Aussagen.

(Bedingung? wenn wahr: wenn falsch) Wenn also Beispielsekunden mehr als 9 sind als nur Sekunden anzeigen, fügen Sie eine Zeichenfolge 0 davor hinzu.

Versuchen Sie Folgendes: Konvertieren von Second in HOURS, MIN und 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;
}

Wenn Sie Moment.js verwenden , können Sie dort das eingebaute DurationObjekt verwenden

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

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

2020 UPDATE

Mit einfacher Mathematik und einfachem Javascript kann dies in nur wenigen Codezeilen erfolgen.

BEISPIEL - Konvertieren 7735 secondsin HH:MM:SS.

MATHEMATIK:

Berechnungen verwenden:

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

Die Math.floor()Funktion gibt die größte Ganzzahl zurück, die kleiner oder gleich einer bestimmten Zahl ist.

2. %arithmetischer Operator (Rest) - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Remainder

Der Restoperator gibt den verbleibenden Rest zurück, wenn ein Operand durch einen zweiten Operanden geteilt wird. Es braucht immer das Zeichen der Dividende.

Überprüfen Sie den Code unten. Sekunden werden durch geteilt 3600, um die Anzahl der Stunden und einen Rest zu erhalten, der zur Berechnung der Anzahl der Minuten und Sekunden verwendet wird.

HOURS => 7735 / 3600 = 2 remainder 535

MINUTES => 535 / 60 = 8 remainder 55

SECONDS => 55

FÜHRENDE NULLEN:

Viele Antworten hier komplizierte Methoden zu zeigen Anzahl der Stunden, Minuten und Sekunden in geeigneter Weise nutzen mit führenden Null - 45, 04usw. verwendet getan werden kann padStart(). Dies funktioniert für Zeichenfolgen, daher muss die Nummer mithilfe von in Zeichenfolgen konvertiert werdentoString() .

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

Die padStart()Methode füllt die aktuelle Zeichenfolge mit einer anderen Zeichenfolge (bei Bedarf mehrmals), bis die resultierende Zeichenfolge die angegebene Länge erreicht. Das Auffüllen wird ab dem Beginn der aktuellen Zeichenfolge angewendet.

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

Sie haben genug Code erstellt, um Minuten- und Sekundenabschnitte zu verfolgen.

Was Sie tun können, ist den Stundenfaktor hinzuzufügen in:

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

Dies würde Ihnen auch das geben, was Sie brauchen.

Ich dachte an einen schnelleren Weg, um dies zu erreichen, und das habe ich mir ausgedacht

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

Wenn wir "Zeit" in Minuten und Sekunden umrechnen möchten, zum Beispiel:

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

Gib meine zwei Cent ein:

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

            return [minutes, seconds];
        }

Also das :

var minutesAndSeconds = convertSecondsToMinutesAndSeconds(101);

Wird die folgende Ausgabe haben:

[1,41];

Dann können Sie es wie folgt drucken:

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

//TIME : 1 minutes, 41 seconds

strftime.js ( strftime github ) ist eine der besten Formatierungsbibliotheken. Es ist extrem leicht - 30 KB - und effektiv. Mit dieser Funktion können Sie Sekunden einfach in einer Codezeile in Zeit umwandeln, wobei Sie sich hauptsächlich auf die native Datumsklasse verlassen.

Beim Erstellen eines neuen Datums ist jedes optionale Argument wie folgt positioniert:

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

Wenn Sie also ein neues Datum mit allen Argumenten als Null bis zu den Sekunden initialisieren, erhalten Sie:

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

Sie können sehen, dass 150 Sekunden 2 Minuten und 30 Sekunden sind, wie aus dem Erstellungsdatum hervorgeht. Wenn Sie dann ein Strftime-Format ("% M:% S" für "MM: SS") verwenden, wird Ihre Minutenzeichenfolge ausgegeben.

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

In einer Zeile würde es so aussehen:

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

Außerdem können Sie auf diese Weise HH: MM: SS und MM: SS basierend auf der Anzahl der Sekunden austauschbar unterstützen. Beispielsweise:

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

Und natürlich können Sie einfach jedes Format übergeben, das Sie strftime möchten, wenn die Zeitzeichenfolge mehr oder weniger semantisch sein soll.

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

Hoffe das hilft.

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

Ich schlage eine andere Lösung vor:

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

Ich weiß, dass es auf viele Arten gelöst wurde. Ich brauchte diese Funktion für ein After Effects-Skript, bei dem Geschwindigkeits- oder Namespace-Verschmutzung kein Problem darstellt. Ich lasse es hier für jemanden fallen, der etwas Ähnliches braucht. Ich habe auch einige Tests geschrieben und gut funktioniert. Also hier ist der 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";
}