Konwertuj sekundy na HH-MM-SS z JavaScript?

Jak przekonwertować sekundy na HH-MM-SSciąg za pomocą JavaScript?

Nie znasz danych ? to trzeba wiedzieć.

Używając datejs, po prostu napisz coś takiego:

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

--aktualizacja

Obecnie date.js jest przestarzały i nie jest obsługiwany, więc użyj „ Moment.js ”, co jest znacznie lepsze, jak wskazał TJ Crowder.

--aktualizacja 2

Skorzystaj z @ Frank's rozwiązania jedno liniowego:

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

To zdecydowanie najlepsze rozwiązanie.

Możesz to zrobić bez zewnętrznej biblioteki JavaScript za pomocą metody JavaScript Date, takiej jak:

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

Lub, zgodnie z komentarzem @Frank ; jedna wkładka:

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

Nie sądzę, aby jakakolwiek wbudowana funkcja standardowego obiektu Date mogła zrobić to dla ciebie w sposób wygodniejszy niż tylko matematyka.

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

Przykład:

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

Wiem, że to trochę stare, ale ...

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(":")
}

Wyprowadzi:

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

Jak zauważył Cleiton w swojej odpowiedzi , moment.js może być wykorzystany do tego:

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

To załatwia sprawę:

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

(Źródło stąd )

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"

możemy sprawić, by ta funkcja była o wiele krótsza i bardziej wyraźna, ale to zmniejsza czytelność, więc napiszemy ją tak prosto, jak to możliwe i tak stabilnie, jak to możliwe.

lub możesz to sprawdzić tutaj :

Spróbuj tego:

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

Oto rozszerzenie klasy Number. Funkcja toHHMMSS () konwertuje sekundy na ciąg hh: mm: ss.

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>

Łatwa do naśladowania wersja dla 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);

Ta funkcja powinna to zrobić:

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

Bez przekazywania separatora służy :jako (domyślny) separator:

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

Jeśli chcesz użyć -jako separatora, po prostu przekaż go jako drugi parametr:

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

Zobacz także to skrzypce .

poniżej podano kod, który przekonwertuje sekundy na format hh-mm-ss:

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

Uzyskaj alternatywną metodę z Konwertuj sekundy na format HH-MM-SS w JavaScript

Dla specjalnego przypadku GG: MM: SS.MS (eq: „00: 04: 33.637”) stosowanego przez FFMPEG do określenia milisekund .

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

HH wyraża liczbę godzin, MM liczbę minut dla maksymalnie 2 cyfr, a SS liczbę sekund dla maksymalnie 2 cyfr. M na końcu wyraża wartość dziesiętną dla SS.

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

Przykładowe użycie, licznik czasu transportu milisekund:

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

Przykładowe użycie powiązane z elementem medialnym

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

Poza pytaniem te funkcje napisane w php:

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

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

Chciałem tylko wyjaśnić miłą odpowiedź powyżej:

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

W drugim wierszu, ponieważ w ciągu 1 godziny jest 3600 sekund, dzielimy całkowitą liczbę sekund przez 3600, aby uzyskać całkowitą liczbę godzin. Używamy parseInt do usuwania dziesiętnych. Jeśli totalSec wynosiłby 12600 (3 i pół godziny), to parsowanie (totalSec / 3600) zwróciłoby 3, ponieważ będziemy mieli 3 pełne godziny. Dlaczego w tym przypadku potrzebujemy% 24? Jeśli przekroczymy 24 godziny, powiedzmy, że mamy 25 godzin (90000 sekund), wówczas moduł modulo ponownie zabierze nas z powrotem do 1, zamiast powrotu 25. Ogranicza wynik w ciągu 24 godzin, ponieważ są 24 godziny w jeden dzień.

Gdy zobaczysz coś takiego:

25 % 24

Pomyśl o tym w ten sposób:

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

Wtrącając się do tego starego wątku - OP stwierdził HH: MM: SS i wiele rozwiązań działa, dopóki nie uświadomisz sobie, że potrzebujesz więcej niż 24 godzin na liście. A może nie chcesz więcej niż jednego wiersza kodu. Proszę bardzo:

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

Zwraca H +: MM: SS. Aby go użyć, po prostu użyj:

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

... Próbowałem zmusić go do użycia najmniejszej możliwej ilości kodu, aby uzyskać ładne podejście z jedną linią.

Czy próbowałeś dodać sekundy do obiektu Date?

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

Przykład: https://jsfiddle.net/j5g2p0dc/5/

Zaktualizowano: brakowało przykładowego linku, więc utworzyłem nowy.

Oto funkcja konwersji sekund na format hh-mm-ss na podstawie odpowiedzi powtac tutaj

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

Przykładowe użycie

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

Po przeanalizowaniu wszystkich odpowiedzi i niezadowoleniu się z większości z nich wpadłem na to. Wiem, że spóźniłem się na rozmowę, ale i tak jest.

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

Tworzę nowy obiekt Date, zmieniam czas na moje parametry, przekształcam obiekt Date na ciąg czasu i usunąłem dodatkowe rzeczy, dzieląc ciąg i zwracając tylko potrzebną część.

Pomyślałem, że podzielę to podejście, ponieważ eliminuje ono potrzebę stosowania wyrażeń regularnych, logiki i matematyki w celu uzyskania wyników w formacie „HH: mm: ss”, a zamiast tego opiera się na wbudowanych metodach.

Możesz zajrzeć do dokumentacji tutaj: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date

Istnieje wiele opcji rozwiązania tego problemu i oczywiste jest, że sugeruje się dobrą opcję, ale chcę tutaj dodać jeszcze jeden zoptymalizowany kod

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

jeśli nie chcesz sformatowanego zera z liczbą mniejszą niż 10, możesz użyć

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

}

Przykładowy kod http://fiddly.org/1c476/1

W jednej linii, korzystając z rozwiązania TJ Crowder:

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

W jednej linii inne rozwiązanie, które również liczy dni:

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

Źródło: 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));

Możesz także użyć poniższego kodu:

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

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

wynik 15:08:03

Dla każdego, kto używa AngularJS, prostym rozwiązaniem jest odfiltrowanie wartości za pomocą interfejsu API daty , który konwertuje milisekundy na ciąg oparty na żądanym formacie. Przykład:

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

Zauważ, że oczekuje to milisekund, więc możesz chcieć pomnożyć timeRemaining przez 1000, jeśli konwertujesz z sekund (jak sformułowano oryginalne pytanie).

Natknąłem się na przypadek, w którym niektórzy wspominali, że liczba sekund jest większa niż jeden dzień. Oto dostosowana wersja najwyżej ocenianej odpowiedzi @Harish Anchu, która odpowiada na dłuższe okresy:

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

Przykład:

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

Przykład użycia

alert("186".toHHMMSS());

Żadna z odpowiedzi tutaj nie spełnia moich wymagań, ponieważ chcę sobie poradzić

1. Duża liczba sekund (dni) i
2. Liczby ujemne

Chociaż nie są one wymagane przez PO, dobrą praktyką jest objęcie przypadków skrajnych, szczególnie gdy wymaga to niewielkiego wysiłku.

To całkiem oczywiste, że OP oznacza LICZBĘ sekund, kiedy mówi sekundy . Dlaczego chcesz przypisać swoją funkcję 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

Użyłem tego kodu wcześniej, aby utworzyć prosty obiekt rozpiętości czasowej:

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