Convertir des secondes en HH-MM-SS avec JavaScript?


Réponses:


110

Vous ne connaissez pas datejs ? c'est un must.

En utilisant datejs, écrivez simplement quelque chose comme:

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

--mettre à jour

De nos jours, date.js est obsolète et n'est pas maintenu, alors utilisez " Moment.js ", ce qui est beaucoup mieux comme l'a souligné TJ Crowder.

--mise à jour 2

Veuillez utiliser @ Frank's une solution à une ligne:

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

C'est de loin la meilleure solution.


11
@Yassir et Cleiton: FWIW, DateJS n'a pas été maintenu depuis des années et a quelques bugs en suspens (bien qu'à ma connaissance, ils concernent principalement l'analyse et minuit). momentjs semble assez bon et est actuellement maintenu.
TJ Crowder

1
@Cleiton, votre réponse mise à jour n'est pas complète. Je l' ai essayé et est comme suis: TypeError: Object [object Date] has no method 'clearTime'.
Hamish Grubijan

19
Accordé Moment.js n'est pas si grand que ça, mais si tout ce que vous faites avec lui est de convertir les secondes en hh: mm: ss, cela semble un peu exagéré. Utilisez plutôt l'une des fonctions suggérées dans ces réponses ou dans d'autres.
Ola Karlsson, le

5
Je pense que l'autre solution est meilleure que de lancer une autre bibliothèque js dans le mix.
Donato

4
Ajout d'une bibliothèque pour une action simple, je pense que la réponse ne devrait pas être acceptée. Oui, cela fonctionne, mais il existe de meilleures solutions !!!
Andris

405

Vous pouvez réussir à le faire sans aucune bibliothèque JavaScript externe à l'aide de la méthode JavaScript Date, comme suit:

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

Ou, selon le commentaire de @Frank ; une doublure:

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

39
Je ne sais pas pourquoi tout le monde ajoute des bibliothèques supplémentaires ou fait les calculs manuellement alors que cela fonctionne parfaitement. Merci!
jminardi

98
Cela peut même être raccourci en une seule ligne: new Date(SECONDS * 1000).toISOString().substr(11, 8);
Frank

4
Brillant. Sans aucune bibliothèque tierce. C'est mieux
Riz

41
Le problème avec cette approche est qu'elle débordera après 24 heures, vous empêchant d'afficher plus que cette durée. Solution parfaite si vous avez moins de 24 heures en quelques secondes.
Renato Gama

1
Cela ne fonctionne pas pour moi dans IE11, je reçoisObject doesn't support property or method 'toISOString'
NibblyPig

153

Je ne pense pas qu'une fonctionnalité intégrée de l'objet Date standard le fasse pour vous d'une manière plus pratique que de faire les calculs vous-même.

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

Exemple:


Il y a des problèmes avec ça je pense? Quand je l'ai essayé, je récupérais des décimales, donc 180 secondes reviendraient 0.05dans la hoursvariable. Je l'ai mis à l'intérieur d'un parseIntqui l'a fixé pour mon cas, mais je ne pense pas que ce serait exact pour tout. Pourtant, cela m'a aidé, alors merci!
BT643

@ BT643: Bizarre que je n'ai pas géré ça. Je l'ai fait maintenant, vous ne voulez pas l'utiliser parseInt, c'est pour analyser des chaînes , pas pour manipuler des nombres. Math.floorserait l'opération pertinente ici.
TJ Crowder

1
Ah ok! J'ai changé mon code. Bien que vous ne voulez probablement sur les secondes ainsi: seconds = Math.floor(totalSeconds % 60);. J'ai aussi obtenu un résultat décimal.
BT643

