如何HH-MM-SS使用 JavaScript 将秒数转换为字符串？
问问题
398198 次
32 回答
494
借助 JavaScript Date 方法，您可以在没有任何外部 JavaScript 库的情况下做到这一点，如下所示：
var date = new Date(null);
date.setSeconds(SECONDS); // specify value for SECONDS here
var result = date.toISOString().substr(11, 8);
或者，根据@Frank的评论；一个班轮：
new Date(SECONDS * 1000).toISOString().substr(11, 8);
于 2014-08-13T06:22:57.107 回答
318
更新（2020 年）：
请使用@Frank 的单行解决方案：
new Date(SECONDS * 1000).toISOString().substr(11, 8)
如果SECONDS<3600并且您只想显示MM:SS则使用以下代码：
new Date(SECONDS * 1000).toISOString().substr(14, 5)
这是迄今为止最好的解决方案。
老答案：
使用Moment.js图书馆。
于 2009-08-24T14:33:46.190 回答
190
我认为标准 Date 对象的任何内置功能都不会以比自己进行数学计算更方便的方式为您执行此操作。
hours = Math.floor(totalSeconds / 3600);
totalSeconds %= 3600;
minutes = Math.floor(totalSeconds / 60);
seconds = totalSeconds % 60;
例子：
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);于 2009-08-24T14:39:37.223 回答
102
我知道这有点老了，但是...
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(":")
}
它将输出：
toHHMMSS(129600) // 36:00:00
toHHMMSS(13545) // 03:45:45
toHHMMSS(180) // 03:00
toHHMMSS(18) // 00:18
于 2016-01-17T17:04:28.077 回答
44
正如克莱顿在他的回答中指出的那样，moment.js可以用于此：
moment().startOf('day')
.seconds(15457)
.format('H:mm:ss');
于 2013-10-18T19:30:50.317 回答
23
这是一个用于转换时间的简单函数，可能会有所帮助
function formatSeconds(seconds) {
var date = new Date(1970,0,1);
date.setSeconds(seconds);
return date.toTimeString().replace(/.*(\d{2}:\d{2}:\d{2}).*/, "$1");
}
于 2013-07-22T06:14:55.543 回答
19
这可以解决问题：
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;
}
（来自这里）
于 2009-08-24T14:42:17.843 回答
14
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"
我们可以让这个函数更短更清晰，但这会降低可读性，所以我们会尽可能简单和稳定地编写它。
或者你可以在这里检查这个工作：
于 2014-01-30T12:05:40.910 回答
11
试试这个：
function toTimeString(seconds) {
return (new Date(seconds * 1000)).toUTCString().match(/(\d\d:\d\d:\d\d)/)[0];
}
于 2015-04-14T03:29:32.893 回答
10
我认为最通用（和神秘）的解决方案可能是这个
function hms(seconds) {
return [3600, 60]
.reduceRight(
(pipeline, breakpoint) => remainder =>
[Math.floor(remainder / breakpoint)].concat(pipeline(remainder % breakpoint)),
r => [r]
)(seconds)
.map(amount => amount.toString().padStart(2, '0'))
.join('-');
}
或者复制和粘贴最短的版本
function hms(seconds) {
return [3600, 60]
.reduceRight(
(p, b) => r => [Math.floor(r / b)].concat(p(r % b)),
r => [r]
)(seconds)
.map(a => a.toString().padStart(2, '0'))
.join('-');
}
一些示例输出：
> hms(0)
< "00-00-00"
> hms(5)
< "00-00-05"
> hms(60)
< "00-01-00"
> hms(3785)
< "01-03-05"
> hms(37850)
< "10-30-50"
> hms(378500)
< "105-08-20"
这个怎么运作
算法
- 要获得小时数，您将总秒数除以 3600 并将其取底。
- 要获得分钟数，您将余数除以 60 并将其取底。
- 要获得秒数，您只需使用余数。
将单个金额保存在数组中以便于格式化也很好。
例如给定 3785s 的输入，输出应该[1, 3, 5]是 1 小时 3 分 5 秒。
创建管道
将 3600 和 60 常量命名为“断点”，您可以将此算法编写成这样的函数
function divideAndAppend(remainder, breakpoint, callback) {
return [Math.floor(remainder / breakpoint)].concat(callback(remainder % breakpoint));
}
它返回一个数组，其中第一项是给定断点的数量，数组的其余部分由回调给出。重用divideAndAppendin 回调函数将为您提供组合函数的管道。 divideAndAppend这些中的每一个都会计算每个给定断点的数量，并将其附加到数组中以产生所需的输出。
然后，您还需要结束此管道的“最终”回调。换句话说，您使用了所有断点，现在您只有剩余的断点。由于您已经在 3) 处得到了答案，因此在这种情况下，您应该使用某种身份函数remainder => [remainder]。
您现在可以像这样编写管道
let pipeline = r3 => divideAndAppend(
r3,
3600,
r2 => divideAndAppend(
r2,
60,
r1 => [r1]));
> pipeline(3785)
< [1, 3, 5]
酷吧？
使用 for 循环进行泛化
现在，您可以使用可变数量的断点进行概括，并创建一个 for 循环，将divideAndAppend各个函数组合到管道中。您从标识函数开始r1 => [r1]，然后使用60断点，最后使用3600断点。
let breakpoints = [60, 3600];
let pipeline = r => [r];
for (const b of breakpoints) {
const previousPipeline = pipeline;
pipeline = r => divideAndAppend(r, b, previousPipeline);
}
> pipeline(3785)
< [1, 3, 5]
使用Array.prototype.reduce()
现在，您可以将此 for 循环重写为 reducer，以获得更短且功能更强大的代码。换句话说，将函数组合重写到减速器中。
let pipeline = [60, 3600].reduce(
(ppln, b) => r => divideAndAppend(r, b, ppln),
r => [r]
);
> pipeline(3785)
< [1, 3, 5]
累加器ppln是管道，您正在使用它的先前版本来组合它。初始管道是r => [r].
您现在可以内联函数divideAndAppend并使用与使断点定义更自然Array.prototype.reduceRight的相同。[].reverse().reduce(...)
let pipeline = [3600, 60]
.reduceRight(
(ppln, b) => r => [Math.floor(r / b)].concat(ppln(r % b)),
r => [r]
);
这是最终的形式。然后，您只需将映射应用到左侧填充 0 的字符串，并使用:分隔符连接字符串；
更多概括
将减速器包装成函数
function decompose(total, breakpoints) {
return breakpoints.reduceRight(
(p, b) => r => [Math.floor(r / b)].concat(p(r % b)),
r => [r]
)(total);
}
> decompose(3785, [3600, 60])
< [1, 3, 5]
您现在有了可以使用的非常通用的算法。例如：
轻松转换（奇怪的）美国长度标准
鉴于标准
| 单元 | 部门 |
|---|---|
| 1 英尺 | 12英寸 |
| 1码 | 3 英尺 |
| 1 英里 | 1760码 |
> decompose(123_456, [1760 * 3 * 12, 3 * 12, 12])
< [1, 1669, 1, 0]
123456 英寸 = 1 英里、1669 码、1 英尺和 0 英寸
或者您可以在一定程度上转换为十进制或二进制表示
> decompose(123_456, [100_000, 10_000, 1000, 100, 10])
< [1, 2, 3, 4, 5, 6]
> decompose(127, [128, 64, 32, 16, 8, 4, 2])
< [0, 1, 1, 1, 1, 1, 1, 1]
也适用于浮点断点
由于 Javascript 支持mod带有浮点数的运算符，因此您也可以这样做
> decompose(26.5, [20, 2.5])
< [1, 2, 1.5]
没有断点的边缘情况也自然覆盖
> decompose(123, [])
< [123]
于 2021-03-06T11:00:16.617 回答
9
这是 Number 类的扩展。toHHMMSS() 将秒转换为 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>于 2015-06-29T09:51:50.093 回答
5
新手易于遵循的版本：
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);
于 2015-02-24T07:08:17.940 回答
5
这个功能应该这样做：
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 : ':' );
}
在不传递分隔符的情况下，它:用作（默认）分隔符：
time = convertTime(13551.9941351); // --> OUTPUT = 03:45:51
如果要-用作分隔符，只需将其作为第二个参数传递：
time = convertTime(1126.5135155, '-'); // --> OUTPUT = 00-18-46
另请参阅此 Fiddle。
于 2017-02-07T14:01:56.343 回答
5
加入这个旧线程 - OP 声明 HH:MM:SS，并且许多解决方案都有效，直到您意识到您需要列出超过 24 小时。也许您只需要一行代码。干得好：
d=(s)=>{f=Math.floor;g=(n)=>('00'+n).slice(-2);return f(s/3600)+':'+g(f(s/60)%60)+':'+g(s%60)}
它返回 H+:MM:SS。要使用它，只需使用：
d(91260); // returns "25:21:00"
d(960); // returns "0:16:00"
...我试图让它使用尽可能少的代码，这是一种很好的单行方法。
于 2017-06-30T01:58:23.653 回答
5
对于FFMPEG用于指定毫秒的HH:MM:SS.MS (eq: "00:04:33.637")的特殊情况。
[-][HH:]MM:SS[.m...]
HH 表示小时数，MM 表示分钟数，最多两位数，SS 表示秒数，最多两位数。末尾的 m 表示 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)
)示例用法，毫秒传输计时器：
/* 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>示例用法，绑定到媒体元素
/* 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>在问题之外，那些用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];
}
于 2019-08-20T10:32:09.443 回答
4
在查看了所有答案并且对其中的大多数都不满意之后，这就是我想出的。我知道我的谈话很晚了，但无论如何都是这样。
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;
}
我创建了一个新的 Date 对象，将时间更改为我的参数，将 Date 对象转换为时间字符串，并通过拆分字符串并仅返回需要的部分来删除其他内容。
我想我会分享这种方法，因为它不需要正则表达式、逻辑和数学杂技来获得“HH：mm：ss”格式的结果，而是依赖于内置方法。
您可能想在这里查看文档： https ://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date
于 2016-01-15T20:29:53.473 回答
4
以下是将秒转换为 hh-mm-ss 格式的给定代码：
var measuredTime = new Date(null);
measuredTime.setSeconds(4995); // specify value of SECONDS
var MHSTime = measuredTime.toISOString().substr(11, 8);
于 2017-07-18T21:10:41.480 回答
3
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.
}
}
于 2011-05-24T13:21:01.417 回答
3
我只是想对上面的好答案做一点解释：
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);
在第二行，由于 1 小时有 3600 秒，我们将总秒数除以 3600 得到总小时数。我们使用 parseInt 去除任何小数。如果 totalSec 为 12600（3 个半小时），则 parseInt(totalSec / 3600) 将返回 3，因为我们将有 3 个完整小时。为什么在这种情况下我们需要 % 24 ？如果我们超过 24 小时，假设我们有 25 小时（90000 秒），那么这里的模数将使我们再次回到 1，而不是返回 25。它将结果限制在 24 小时限制内，因为有 24 小时一天内。
当你看到这样的事情时：
25 % 24
可以这样想：
25 mod 24 or what is the remainder when we divide 25 by 24
于 2016-07-19T20:27:49.443 回答
2
您是否尝试过向 Date 对象添加秒数？
Date.prototype.addSeconds = function(seconds) {
this.setSeconds(this.getSeconds() + seconds);
};
var dt = new Date();
dt.addSeconds(1234);
示例： https ://jsfiddle.net/j5g2p0dc/5/
更新：示例链接丢失，所以我创建了一个新链接。
于 2014-03-31T14:02:22.223 回答
2
这是一个根据 powtac 的回答将秒转换为 hh-mm-ss 格式的函数
/**
* 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;
}
示例使用
var seconds = SecondsTohhmmss(70);
console.log(seconds);
// logs 00-01-10
于 2015-01-27T23:25:43.007 回答
2
有很多解决这个问题的选项，显然有很好的选项建议，但我想在这里添加一个更优化的代码
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(":");
}
如果你不想用少于 10 个数字格式化零，你可以使用
function formatSeconds(sec) {
return parseInt(sec / 3600) + ':' + parseInt((sec % 3600) / 60) + ':' + parseInt((sec % 3600) % 60);
}
于 2017-12-05T12:54:33.327 回答
2
在一行中，使用 TJ Crowder 的解决方案：
secToHHMMSS = seconds => `${Math.floor(seconds / 3600)}:${Math.floor((seconds % 3600) / 60)}:${Math.floor((seconds % 3600) % 60)}`
在一行中，另一种也计算天数的解决方案：
secToDHHMMSS = seconds => `${parseInt(seconds / 86400)}d ${new Date(seconds * 1000).toISOString().substr(11, 8)}`
来源：https ://gist.github.com/martinbean/2bf88c446be8048814cf02b2641ba276
于 2018-04-24T15:05:18.073 回答
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));
于 2018-08-10T16:52:05.733 回答
2
这里没有一个答案能满足我的要求，因为我希望能够处理
- 大量秒（天），以及
- 负数
尽管这些不是 OP 所要求的，但覆盖边缘情况是一种很好的做法，尤其是在不费吹灰之力的情况下。
很明显，当他说 seconds 时，OP 的意思是 NUMBER of seconds。为什么要将您的功能固定在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
于 2019-04-29T03:46:46.890 回答
2
将秒转换为 hh:mm:ss 格式的简单函数：
function getHHMMSSFromSeconds(totalSeconds) {
if (!totalSeconds) {
return '00:00:00';
}
const hours = Math.floor(totalSeconds / 3600);
const minutes = Math.floor(totalSeconds % 3600 / 60);
const seconds = totalSeconds % 60;
const hhmmss = padTo2(hours) + ':' + padTo2(minutes) + ':' + padTo2(seconds);
return hhmmss;
}
// function to convert single digit to double digit
function padTo2(value) {
if (!value) {
return '00';
}
return value < 10 ? String(value).padStart(2, '0') : value;
}
于 2021-06-03T20:14:51.717 回答
1
您还可以使用以下代码：
int ss = nDur%60;
nDur = nDur/60;
int mm = nDur%60;
int hh = nDur/60;
于 2012-11-13T15:11:31.257 回答
1
对于任何使用 AngularJS 的人来说，一个简单的解决方案是使用date API过滤值，它根据请求的格式将毫秒转换为字符串。例子：
<div>Offer ends in {{ timeRemaining | date: 'HH:mm:ss' }}</div>
请注意，这需要毫秒，因此如果您从秒转换（如原始问题所制定的那样），您可能需要将 timeRemaining 乘以 1000。
于 2014-12-15T10:28:00.213 回答
1
我遇到了一些人提到的秒数超过一天的情况。这是@Harish Anchu 的最高评价答案的改编版本，占更长的时间：
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(':');
}
例子：
secondsToTime(101596) // outputs '28:13:16' as opposed to '04:13:16'
于 2018-09-28T20:10:55.817 回答
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;
}
使用示例
alert("186".toHHMMSS());
于 2019-03-17T15:37:32.703 回答
-2
于 2012-04-12T08:00:13.230 回答
-4
我之前使用过这段代码来创建一个简单的时间跨度对象：
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);
于 2009-08-24T14:41:13.277 回答