Sekunden mit JavaScript in HH-MM-SS konvertieren?

Wie kann ich HH-MM-SSmit JavaScript Sekunden in eine Zeichenfolge konvertieren ?

Kennst du keine Datumsangaben ? es ist ein Muss zu wissen.

Schreiben Sie mit datejs einfach Folgendes:

(new Date).clearTime()
          .addSeconds(15457)
          .toString('H:mm:ss');

--aktualisieren

Heutzutage ist date.js veraltet und wird nicht mehr gepflegt. Verwenden Sie daher " Moment.js ", was viel besser ist, wie von TJ Crowder hervorgehoben.

--update 2

Bitte verwenden Sie @ Franks eine einzeilige Lösung:

new Date(SECONDS * 1000).toISOString().substr(11, 8)

Es ist bei weitem die beste Lösung.

Sie können dies ohne externe JavaScript-Bibliothek mithilfe der folgenden JavaScript-Datumsmethode tun:

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

Oder gemäß dem Kommentar von @Frank ; ein Einzeiler:

new Date(SECONDS * 1000).toISOString().substr(11, 8);

Ich glaube nicht, dass eine integrierte Funktion des Standard-Date-Objekts dies auf eine Weise für Sie erledigt, die bequemer ist, als nur selbst zu rechnen.

hours = Math.floor(totalSeconds / 3600);
totalSeconds %= 3600;
minutes = Math.floor(totalSeconds / 60);
seconds = totalSeconds % 60;

Beispiel:

let totalSeconds = 28565;
let hours = Math.floor(totalSeconds / 3600);
totalSeconds %= 3600;
let minutes = Math.floor(totalSeconds / 60);
let seconds = totalSeconds % 60;

console.log("hours: " + hours);
console.log("minutes: " + minutes);
console.log("seconds: " + seconds);

// If you want strings with leading zeroes:
minutes = String(minutes).padStart(2, "0");
hours = String(hours).padStart(2, "0");
seconds = String(seconds).padStart(2, "0");
console.log(hours + ":" + minutes + ":" + seconds);

Ich weiß, das ist ein bisschen alt, aber ...

ES2015:

var toHHMMSS = (secs) => {
    var sec_num = parseInt(secs, 10)
    var hours   = Math.floor(sec_num / 3600)
    var minutes = Math.floor(sec_num / 60) % 60
    var seconds = sec_num % 60

    return [hours,minutes,seconds]
        .map(v => v < 10 ? "0" + v : v)
        .filter((v,i) => v !== "00" || i > 0)
        .join(":")
}

Es wird ausgegeben:

toHHMMSS(129600) // 36:00:00
toHHMMSS(13545) // 03:45:45
toHHMMSS(180) // 03:00
toHHMMSS(18) // 00:18

Wie Cleiton in darauf hingewiesen , seine Antwort , moment.js kann dafür verwendet werden:

moment().startOf('day')
        .seconds(15457)
        .format('H:mm:ss');

function formatSeconds(seconds)
{
    var date = new Date(1970,0,1);
    date.setSeconds(seconds);
    return date.toTimeString().replace(/.*(\d{2}:\d{2}:\d{2}).*/, "$1");
}

Das macht den Trick:

function secondstotime(secs)
{
    var t = new Date(1970,0,1);
    t.setSeconds(secs);
    var s = t.toTimeString().substr(0,8);
    if(secs > 86399)
        s = Math.floor((t - Date.parse("1/1/70")) / 3600000) + s.substr(2);
    return s;
}

(Von hier bezogen )

var  timeInSec = "661"; //even it can be string

