用JavaScript将秒转换为HH-MM-SS ?

如何使用JavaScript将秒转换为HH-MM-SS字符串?

442116 次浏览
小开
最佳答案

更新(2020):

请使用@Frank的一句话解决方案:

new Date(SECONDS * 1000).toISOString().substring(11, 16)

如果SECONDS< 3600和如果你只想显示MM:党卫军，那么使用下面的代码:

new Date(SECONDS * 1000).toISOString().substring(14, 19)

这是目前为止最好的解决办法。

旧的回答:

使用Moment.js库。

小开

我认为标准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);

小开

我之前用这段代码创建了一个简单的时间跨度对象:

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

这招很管用:

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

(来源自在这里)

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

你也可以使用糖。

Date.create().reset().set({seconds: 180}).format('{mm}:{ss}');

这个例子返回'03:00'。

小开

你也可以使用下面的代码:

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

这里有一个转换时间的简单函数，可能会有帮助

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

正如Cleiton在他的回答中指出的，moment.js可用于此:

moment().startOf('day')
.seconds(15457)
.format('H:mm:ss');
小开 
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"

我们可以把这个函数写得更短更清晰，但这会降低可读性，所以我们要把它写得尽可能简单，尽可能稳定。

或者你可以检查这个工作在这里:

小开

您尝试过向Date对象添加秒数吗?

Date.prototype.addSeconds = function(seconds) {
this.setSeconds(this.getSeconds() + seconds);
};
var dt = new Date();
dt.addSeconds(1234);
< p >一个示例: https://jsfiddle.net/j5g2p0dc/5/ < / p > < p >更新: 样本链接丢失了，所以我创建了一个新的
小开

在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);
小开

对于任何使用AngularJS的人来说，一个简单的解决方案是使用日期的API来过滤值，它会根据请求的格式将毫秒转换为字符串。例子:

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

请注意，这需要毫秒，所以如果从秒转换(就像最初的问题一样)，可能需要将timerremain乘以1000。

小开

下面是一个函数，根据powtac的答案在这里将秒转换为hh-mm-ss格式

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

示例使用

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

易于遵循的版本为菜鸟:

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

试试这个:

function toTimeString(seconds) {
return (new Date(seconds * 1000)).toUTCString().match(/(\d\d:\d\d:\d\d)/)[0];
}
小开
这是数字类的扩展。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>

小开

看了所有的答案，大部分都不满意，下面是我想到的。我知道我说得有点晚了，但我还是要说了。

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

我创建了一个新的日期对象，将时间更改为参数，将日期对象转换为时间字符串，并通过分割字符串并只返回需要的部分来删除额外的内容。

我认为我应该分享这种方法，因为它不需要正则表达式、逻辑和数学技巧来获得“HH:mm:ss”格式的结果，而是依赖于内置的方法。

你可能想看一下这里的文档:https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date

小开

我知道这有点老了，但是…

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
小开

我只是想对上面这个不错的答案做一点解释:

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
小开

这个函数应该这样做:

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

另见< >强这个小提琴< / >强。

小开

再来看看这个老话题——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"

.．.我试图让它使用尽可能少的代码，这是一种很好的一行程序方法。

小开

下面是将秒转换为hh-mm-ss格式的代码:

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

从在JavaScript中转换秒为HH-MM-SS格式获取替代方法

小开

有很多解决这个问题的选项，显然有很好的选项建议，但我想在这里添加一个更优化的代码

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

如果你不想格式化0和小于10的数字，你可以使用

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

｝

示例代码http://fiddly.org/1c476/1

小开

在一行中，使用T.J.克劳德的解决方案:

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

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

我遇到了一些人提到的情况，其中秒的数量超过了一天。以下是@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'
小开 
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());
小开

这里没有一个答案满足我的要求，因为我想能够处理

  1. 大量的秒(天)，以及
  2. 负数

尽管OP不要求这些，但是覆盖边缘情况是一个很好的实践，特别是当它不需要花费太多精力时。