@ BT643: totalSeconds % 60ne peut avoir qu'une partie fractionnaire s'il totalSecondsa une partie fractionnaire. Que vous souhaitiez le plancher, cela dépendra de la perte ou de la conservation de ces informations. (Les autres opérations d'étage que nous effectuons ne perdent aucune information, car elles effacent simplement les données qui se retrouveront dans minuteset seconds.)
TJ Crowder

8
@HannounYassirconsole.log( hours +':'+ ('0'+minutes).slice(-2) +':'+ ('0'+seconds).slice(-2) );
Xavi Esteve

60

Je sais que c'est un peu vieux, mais ...

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

Il produira:

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

2
Qu'en est-il des fractions de seconde? 03: 45: 45.xxx?
Mike Stoddart

1
@ SantiagoHernández Super! Cela fonctionne maintenant parfaitement pendant plus de 24 heures.
Stefnotch

2
+1. Ceci ou le TJ devrait être la réponse acceptée, car ce sont les seuls qui fonctionnent pour les situations où la durée dépasse 24 heures (et la question ne limite pas la durée).
George Y.

38

Comme Cleiton l'a souligné dans sa réponse , moment.js peut être utilisé pour cela:

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

5
Que se passe-t-il si le nombre de secondes dépasse un jour?
Gilad Peleg

3
@GiladPeleg si le nombre de secondes dépasse un jour, le nombre de jours est calculé en interne et il ne renverra que les heures, minutes et secondes restantes. Si vous souhaitez également compter le nombre de jours, vous pouvez essayer moment().startOf('year').seconds(30000000).format('DDD HH:mm:ss').
elquimista

9
Que se passe-t-il si le nombre de secondes dépasse un an?
OrangePot

3
@OrangePot si le nombre de secondes dépasse un an, le nombre d'années est calculé en interne et il ne renverra que les jours, heures, minutes et secondes restants. Si vous voulez également compter le nombre d'années, vous pouvez essayer.format('YYYY DDD HH:mm:ss')
David Callanan

1
Mais cela ne peut pas être rendu facultatif. Cela pourrait sembler laid.
shaedrich

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

2
formatSeconds (3919); // Retourne 01:05:19 Excellente fonction .. J'aime ça
Samrat Saha

17

Cela fait l'affaire:

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

(Provenant d' ici )


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

nous pouvons rendre cette fonction beaucoup plus courte et nette mais cela diminue la lisibilité, nous l'écrirons donc aussi simple que possible et aussi stable que possible.

ou vous pouvez vérifier que cela fonctionne ici :


de plus ... si vous voulez faire toute la date et l'heure facilement ... utilisez momentJS
Sheelpriy

Merci! pas besoin d'inclure une bibliothèque dans une extension de navigateur. Simple et fonctionne!
Arlo

9

Essaye ça:

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

7

Voici une extension de la classe Number. toHHMMSS () convertit les secondes en une chaîne 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>


5

Version facile à suivre pour les 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);

5

Cette fonction devrait le faire:

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

Sans passer de séparateur, il utilise :comme séparateur (par défaut):

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

Si vous souhaitez utiliser -comme séparateur, passez-le simplement comme deuxième paramètre:

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

Voir aussi ce violon .


Pourrait utiliser des paramètres par défaut comme (entrée, séparateur = ":"). De plus, il n'a rien retourné jusqu'à ce que je le modifie un peu coller.ee/p/FDNag
madprops

@madprops: En fait, la version de ma réponse est déjà définie :par défaut pour le separatorparamètre, comme je l'ai déjà expliqué. Cela se fait par la déclaration typeof separator !== 'undefined' ? separator : ':'. De plus, votre fonction est à peu près identique à la mienne sauf quelques modifications cosmétiques et elles devraient toutes deux produire la même sortie ... sauf que ma version a un bien meilleur support du navigateur. Le vôtre ne fonctionnera dans AUCUNE version d'Internet Explorer ou de MS Edge <14.
John Slegers


5

Pour le cas particulier de HH: MM: SS.MS (eq: "00: 04: 33.637") tel qu'utilisé par FFMPEG pour spécifier les millisecondes .

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

HH exprime le nombre d'heures, MM le nombre de minutes pour un maximum de 2 chiffres et SS le nombre de secondes pour un maximum de 2 chiffres. Le m à la fin exprime la valeur décimale pour 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)
)

Exemple d'utilisation, une minuterie de transport en millisecondes:

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

Exemple d'utilisation, lié à un élément multimédia

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


En dehors de la question, ces fonctions écrites en 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];  
}

1
Vous pouvez omettre + "." + p.getMilliseconds()en utilisant simplement new Date(p.getTime()-o.getTime()).toISOString().split("T")[1].split("Z")[0]
JayJay

1
Ça va bien, oui votre version est plus rapide: Voir le benchmark jsben.ch/4sQY1 Modification acceptée! Je vous remercie.
NVRM

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

4

Je voulais juste donner une petite explication à la belle réponse ci-dessus:

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

Sur la deuxième ligne, comme il y a 3600 secondes en 1 heure, nous divisons le nombre total de secondes par 3600 pour obtenir le nombre total d'heures. Nous utilisons parseInt pour supprimer toute décimale. Si totalSec était de 12600 (3 heures et demie), alors parseInt (totalSec / 3600) renverrait 3, car nous aurons 3 heures complètes. Pourquoi avons-nous besoin du% 24 dans ce cas? Si nous dépassons 24 heures, disons que nous avons 25 heures (90000 secondes), alors le modulo ici nous ramènera à 1, plutôt que de revenir à 25. Il limite le résultat dans une limite de 24 heures, car il y a 24 heures en un jour.