String.prototype.toHHMMSS = function () { 
   /* extend the String by using prototypical inheritance */
    var seconds = parseInt(this, 10); // don't forget the second param
    var hours   = Math.floor(seconds / 3600);
    var minutes = Math.floor((seconds - (hours * 3600)) / 60);
    seconds = seconds - (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;
}

alert("5678".toHHMMSS());   // "01:34:38"
console.log(timeInSec.toHHMMSS());   //"00:11:01"

Wir können diese Funktion viel kürzer und klarer machen, aber das verringert die Lesbarkeit, sodass wir sie so einfach wie möglich und so stabil wie möglich schreiben.

oder Sie können dies hier überprüfen :

Versuche dies:

function toTimeString(seconds) {
  return (new Date(seconds * 1000)).toUTCString().match(/(\d\d:\d\d:\d\d)/)[0];
}

Hier ist eine Erweiterung der Zahlenklasse. toHHMMSS () konvertiert Sekunden in einen hh: mm: ss-String.

Number.prototype.toHHMMSS = function() {
  var hours = Math.floor(this / 3600) < 10 ? ("00" + Math.floor(this / 3600)).slice(-2) : Math.floor(this / 3600);
  var minutes = ("00" + Math.floor((this % 3600) / 60)).slice(-2);
  var seconds = ("00" + (this % 3600) % 60).slice(-2);
  return hours + ":" + minutes + ":" + seconds;
}

// Usage: [number variable].toHHMMSS();

// Here is a simple test
var totalseconds = 1234;
document.getElementById("timespan").innerHTML = totalseconds.toHHMMSS();

// HTML of the test
<div id="timespan"></div>

Einfach zu verfolgende Version für Noobies:

 var totalNumberOfSeconds = YOURNUMBEROFSECONDS;
 var hours = parseInt( totalNumberOfSeconds / 3600 );
 var minutes = parseInt( (totalNumberOfSeconds - (hours * 3600)) / 60 );
 var seconds = Math.floor((totalNumberOfSeconds - ((hours * 3600) + (minutes * 60))));
 var result = (hours < 10 ? "0" + hours : hours) + ":" + (minutes < 10 ? "0" + minutes : minutes) + ":" + (seconds  < 10 ? "0" + seconds : seconds);
 console.log(result);

Diese Funktion sollte es tun:

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

Ohne ein Trennzeichen zu übergeben, wird es :als (Standard-) Trennzeichen verwendet:

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

Wenn Sie -als Trennzeichen verwenden möchten , übergeben Sie es einfach als zweiten Parameter:

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

Siehe auch diese Geige .

Unten ist der angegebene Code, der Sekunden in das hh-mm-ss-Format konvertiert:

var measuredTime = new Date(null);
measuredTime.setSeconds(4995); // specify value of SECONDS
var MHSTime = measuredTime.toISOString().substr(11, 8);

Holen Sie sich eine alternative Methode aus Konvertieren Sie Sekunden in das HH-MM-SS-Format in JavaScript

var time1 = date1.getTime();
var time2 = date2.getTime();
var totalMilisec = time2 - time1;

alert(DateFormat('hh:mm:ss',new Date(totalMilisec)))

 /* ----------------------------------------------------------
 *  Field        | Full Form          | Short Form
 *  -------------|--------------------|-----------------------
 *  Year         | yyyy (4 digits)    | yy (2 digits)
 *  Month        | MMM (abbr.)        | MM (2 digits)
                 | NNN (name)         |
 *  Day of Month | dd (2 digits)      | 
 *  Day of Week  | EE (name)          | E (abbr)
 *  Hour (1-12)  | hh (2 digits)      | 
 *  Minute       | mm (2 digits)      | 
 *  Second       | ss (2 digits)      | 
 *  ----------------------------------------------------------
 */
function DateFormat(formatString,date){
    if (typeof date=='undefined'){
    var DateToFormat=new Date();
    }
    else{
        var DateToFormat=date;
    }
    var DAY         = DateToFormat.getDate();
    var DAYidx      = DateToFormat.getDay();
    var MONTH       = DateToFormat.getMonth()+1;
    var MONTHidx    = DateToFormat.getMonth();
    var YEAR        = DateToFormat.getYear();
    var FULL_YEAR   = DateToFormat.getFullYear();
    var HOUR        = DateToFormat.getHours();
    var MINUTES     = DateToFormat.getMinutes();
    var SECONDS     = DateToFormat.getSeconds();

    var arrMonths = new Array("January","February","March","April","May","June","July","August","September","October","November","December");
    var arrDay=new Array('Sunday','Monday','Tuesday','Wednesday','Thursday','Friday','Saturday');
    var strMONTH;
    var strDAY;
    var strHOUR;
    var strMINUTES;
    var strSECONDS;
    var Separator;

    if(parseInt(MONTH)< 10 && MONTH.toString().length < 2)
        strMONTH = "0" + MONTH;
    else
        strMONTH=MONTH;
    if(parseInt(DAY)< 10 && DAY.toString().length < 2)
        strDAY = "0" + DAY;
    else
        strDAY=DAY;
    if(parseInt(HOUR)< 10 && HOUR.toString().length < 2)
        strHOUR = "0" + HOUR;
    else
        strHOUR=HOUR;
    if(parseInt(MINUTES)< 10 && MINUTES.toString().length < 2)
        strMINUTES = "0" + MINUTES;
    else
        strMINUTES=MINUTES;
    if(parseInt(SECONDS)< 10 && SECONDS.toString().length < 2)
        strSECONDS = "0" + SECONDS;
    else
        strSECONDS=SECONDS;

    switch (formatString){
        case "hh:mm:ss":
            return strHOUR + ':' + strMINUTES + ':' + strSECONDS;
        break;
        //More cases to meet your requirements.
    }
}

Ich wollte nur eine kleine Erklärung für die nette Antwort oben geben:

var totalSec = new Date().getTime() / 1000;
var hours = parseInt( totalSec / 3600 ) % 24;
var minutes = parseInt( totalSec / 60 ) % 60;
var seconds = totalSec % 60;

var result = (hours < 10 ? "0" + hours : hours) + "-" + (minutes < 10 ? "0" + minutes : minutes) + "-" + (seconds  < 10 ? "0" + seconds : seconds);

In der zweiten Zeile teilen wir die Gesamtzahl der Sekunden durch 3600, um die Gesamtzahl der Stunden zu erhalten, da in einer Stunde 3600 Sekunden vorhanden sind. Wir verwenden parseInt, um Dezimalstellen zu entfernen. Wenn totalSec 12600 (dreieinhalb Stunden) wäre, würde parseInt (totalSec / 3600) 3 zurückgeben, da wir 3 volle Stunden haben werden. Warum brauchen wir in diesem Fall die% 24? Wenn wir 24 Stunden überschreiten, nehmen wir an, wir haben 25 Stunden (90000 Sekunden), dann bringt uns das Modulo hier wieder auf 1 zurück, anstatt 25 zurückzugeben. Es beschränkt das Ergebnis innerhalb eines 24-Stunden-Limits, da es 24 Stunden gibt in einem Tag.

Wenn Sie so etwas sehen:

25 % 24

Stellen Sie sich das so vor:

25 mod 24 or what is the remainder when we divide 25 by 24

In diesen alten Thread einsteigen - das OP gab HH: MM: SS an, und viele der Lösungen funktionieren, bis Sie feststellen, dass Sie mehr als 24 Stunden benötigen. Und vielleicht möchten Sie nicht mehr als eine einzige Codezeile. Bitte schön:

d=(s)=>{f=Math.floor;g=(n)=>('00'+n).slice(-2);return f(s/3600)+':'+g(f(s/60)%60)+':'+g(s%60)}

Es gibt H +: MM: SS zurück. Um es zu benutzen, benutze einfach:

d(91260);     // returns "25:21:00"
d(960);       // returns "0:16:00"

... Ich habe versucht, die geringstmögliche Menge an Code für einen netten Einzeiler-Ansatz zu verwenden.

Für den Sonderfall von HH: MM: SS.MS (Gleichung: "00: 04: 33.637"), wie er von FFMPEG zur Angabe von Millisekunden verwendet wird .

[-] [HH:] MM: SS [.m ...]

HH drückt die Anzahl der Stunden aus, MM die Anzahl der Minuten für maximal 2 Stellen und SS die Anzahl der Sekunden für maximal 2 Stellen. Das m am Ende drückt den Dezimalwert für SS aus.

/* HH:MM:SS.MS to (FLOAT)seconds ---------------*/
function timerToSec(timer){
   let vtimer = timer.split(":")
   let vhours = +vtimer[0]
   let vminutes = +vtimer[1]
   let vseconds = parseFloat(vtimer[2])
   return vhours * 3600 + vminutes * 60 + vseconds
}

/* Seconds to (STRING)HH:MM:SS.MS -----------------------*/
function secToTimer(sec){
  let o = new Date(0)
  let p =  new Date(sec*1000)  
  return new Date(p.getTime()-o.getTime())
    .toISOString()
    .split("T")[1]
    .split("Z")[0]
}


/* Example: 7hours, 4 minutes, 33 seconds and 637 milliseconds */
const t = "07:04:33.637"
console.log(
  t + " => " +
  timerToSec(t) +
  "s"
)

/* Test: 25473 seconds and 637 milliseconds */
const s = 25473.637 // "25473.637"
console.log(
  s + "s => " + 
  secToTimer(s)
)

Beispielverwendung, ein Millisekunden-Transport-Timer:

/* Seconds to (STRING)HH:MM:SS.MS -----------------------*/
function secToTimer(sec){
  let o = new Date(0)
  let p =  new Date(sec*1000)  
  return new Date(p.getTime()-o.getTime())
    .toISOString()
    .split("T")[1]
    .split("Z")[0]
}


let job, origin = new Date().getTime()
const timer = () => {
  job = requestAnimationFrame(timer)
  OUT.textContent = secToTimer((new Date().getTime() - origin) / 1000)
}

requestAnimationFrame(timer)

span {font-size:4rem}

<span id="OUT"></span>
<br>
<button onclick="origin = new Date().getTime()">RESET</button>
<button onclick="requestAnimationFrame(timer)">RESTART</button>
<button onclick="cancelAnimationFrame(job)">STOP</button>

Anwendungsbeispiel, gebunden an ein Medienelement

/* Seconds to (STRING)HH:MM:SS.MS -----------------------*/
function secToTimer(sec){
  let o = new Date(0)
  let p =  new Date(sec*1000)  
  return new Date(p.getTime()-o.getTime())
    .toISOString()
    .split("T")[1]
    .split("Z")[0]
}

VIDEO.addEventListener("timeupdate", function(e){
  OUT.textContent = secToTimer(e.target.currentTime)
}, false)

span {font-size:4rem}

<span id="OUT"></span><br>
<video id="VIDEO" width="400" controls autoplay>
  <source src="https://www.w3schools.com/html/mov_bbb.mp4" type="video/mp4">
</video>

Außerhalb der Frage sind diese Funktionen in PHP geschrieben:

<?php 
/* HH:MM:SS to (FLOAT)seconds --------------*/
function timerToSec($timer){
  $vtimer = explode(":",$timer);
  $vhours = (int)$vtimer[0];
  $vminutes = (int)$vtimer[1];
  $vseconds = (float)$vtimer[2];
  return $vhours * 3600 + $vminutes * 60 + $vseconds;
}
/* Seconds to (STRING)HH:MM:SS -----------------*/
function secToTimer($sec){
  return explode(" ", date("H:i:s", $sec))[0];  
}

Haben Sie versucht, einem Datumsobjekt Sekunden hinzuzufügen?

var dt = new Date();
dt.addSeconds(1234);

Ein Beispiel: https://jsfiddle.net/j5g2p0dc/5/

Aktualisiert: Der Beispiellink fehlte, daher habe ich einen neuen erstellt.

Hier ist eine Funktion zum Konvertieren von Sekunden in das hh-mm-ss-Format basierend auf der Antwort von powtac hier

jsfiddle

/** 
 * Convert seconds to hh-mm-ss format.
 * @param {number} totalSeconds - the total seconds to convert to hh- mm-ss
**/
var SecondsTohhmmss = function(totalSeconds) {
  var hours   = Math.floor(totalSeconds / 3600);
  var minutes = Math.floor((totalSeconds - (hours * 3600)) / 60);
  var seconds = totalSeconds - (hours * 3600) - (minutes * 60);

  // round seconds
  seconds = Math.round(seconds * 100) / 100

  var result = (hours < 10 ? "0" + hours : hours);
      result += "-" + (minutes < 10 ? "0" + minutes : minutes);
      result += "-" + (seconds  < 10 ? "0" + seconds : seconds);
  return result;
}

Beispiel Verwendung

var seconds = SecondsTohhmmss(70);
console.log(seconds);
// logs 00-01-10

Nachdem ich mir alle Antworten angesehen hatte und mit den meisten nicht zufrieden war, kam ich auf diese Idee. Ich weiß, dass ich sehr spät zum Gespräch komme, aber hier ist es trotzdem.

function secsToTime(secs){
  var time = new Date(); 
  // create Date object and set to today's date and time
  time.setHours(parseInt(secs/3600) % 24);
  time.setMinutes(parseInt(secs/60) % 60);
  time.setSeconds(parseInt(secs%60));
  time = time.toTimeString().split(" ")[0];
  // time.toString() = "HH:mm:ss GMT-0800 (PST)"
  // time.toString().split(" ") = ["HH:mm:ss", "GMT-0800", "(PST)"]
  // time.toTimeString().split(" ")[0]; = "HH:mm:ss"
  return time;
}

Ich erstelle ein neues Datumsobjekt, ändere die Uhrzeit in meine Parameter, konvertiere das Datumsobjekt in eine Zeitzeichenfolge und entferne das zusätzliche Material, indem ich die Zeichenfolge teile und nur den Teil zurückgebe, der benötigt wird.

Ich dachte, ich würde diesen Ansatz teilen, da Regex, Logik und mathematische Akrobatik nicht mehr erforderlich sind, um die Ergebnisse im Format "HH: mm: ss" zu erhalten. Stattdessen werden integrierte Methoden verwendet.

Vielleicht möchten Sie sich die Dokumentation hier ansehen: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date

Es gibt viele Möglichkeiten, dieses Problem zu lösen, und es gibt natürlich gute Möglichkeiten, die vorgeschlagen werden. Aber ich möchte hier noch einen optimierten Code hinzufügen

function formatSeconds(sec) {
     return [(sec / 3600), ((sec % 3600) / 60), ((sec % 3600) % 60)]
            .map(v => v < 10 ? "0" + parseInt(v) : parseInt(v))
            .filter((i, j) => i !== "00" || j > 0)
            .join(":");
}

Wenn Sie keine formatierte Null mit weniger als 10 Zahlen möchten, können Sie diese verwenden

function formatSeconds(sec) {
  return parseInt(sec / 3600) + ':' + parseInt((sec % 3600) / 60) + ':' + parseInt((sec % 3600) % 60);

}}