很明显，当他说秒时，OP意味着一个秒数。为什么要把你的函数挂在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
小开

对于HH: MM: SS。女士 (eq: " 00:04:33.637")的特殊情况，由FFMPEG用于指定毫秒。

[-] [HH: MM: SS(打烊……)

HH表示小时数，MM表示分钟数 最大值为2位，SS为最大值为2的秒数 位数。最后的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];
}
小开

我认为最普遍(也是最神秘)的解决方案可能是这样的

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"

它是如何工作的

算法

  1. 要得到小时数，你需要用总秒数除以3600，然后取底。
  2. 要得到分钟，你将剩余部分除以60并将其取底。
  3. 要得到秒数，你只需用余数。

将单个金额保存在一个数组中也很好，以便于格式化。

例如，给定输入3785s，输出应该是[1, 3, 5]，即1小时3分5秒。

创建管道

将3600和60常量命名为“断点”;你可以把这个算法写成这样的函数

function divideAndAppend(remainder, breakpoint, callback) {
return [Math.floor(remainder / breakpoint)].concat(callback(remainder % breakpoint));
}

它返回一个数组，其中第一项是给定断点的数量，数组的其余部分由回调函数给出。 在回调函数中重用divideAndAppend将给你一个管道组成 divideAndAppend函数。每一个 计算每个给定断点的数量，并将其添加到生成所需输出的数组中

那么你还需要&;final&;结束此管道的回调。换句话说，您使用了所有的断点，现在只剩下其余的。 既然你已经在3)处得到了答案，你应该使用某种恒等函数，在本例中是remainder => [remainder].

现在可以像这样编写管道

let pipeline = r3 => divideAndAppend(
r3,
3600,
r2 => divideAndAppend(
r2,
60,
r1 => [r1]));


> pipeline(3785)
< [1, 3, 5]

酷吧?

使用for-loop泛化

现在你可以泛化可变数量的断点，并创建一个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，并使用与[].reverse().reduce(...)相同的Array.prototype.reduceRight来设置断点 

let pipeline = [3600, 60]
.reduceRight(
(ppln, b) => r => [Math.floor(r / b)].concat(ppln(r % b)),
r => [r]
);

这是最终形式。然后你只需要appy映射到左边带填充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]
小开

简单的函数转换秒为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;
}
小开

当我想象一个时钟或计时器时，我会这样做:

const secondsTo_HHMMSS = (seconds) => {
//format to a readable friendly timer
let hour = Math.floor(seconds / 3600);
let minute = Math.floor((seconds % 3600) / 60);
let second = seconds % 60;


if(hour.toString().length === 1) {
hour = `0${hour}`;
}
if(minute.toString().length === 1) {
minute = `0${minute}`;
}
if(second.toString().length === 1) {
second = `0${second}`;
};


let timer = `${hour}-${minute}-${second}`;


return timer;
}
小开

已经有很多答案了，但我的要求是:

  • 转换为持续时间(即，应适用于大于24小时的值)
  • 关心的小数秒到给定的十进制精度
  • 如果为零，则截断前面的小时和分钟。

const seconds2duration = ( seconds, decimals=0 ) => {
let fraction = ( seconds - Math.floor( seconds ) ).toFixed( decimals );
fraction = decimals === 0 ? '' : fraction.slice( 1 );
const [ hours, mins, secs ] = [ seconds / 3600, seconds % 3600 / 60, seconds % 3600 % 60 ].map( ( x ) => String( Math.floor( x ) ).padStart( 2, '0' ) );
if ( hours === '00' && mins === '00' ) {
return secs + fraction;
} else if ( hours === '00' ) {
return [ mins, secs + fraction ].join( ':' );
} else {
return [ hours, mins, secs + fraction ].join( ':' );
}
};


console.log(seconds2duration(25*3600 + 0*60 + 41 + 0.333, 0)); // 25:00:41
console.log(seconds2duration(0*3600 + 5*60 + 41 + 0.333, 0)); // 05:41
console.log(seconds2duration(0*3600 + 5*60 + 41 + 0.333, 1)); // 05:41.3
console.log(seconds2duration(0*3600 + 0*60 + 41 + 0.333, 2)); // 41.33

