Sekunden in HH-MM-SS mit JavaScript konvertieren?
Wie kann ich mit JavaScript Sekunden in einen HH-MM-SS - String konvertieren?
Sie können dies mithilfe der JavaScript Date-Methode wie folgt ohne externe JavaScript-Bibliothek durchführen:
var date = new Date(null);
date.setSeconds(SECONDS); // specify value for SECONDS here
var result = date.toISOString().substr(11, 8);
Oder laut @ Frank 's Kommentar; Ein Einzeiler:
new Date(SECONDS * 1000).toISOString().substr(11, 8);
Ich glaube nicht, dass eine integrierte Funktion des Standard-Date-Objekts dies für Sie auf eine bequemere Weise erledigt, 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);Wie Cleiton in seine Antwort hervorhob, kann moment.js dazu verwendet werden:
moment().startOf('day')
.seconds(15457)
.format('H:mm:ss');
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
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;
}
(Quelle: hier )
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 knackiger 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 überprüfen hier :
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>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 : 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 this Fiddle .
Einfach zu verfolgende Version für Anfänger:
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);
der folgende Code konvertiert Sekunden in das Format hh-mm-ss:
var measuredTime = new Date(null);
measuredTime.setSeconds(4995); // specify value of SECONDS
var MHSTime = measuredTime.toISOString().substr(11, 8);
Alternative Methode abrufen von Sekunden in HH-MM-SS-Format in JavaScript konvertieren
Ich wollte nur eine kleine Erklärung zu der obigen Antwort von Nizza 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 Gesamtanzahl der Sekunden durch 3600, um die Gesamtanzahl der Stunden zu erhalten, da eine Stunde 3600 Sekunden enthält. Wir verwenden parseInt, um Dezimalstellen zu entfernen. Wenn totalSec 12600 (3 und halbe 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 es sich so vor:
25 mod 24 or what is the remainder when we divide 25 by 24
Diesem alten Thread auf den Grund zu gehen - im OP hieß es HH: MM: SS, 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 wird H +: MM: SS zurückgegeben. Um es zu benutzen, benutze einfach:
d(91260); // returns "25:21:00"
d(960); // returns "0:16:00"
... Ich habe versucht, den Code so gering wie möglich zu halten, um einen Nizza-Einzeiler-Ansatz zu erreichen.
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.
}
}
Haben Sie versucht, einem Date-Objekt Sekunden hinzuzufügen?
var dt = new Date();
dt.addSeconds(1234);
Ein Beispiel: https://jsfiddle.net/j5g2p0dc/5/
Aktualisiert: Beispiellink fehlte, daher habe ich einen neuen erstellt.
In einer Zeile unter Verwendung von T.J. Pulverlösung:
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
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 Date-Objekt, ändere die Zeit in meinen Parametern, konvertiere das Date-Objekt in eine Zeitzeichenfolge und entferne das zusätzliche Material, indem ich die Zeichenfolge aufspalte und nur den Teil zurückgebe, der benötigt wird.
Ich dachte, ich würde diesen Ansatz teilen, da Regex, Logik und mathematische Akrobatik entfallen, um die Ergebnisse im Format "HH: mm: ss" zu erhalten. Stattdessen werden integrierte Methoden verwendet.
Sie können sich die Dokumentation hier ansehen: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date
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));
Hier ist eine Funktion zum Konvertieren von Sekunden in das Format hh-mm-ss basierend auf der Antwort von powtac hier
/**
* 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;
}
Beispielgebrauch
var seconds = SecondsTohhmmss(70);
console.log(seconds);
// logs 00-01-10
Es gibt viele Möglichkeiten, um dieses Problem zu lösen, und natürlich gibt es gute Vorschläge, 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 Null mit weniger als 10 Zahlen formatieren möchten, können Sie verwenden
function formatSeconds(sec) {
return parseInt(sec / 3600) + ':' + parseInt((sec % 3600) / 60) + ':' + parseInt((sec % 3600) % 60);
}
Beispielcode http://fiddly.org/1c476/1
Sie können auch den folgenden Code verwenden:
int ss = nDur%60;
nDur = nDur/60;
int mm = nDur%60;
int hh = nDur/60;
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());
Für alle, die AngularJS verwenden, besteht eine einfache Lösung darin, den Wert mit der Datums-API zu filtern, die Millisekunden in eine Zeichenfolge konvertiert, die auf dem angeforderten Format basiert. Beispiel:
<div>Offer ends in {{ timeRemaining | date: 'HH:mm:ss' }}</div>
Beachten Sie, dass dies Millisekunden voraussetzt. Sie können also timeRemaining mit 1000 multiplizieren, wenn Sie von Sekunden konvertieren (wie die ursprüngliche Frage formuliert wurde).
Keine der hier aufgeführten Antworten entspricht meinen Anforderungen, da ich damit umgehen möchte
- Große Anzahl von Sekunden (Tagen) und
- Negative Zahlen
Obwohl dies vom OP nicht verlangt wird, ist es empfehlenswert, Edge-Fälle abzudecken, insbesondere wenn es nur wenig Aufwand erfordert.
Es ist ziemlich offensichtlich, dass der OP eine ANZAHL von Sekunden bedeutet, wenn er Sekunden sagt. Warum sollten Sie Ihre Funktion an String binden?
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 bin auf den Fall gestoßen, in dem einige erwähnt haben, dass die Anzahl der Sekunden mehr als ein 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'
new Date().toString().split(" ")[4];
ergebnis 15:08:03
Ich habe diesen Code zuvor 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);
Vielleicht so etwas:
var Convert = function (time) {
const HOUR = 60 * 60;
const MINUTE = 60;
var minutesInSeconds = time % HOUR;
var hours = Math.floor(time / HOUR);
var minutes = Math.floor(minutesInSeconds / MINUTE)
var seconds = minutesInSeconds % MINUTE;
return hours.padStart(2, 0) + ':' + minutes.padStart(2, 0) + ':' + seconds.padStart(2, 0);
}
Für den Spezialfall von HH: MM: SS.MS (Gl. "00: 04: 33.637"), wie von FFMPEG um Millisekunden anzugeben.
[-] [HH:] MM: SS [.m ...]
HH gibt die Anzahl der Stunden an, 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()).toString().split(" ")[4] + "." + p.getMilliseconds()
}
/* Example: 7hours, 4 minutes, 33 seconds and 637 milliseconds */
console.log(
timerToSec("07:04:33.637")
)
/* Test: 25473 seconds and 637 milliseconds */
console.log(
secToTimer(25473.637)
)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()).toString().split(" ")[4] + "." + p.getMilliseconds()
}
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>Beispielverwendung, an ein Medienelement gebunden
/* 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()).toString().split(" ")[4] + "." + p.getMilliseconds()
}
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>