Beispielcode http://fiddly.org/1c476/1

In einer Zeile mit der Lösung von TJ Crowder:

secToHHMMSS = seconds => `${Math.floor(seconds / 3600)}:${Math.floor((seconds % 3600) / 60)}:${Math.floor((seconds % 3600) % 60)}`

In einer Zeile eine andere Lösung, die auch Tage zählt:

secToDHHMMSS = seconds => `${parseInt(seconds / 86400)}d ${new Date(seconds * 1000).toISOString().substr(11, 8)}`

Quelle: https://gist.github.com/martinbean/2bf88c446be8048814cf02b2641ba276

var sec_to_hms = function(sec){
var min, hours;
     sec = sec - (min = Math.floor(sec/60))*60;
     min = min - (hours = Math.floor(min/60))*60;
     return (hours?hours+':':'') + ((min+'').padStart(2, '0')) + ':'+ ((sec+'').padStart(2, '0'));
}
alert(sec_to_hms(2442542));

Sie können auch den folgenden Code verwenden:

int ss = nDur%60;
nDur   = nDur/60;
int mm = nDur%60;
int hh = nDur/60;

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

Ergebnis 15:08:03

Für jeden, der AngularJS verwendet, besteht eine einfache Lösung darin, den Wert mit der Datums-API zu filtern , die Millisekunden basierend auf dem angeforderten Format in eine Zeichenfolge konvertiert. Beispiel:

<div>Offer ends in {{ timeRemaining | date: 'HH:mm:ss' }}</div>

Beachten Sie, dass dies Millisekunden erwartet. Wenn Sie von Sekunden konvertieren (wie die ursprüngliche Frage formuliert wurde), möchten Sie möglicherweise timeRemaining mit 1000 multiplizieren.

Ich bin auf den Fall gestoßen, in dem einige erwähnt haben, dass die Anzahl der Sekunden mehr als einen Tag beträgt. Hier ist eine angepasste Version von @Harish Anchus bestbewerteter Antwort, die längere Zeiträume berücksichtigt:

function secondsToTime(seconds) {
  const arr = new Date(seconds * 1000).toISOString().substr(11, 8).split(':');

  const days = Math.floor(seconds / 86400);
  arr[0] = parseInt(arr[0], 10) + days * 24;

  return arr.join(':');
}

Beispiel:

secondsToTime(101596) // outputs '28:13:16' as opposed to '04:13:16'

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

Anwendungsbeispiel

alert("186".toHHMMSS());

Keine der Antworten hier entspricht meinen Anforderungen, da ich damit umgehen möchte

1. Große Anzahl von Sekunden (Tagen) und
2. Negative Zahlen

Obwohl diese vom OP nicht verlangt werden, empfiehlt es sich, Randfälle abzudecken, insbesondere wenn dies nur wenig Aufwand erfordert.