小开

一个好的选择是使用Intl.DateTimeFormat。例子:

const timeFormat = new Intl.DateTimeFormat('es-US', {
hour: 'numeric',
minute: 'numeric',
second: 'numeric',
hour12: false,
timeZone: 'UTC'
});


const endTimeFormatted = timeFormat.format(new Date(SECS * 1000); //hour in secs
小开

你可以使用ES6 发电机来创建高度可定制的时间字符串。

下面是将数字从给定比例转换为数组的通用函数:

function toScaledArray(n,scales){
function* g(x, n=0){
if(x>0) {
yield x%(scales[n]||Infinity);
yield* g(Math.floor(x/scales[n]),n+1)
}
}
return [...g(n)]
}


console.log(toScaledArray(6,[10,10]))
console.log(toScaledArray(2000,[30,12]))
console.log(toScaledArray(45000,[24,30,12]))

因此，我们可以使用它来创建时间字符串，如下所示:

> toScaledArray(45000,[60,60]).reverse().join(":")
< '12:30:0'
> toScaledArray(1234,[60,60]).reverse().join(":")
< '20:34'

函数也可以写成一行:

[...(function* g(x,n=0,scales=[60,60]){if(x>0) {yield x%(scales[n]||Infinity); yield* g(Math.floor(x/scales[n]),n+1,scales)}})(45000)].reverse().join("-")

上面的函数将省略前导零，如果你想将字符串精确地转换为'HH-MM-SS'，你可以使用

[...(function* g(x,n=0,scales=[60,60]){if(x>0||n<3) {yield x%(scales[n]||Infinity); yield* g(Math.floor(x/scales[n]),n+1,scales)}})(45000)].reverse().map(x=>String(x).padStart(2, '0')).join("-")

此外，如果你需要的是'[H:]MM:SS'，这里我们有:

Number.prototype.toTimeString = function(){
return [...(function* g(x,n=0,scales=[60,60]){if(x>0||n<2) {yield x%(scales[n]||Infinity); yield* g(Math.floor(x/scales[n]),n+1,scales)}})(this)].map((x,n)=>n<2?String(x).padStart(2,'0'):x).reverse().join(":")
}


console.log(12,(12).toTimeString())
console.log(345,(345).toTimeString())
console.log(6789,(6789).toTimeString())

你也可以有D(ay)，甚至M(onth)和Y(ear)(虽然不准确)，如下所示:

> toScaledArray(123456789,[60,60,24,30,12]).map((x,n)=>n<2?String(x).padStart(2,'0'):x).reverse().join(":")
< '3:11:18:21:33:09'

这里输出的意思是“3年11个月18天21小时33分9秒”。

总之，这是一种高度可定制的将数字转换为可缩放数组的方法，可用于时间字符串转换、人类可读的字节转换甚至纸币的更改。

小开

这是一个非常简单的任务，但你们中的一些人直接推荐了Moment.js，或者创建了一些最丑陋的函数来解析一些秒…

transform(time: number): string {
if (time != null) {
const hours: number = Math.floor(time / 3600);
const minutes: number = Math.floor((time - (hours * 3600)) / 60);
const seconds: number = time - (hours * 3600) - (minutes * 60);
return [hours, (minutes < 10) ? '0' + minutes : minutes, (seconds < 10) ? '0' + seconds : seconds].join(':');
} else {
return '00:00:00';
}
}

这在任何情况下都适用……

小开 
export const secondsToHHMMSS = (seconds) => {
const HH = `${Math.floor(seconds / 3600)}`.padStart(2, '0');
const MM = `${Math.floor(seconds / 60) % 60}`.padStart(2, '0');
const SS = `${Math.floor(seconds % 60)}`.padStart(2, '0');
return [HH, MM, SS].join(':');
};

提交答案