Lorsque vous voyez quelque chose comme ça:

25 % 24

Pensez-y comme ceci:

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

4

Sonner sur ce vieux fil - l'OP a déclaré HH: MM: SS, et de nombreuses solutions fonctionnent, jusqu'à ce que vous réalisiez que vous avez besoin de plus de 24 heures répertoriées. Et peut-être que vous ne voulez pas plus d'une seule ligne de code. Voici:

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

Il renvoie H +: MM: SS. Pour l'utiliser, utilisez simplement:

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

... J'ai essayé de le faire utiliser le moins de code possible, pour une belle approche à une ligne.


1
Pouvez-vous également fournir une version étendue / en lecture de votre code afin que nous puissions plus facilement voir ce qui se passe? Merci.
Kimball

3

Avez-vous essayé d'ajouter des secondes à un objet Date?

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

Un exemple: https://jsfiddle.net/j5g2p0dc/5/

Mise à jour: un exemple de lien manquait, j'en ai créé un nouveau.


Uncaught TypeError: dt.addSeconds n'est pas une fonction
Ikrom

@Ikrom vérifier l'échantillon, j'en ai créé un nouveau dans jsfiddle depuis que l'ancien a renvoyé une erreur 404
kpull1

On dirait que je n'ai pas publié que vous utilisiez une méthode personnalisée addSecondssur un objet Date comme Date.prototype.addSeconds = function(seconds){...}. Oui, cela fonctionne, merci pour la mise à jour.
Ikrom

2

Voici une fonction pour convertir les secondes au format hh-mm-ss basé sur la réponse de powtac ici

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

Exemple d'utilisation

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

2

Après avoir regardé toutes les réponses et ne pas être satisfait de la plupart d'entre elles, voici ce que j'ai trouvé. Je sais que je suis très en retard pour la conversation, mais la voici quand même.

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

Je crée un nouvel objet Date, modifie l'heure à mes paramètres, convertis l'objet Date en une chaîne d'heure et supprime les éléments supplémentaires en divisant la chaîne et en ne renvoyant que la partie qui en a besoin.

J'ai pensé partager cette approche, car elle supprime le besoin d'acrobaties d'expression rationnelle, de logique et de mathématiques pour obtenir les résultats au format "HH: mm: ss", et à la place, elle s'appuie sur des méthodes intégrées.

Vous pouvez consulter la documentation ici: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date


2

Il existe de nombreuses options pour résoudre ce problème, et il est évident qu'il existe une bonne option suggérée, mais je veux ajouter un code optimisé de plus ici

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

si vous ne voulez pas mettre en forme zéro avec moins de 10 nombres, vous pouvez utiliser

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

}

Exemple de code http://fiddly.org/1c476/1


2

En une seule ligne, en utilisant la solution de TJ Crowder:

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

En une ligne, une autre solution qui compte également des jours:

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

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


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

1

Vous pouvez également utiliser le code ci-dessous:

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


1

Pour toute personne utilisant AngularJS, une solution simple consiste à filtrer la valeur avec l' API date , qui convertit les millisecondes en une chaîne basée sur le format demandé. Exemple:

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

Notez que cela attend des millisecondes, vous pouvez donc vouloir multiplier timeRemaining par 1000 si vous effectuez une conversion à partir de secondes (comme la question d'origine a été formulée).


1

Je suis tombé sur le cas que certains ont mentionné où le nombre de secondes est supérieur à un jour. Voici une version adaptée de la réponse la mieux notée de @Harish Anchu qui tient compte de périodes plus longues:

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

Exemple:

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

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

Exemple d'utilisation

alert("186".toHHMMSS());

1

Aucune des réponses ici ne répond à mes exigences car je veux pouvoir gérer

  1. Grand nombre de secondes (jours), et
  2. Nombres négatifs

Bien que ceux-ci ne soient pas requis par l'OP, il est recommandé de couvrir les cas de bord, surtout quand cela prend peu d'effort.

Il est assez évident que l'OP signifie un NOMBRE de secondes quand il dit secondes . Pourquoi ancreriez-vous votre fonction 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

1
secondsToTimeSpan(8991)renvoie 6.00:05:51alors que je pense qu'il devrait revenir00:02:29:51
user1063287

0

J'ai déjà utilisé ce code pour créer un simple objet de durée:

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

1
les résultats de bouclage sont une très mauvaise technique de codage et ne devraient jamais être utilisés, ils accapareront votre puissance de traitement et vous donneront un site en retard
yan bellavance
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.