Convertir des secondes en HH-MM-SS avec JavaScript?
comment convertir seconds en chaîne de caractères HH-MM-SS en utilisant JavaScript?
30 réponses
ne savez-vous pas datejs ? c'est un doit le savoir.
en utilisant datejs, il suffit d'écrire quelque chose comme:
(new Date).clearTime()
.addSeconds(15457)
.toString('H:mm:ss');
--mise à jour
de nos jours date.js est périmé et non maintenu, donc utiliser " Moment.js ", ce qui est beaucoup mieux comme l'a souligné T. J. Crowder.
vous pouvez y arriver sans bibliothèque JavaScript externe à l'aide de la méthode date JavaScript comme suit:
var date = new Date(null);
date.setSeconds(SECONDS); // specify value for SECONDS here
var result = date.toISOString().substr(11, 8);
Je ne pense pas qu'une fonctionnalité intégrée de L'objet Date standard le fera pour vous d'une manière plus commode que de simplement faire le calcul vous-même.
hours = Math.floor(totalSeconds / 3600);
totalSeconds %= 3600;
minutes = Math.floor(totalSeconds / 60);
seconds = totalSeconds % 60;
exemple:
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);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');
function formatSeconds(seconds)
{
var date = new Date(1970,0,1);
date.setSeconds(seconds);
return date.toTimeString().replace(/.*(\d{2}:\d{2}:\d{2}).*/, "");
}
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) % 24
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 sortira:
toHHMMSS(13545) // 03:45:45
toHHMMSS(180) // 03:00
toHHMMSS(18) // 00:18
essayez ceci:
function toTimeString(seconds) {
return (new Date(seconds * 1000)).toUTCString().match(/(\d\d:\d\d:\d\d)/)[0];
}
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);
var 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é, donc nous allons l'écrire aussi simple que possible et aussi stable que possible.
ou vous pouvez vérifier ce qui fonctionne ici :
voici une extension à la classe de nombre. 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>Version facile à suivre pour 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);
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 un séparateur, il utilise : comme séparateur (par défaut):
time = convertTime(13551.9941351); // --> OUTPUT = 03:45:51
si vous voulez utiliser - comme séparateur, passez-le simplement comme second paramètre:
time = convertTime(1126.5135155, '-'); // --> OUTPUT = 00-18-46
Voir aussi ce violon .
ci-dessous est le code donné qui convertira des secondes en format hh-mm-ss:
var measuredTime = new Date(null);
measuredTime.setSeconds(4995); // specify value of SECONDS
var MHSTime = measuredTime.toISOString().substr(11, 8);
Obtenir de la méthode alternative de Convertir secondes à HH-MM-SS en 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.
}
}
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, car il y a 3600 secondes dans 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) retournerait 3, puisque 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), puis le modulo ici nous ramènera à 1 de nouveau, plutôt que de retourner 25. Le résultat est confiné dans une limite de 24 heures, puisqu'il y a 24 heures dans une journée.
quand vous voyez quelque chose comme ceci:
25 % 24
pensez-y comme ceci:
25 mod 24 or what is the remainder when we divide 25 by 24
sonnant sur ce vieux fil -- L'OP a déclaré HH:MM:SS, et beaucoup de solutions fonctionnent, jusqu'à ce que vous réalisez que vous avez besoin de plus de 24 heures énumérées. Et peut-être que vous ne voulez pas plus d'une ligne de code. Et voilà:
d=(s)=>{f=Math.floor;g=(n)=>('00'+n).slice(-2);return f(s/3600)+':'+g(f(s/60)%60)+':'+g(s%60)}
Il retourne H+:MM:SS. Pour l'utiliser, il suffit d'utiliser:
d(91260); // returns "25:21:00"
d(960); // returns "0:16:00"
...J'ai essayé de lui faire utiliser le moins de code possible, pour une bonne approche monobloc.
avez-vous essayé d'ajouter des secondes à un objet Date?
var dt = new Date();
dt.addSeconds(1234);
un échantillon: https://jsfiddle.net/j5g2p0dc/5 /
mis à jour: Le lien d'échantillon manquait donc j'en ai créé un nouveau.
Voici une fonction pour convertir secondes au format HH-mm-ss basé sur la réponse de powtac ici
/**
* 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
après avoir regardé toutes les réponses et ne pas être heureux avec la plupart d'entre eux, c'est ce que j'ai inventé. 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 de mes paramètres, convertit l'objet Date en une chaîne de temps, et supprime les éléments supplémentaires en séparant la chaîne et en ne retournant que la partie qui en a besoin.
j'ai pensé que je partagerais cette approche, puisqu'il élimine le besoin de regex, logique et acrobaties mathématiques pour obtenir les résultats dans le format "HH:mm:ss", et à la place il s'appuie sur des méthodes intégrées.
vous pouvez jeter un oeil à la documentation ici: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date
il y a beaucoup d'options pour résoudre ce problème, et évidemment il y a une bonne option suggérée à propos, 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 formaté zéro avec moins de 10 Nombre, Vous pouvez utiliser
function formatSeconds(sec) {
return parseInt(sec / 3600) + ':' + parseInt((sec % 3600) / 60) + ':' + parseInt((sec % 3600) % 60);
}
code échantillon http://fiddly.org/1c476/1
en une ligne, en utilisant la solution de T. J. Crowder:
secToHHMMSS = seconds => `${Math.floor(seconds / 3600)}:${Math.floor((seconds % 3600) / 60)}:${Math.floor((seconds % 3600) % 60)}`
dans une ligne, une autre solution qui compte aussi les jours:
secToDHHMMSS = seconds => `${parseInt(seconds / 86400)}d ${new Date(seconds * 1000).toISOString().substr(11, 8)}`
Source: https://gist.github.com/martinbean/2bf88c446be8048814cf02b2641ba276
vous pouvez également utiliser le code ci-dessous:
int ss = nDur%60;
nDur = nDur/60;
int mm = nDur%60;
int hh = nDur/60;
pour toute personne utilisant AngularJS, une solution simple est de filtrer la valeur avec date API , qui convertit des 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 s'attend à des millisecondes, donc vous pouvez vouloir multiplier la mémorisation de temps par 1000 si vous convertissez à partir de secondes (comme la question originale a été formulée).
j'ai déjà utilisé ce code pour créer un objet timespan simple:
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);
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));
j'ai couru dans le cas certains ont mentionné où le nombre de secondes est plus d'un jour. Voici une version adaptée de la réponse la mieux cotée de @Harish Anchu qui rend compte de plus longues périodes de temps:
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'
vous pouvez également utiliser sucre .
Date.create().reset().set({seconds: 180}).format('{mm}:{ss}');
cet exemple retourne '03:00'.
"
var number = 10000(milliseconds);
var momentObject = moment.duration(number);
var output = momentObject.hours()+"HH"+momentObject.minutes()+"MM"+minuteObject.seconds()+"S"