Es ist ziemlich offensichtlich, dass das OP eine ANZAHL von Sekunden bedeutet, wenn er Sekunden sagt . Warum sollten Sie Ihre Funktion festlegen String?

function secondsToTimeSpan(seconds) {
    const value = Math.abs(seconds);
    const days = Math.floor(value / 1440);
    const hours = Math.floor((value - (days * 1440)) / 3600);
    const min = Math.floor((value - (days * 1440) - (hours * 3600)) / 60);
    const sec = value - (days * 1440) - (hours * 3600) - (min * 60);
    return `${seconds < 0 ? '-':''}${days > 0 ? days + '.':''}${hours < 10 ? '0' + hours:hours}:${min < 10 ? '0' + min:min}:${sec < 10 ? '0' + sec:sec}`
}
secondsToTimeSpan(0);       // => 00:00:00
secondsToTimeSpan(1);       // => 00:00:01
secondsToTimeSpan(1440);    // => 1.00:00:00
secondsToTimeSpan(-1440);   // => -1.00:00:00
secondsToTimeSpan(-1);      // => -00:00:01

Ich habe diesen Code bereits verwendet, um ein einfaches Zeitspannenobjekt zu erstellen:

function TimeSpan(time) {
this.hours = 0;
this.minutes = 0;
this.seconds = 0;

while(time >= 3600)
{
    this.hours++;
    time -= 3600;
}

while(time >= 60)
{
    this.minutes++;
    time -= 60;
}

this.seconds = time;
}

var timespan = new Timespan(3662);