जावास्क्रिप्ट के साथ HH-MM-SS में सेकंड परिवर्तित करें?

Question

मैं HH-MM-SSजावास्क्रिप्ट का उपयोग करके सेकंड को स्ट्रिंग में कैसे बदल सकता हूं ?

Comments

मेरा जवाब देखें stackoverflow.com/a/6313008/22470

— powtac

Answer 1

क्या आप खजूर नहीं जानते हैं ? यह पता होना चाहिए।

डेटज का उपयोग करते हुए, जैसे कुछ लिखें:

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

--अपडेट करें

आजकल date.js पुराना है और इसका रखरखाव नहीं किया जाता है, इसलिए " Moment.js " का उपयोग करें , जो कि TJ Crowder द्वारा बताया गया है।

- अद्यतन २

कृपया @ फ्रैंक का एक लाइन समाधान का उपयोग करें:

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

यह अब तक का सबसे अच्छा समाधान है।

Comments

@ वायसिर और क्लीटन: एफडब्ल्यूआईडब्ल्यू, डेटजेएस को वर्षों में बनाए नहीं रखा गया है, और उनके पास कुछ बकाया कीड़े हैं (हालांकि मेरी जानकारी के लिए, वे ज्यादातर पार्सिंग और मध्यरात्रि के संबंध में हैं)। momentjs बहुत अच्छा लगता है, और वर्तमान में बनाए रखा है।

— टीजे क्राउडर

@ कोलिटन, आपका अपडेट किया गया उत्तर पूर्ण नहीं है। मैंने कोशिश की है के रूप में है और मिल गया TypeError: Object [object Date] has no method 'clearTime':।

— हमीश ग्रुबीजन

ग्रांटेड मोमेंट.जेएस वह सब बड़ा नहीं है, लेकिन अगर आप यह कर रहे हैं तो सेकंड को hh: mm: ss में बदलना है, यह थोड़ा ओवरकिल जैसा लगता है। बल्कि इन या अन्य उत्तरों में सुझाए गए कार्यों में से एक का उपयोग करें।

— ओला कार्ल्ससन

मुझे लगता है कि मिक्स में दूसरे js लाइब्रेरी को फेंकने से बेहतर दूसरा उपाय है।

— डोनाटो

एक साधारण क्रिया के लिए पुस्तकालय जोड़ना मुझे लगता है कि उत्तर को स्वीकार नहीं किया जाना चाहिए। हाँ, यह काम करता है, लेकिन बेहतर समाधान है !!!

— एंड्रीस

Answer 2

आप निम्न की तरह जावास्क्रिप्ट तिथि पद्धति की सहायता से किसी भी बाहरी जावास्क्रिप्ट पुस्तकालय के बिना ऐसा करने का प्रबंधन कर सकते हैं:

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

Comments

मैं नहीं जानता कि क्यों हर कोई अतिरिक्त पुस्तकालयों को जोड़ रहा है या जब यह पूरी तरह से काम करता है तो मैन्युअल रूप से गणित कर रहा है। धन्यवाद!

— jminardi

इसे एक पंक्ति में भी छोटा किया जा सकता है: new Date(SECONDS * 1000).toISOString().substr(11, 8);

— फ्रैंक

प्रतिभाशाली। बिना किसी तीसरे पक्ष के परिवाद के। यह सबसे अच्छा है

— रिज़

इस दृष्टिकोण के साथ समस्या यह है कि यह 24 घंटे के बाद अतिप्रवाह कर देगा, आपको इस लंबाई से अधिक दिखाने से रोक देगा। सही समाधान अगर आप सेकंड में 24 घंटे से कम है।

— रेनो गामा

यह मेरे लिए IE11 में काम नहीं करता है, मुझे मिलता हैObject doesn't support property or method 'toISOString'

— NIBlyPig

Answer 3

मुझे नहीं लगता कि मानक दिनांक ऑब्जेक्ट की कोई भी अंतर्निहित सुविधा आपके लिए ऐसा करेगी जो केवल स्वयं गणित करने की तुलना में अधिक सुविधाजनक है।

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

Comments

मेरे विचार से इसके कुछ मुद्दे हैं? जब मैंने इसकी कोशिश की, तो मुझे दशमलव वापस मिल रहा था, इसलिए 180 सेकंड चर 0.05में वापस आ जाएंगे hours। मैंने इसे parseIntअपने मामले के लिए तय कर दिया, लेकिन मुझे नहीं लगता कि यह सब कुछ सही होगा। फिर भी, इससे मुझे मदद मिली, इसलिए धन्यवाद!

— BT643

@ BT643: अजीब बात है कि मैंने ऐसा नहीं किया। मैंने अब ऐसा किया है, आप इसके लिए उपयोग नहीं करना चाहते हैं parseInt, यह स्ट्रिंग को पार्स करने के लिए है , न कि संख्याओं में हेरफेर करने के लिए । Math.floorयहां प्रासंगिक संचालन होगा।

— टीजे क्राउडर

आह अच्छा! मेरा कोड बदल दिया। आप शायद के रूप में अच्छी सेकंड पर यह चाहते हैं हालांकि: seconds = Math.floor(totalSeconds % 60);। मुझे अभी एक दशमलव परिणाम भी मिला है।

— बीटी ६४३

@ BT643: totalSeconds % 60केवल एक भिन्नात्मक भाग हो सकता है यदि totalSecondsभिन्नात्मक भाग हो। आप चाहे तो उस पर निर्भर रह सकते हैं, चाहे आप उस जानकारी को खोना चाहते हों या उसे बरकरार रखना चाहते हों। (अन्य मंजिल संचालन हम कर रहे हैं किसी भी जानकारी को, क्योंकि वे केवल अपना मनपसंद डेटा में खत्म हो जाएगा बाहर साफ़ किए जा रहे खोना नहीं है, minutesऔर seconds।)

— टीजे Crowder

@ हन्नौय्यासीरconsole.log( hours +':'+ ('0'+minutes).slice(-2) +':'+ ('0'+seconds).slice(-2) );

— ज़ावी

Answer 4

मुझे पता है कि यह थोड़े पुराना है, लेकिन ...

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

Comments

एक सेकंड के अंशों के बारे में क्या? 03: 45: 45.xxx?

— माइक स्टोडर्ट

@ सैंटियागो हर्नांडेज़ महान! यह अब 24 घंटे से अधिक समय तक पूरी तरह से काम करता है।

— स्टेफनोट

+1। यह या टीजे को स्वीकृत उत्तर होना चाहिए, क्योंकि वे केवल वही होते हैं जो उन परिस्थितियों के लिए काम करते हैं जब अवधि 24 घंटे से अधिक हो जाती है (और प्रश्न अवधि सीमित नहीं करता है)।

— जॉर्ज वाई।

Answer 5

जैसा कि क्लेटन ने अपने उत्तर में बताया , क्षण.js का उपयोग इसके लिए किया जा सकता है:

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

Comments

यदि सेकंड की संख्या एक दिन से अधिक हो जाए तो क्या होगा?

— गिलाद पेलेग

@ गिलाडपेगेल यदि सेकंड की संख्या एक दिन से अधिक हो जाती है, तो दिनों की संख्या की गणना आंतरिक रूप से की जाती है और यह केवल शेष घंटों, मिनटों और सेकंडों को लौटाएगा। यदि आप दिनों की संख्या भी गिनना चाहते हैं, तो आप कोशिश कर सकते हैं moment().startOf('year').seconds(30000000).format('DDD HH:mm:ss')।

— एलक्विमिस्टा

यदि सेकंड की संख्या एक वर्ष से अधिक हो जाए तो क्या होगा?

— ऑरेंजपॉट

@OrangePot यदि सेकंड की संख्या एक वर्ष से अधिक हो जाती है, तो वर्षों की संख्या की गणना आंतरिक रूप से की जाती है और यह केवल शेष दिन, घंटे, मिनट और सेकंड लौटाएगा। यदि आप वर्षों की संख्या भी गिनना चाहते हैं, तो आप कोशिश कर सकते हैं.format('YYYY DDD HH:mm:ss')

— डेविड कॉलनान

लेकिन इसे वैकल्पिक नहीं बनाया जा सकता। वह बदसूरत लग सकता है।

— शेड्रिच

Answer 6

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

Comments

formatSeconds (3919); // रिटर्न 01:05:19 उत्कृष्ट फंक्शन .. जैसे

— सम्राट

Answer 7

यह चाल है:

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

( यहां से साभार )

Answer 8

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"

हम इस फ़ंक्शन को बहुत छोटा और कुरकुरा बना सकते हैं लेकिन यह पठनीयता कम कर देता है, इसलिए हम इसे यथासंभव सरल और यथासंभव स्थिर लिखेंगे।

या आप इस कार्य को यहां देख सकते हैं :

Comments

इसके अलावा ... यदि आप आसानी से सभी दिनांक समय बात करना चाहते हैं .. क्षण का उपयोग करें

— sheelpriy

धन्यवाद! ब्राउज़र एक्सटेंशन में लाइब्रेरी शामिल करने की कोई आवश्यकता नहीं है। सरल और काम करता है!

— 19lo में Arlo

Answer 9

इसे इस्तेमाल करे:

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

Answer 10

यहाँ संख्या वर्ग का विस्तार है। toHHMMSS () सेकंड को hh: mm: ss string में कनवर्ट करता है।

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>

Answer 11

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

Answer 12

यह कार्य इसे करना चाहिए:

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

इस फिडल को भी देखें ।

Comments

डिफ़ॉल्ट मापदंडों का उपयोग कर सकते हैं जैसे (इनपुट, विभाजक = ":")। जब तक मैंने इसे थोड़ा सा पेस्ट

— p/

@madprops: वास्तव में, मेरे जवाब में संस्करण पहले से ही पैरामीटर के :लिए डिफ़ॉल्ट रूप में सेट है separator, जैसा कि मैंने पहले ही समझाया था। यह कथन द्वारा किया गया है typeof separator !== 'undefined' ? separator : ':'। इसके अलावा, आपका कार्य मेरे लिए कुछ कॉस्मेटिक परिवर्तनों को बचाने के लिए बहुत समान है और उन्हें दोनों एक ही आउटपुट का उत्पादन करना चाहिए ... सिवाय मेरे संस्करण के बहुत बेहतर ब्राउज़र समर्थन है। आपका इंटरनेट एक्सप्लोरर या एमएस एज <14. के किसी भी संस्करण में काम नहीं करेगा

— जॉन सलेगर्स

Answer 13

नीचे दिया गया कोड है जो सेकंड को hh-mm-ss प्रारूप में बदल देगा:

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

जावास्क्रिप्ट में एचएच-एमएम-एसएस प्रारूप में कन्वर्ट सेकंड से वैकल्पिक विधि प्राप्त करें

Comments

क्या आपने इस जवाब से कॉपी पेस्ट किया ?

— स्टेफन्सआरी

Answer 14

HH के विशेष मामले के लिए : MM: SS.MS (eq: "00: 04: 33.637") FFMPEG द्वारा मिलीसेकंड निर्दिष्ट करने के लिए उपयोग किया जाता है ।

[-] [HH:] MM: SS [मीटर ...]

HH अधिकतम 2 अंकों के लिए घंटों की संख्या, MM की संख्या और अधिकतम 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];  
}

Comments

आप + "." + p.getMilliseconds()केवल २new Date(p.getTime()-o.getTime()).toISOString().split("T")[1].split("Z")[0]

— just तक जयजय

ठीक लग रहा है, हाँ आपका संस्करण तेजी से: बेंचमार्क jsben.ch/4sQY1 स्वीकृत संपादित देखें ! धन्यवाद।

— एनवीआरएम

Answer 15

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

Answer 16

मैं सिर्फ ऊपर दिए गए अच्छे जवाब के बारे में थोड़ा स्पष्टीकरण देना चाहता था:

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 का उपयोग करते हैं। यदि टोटल सेस 12600 (3 और आधे घंटे) था, तो parseInt (टोटल सेस / 3600) 3 वापस आएगा, क्योंकि हमारे पास पूरे 3 घंटे होंगे। हमें इस मामले में% 24 की आवश्यकता क्यों है? यदि हम 24 घंटे से अधिक हो जाते हैं, मान लें कि हमारे पास 25 घंटे (90000 सेकंड) हैं, तो यहां मॉड्यूल हमें 25 को वापस करने के बजाय 1 बार फिर से 1 पर ले जाएगा। यह 24 घंटे की सीमा के भीतर परिणाम को सीमित कर रहा है, क्योंकि 24 घंटे हैं एक दिन में।

जब आप कुछ इस तरह देखते हैं:

25 % 24

इसके बारे में इस तरह से सोचें:

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

Answer 17

इस पुराने सूत्र पर चिंतन करते हुए - ओपी ने एचएच: एमएम: एसएस और कई समाधानों के काम को कहा, जब तक आपको एहसास नहीं होता कि आपको सूचीबद्ध 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"

... मैंने एक अच्छा वन-लाइनर दृष्टिकोण के लिए, कम से कम कोड का उपयोग करने की कोशिश की।

Comments

क्या आप अपने कोड का एक विस्तारित / रीडिंग संस्करण प्रदान कर सकते हैं ताकि हम अधिक आसानी से देख सकें कि क्या हो रहा है? धन्यवाद।

— किमबॉल

Answer 18

क्या आपने किसी दिनांक ऑब्जेक्ट में सेकंड जोड़ने की कोशिश की है?

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

एक नमूना: https://jsfiddle.net/j5g2p0dc/5/

अपडेट किया गया: नमूना लिंक गायब था इसलिए मैंने एक नया बनाया।

Comments

अनक्रेडेड टाइपर्रर: dt.addSeconds एक फंक्शन नहीं है

— Ikrom

@ मैं सैंपल की जांच करता हूं, मैंने jsfiddle में एक नया बनाया है क्योंकि पुराने ने 404 त्रुटि लौटा दी है

— kpull1

ऐसा लगता है कि मैंने रिलीज़ नहीं किया है कि आप addSecondsडेट ऑब्जेक्ट पर कस्टम विधि का उपयोग कर रहे थे Date.prototype.addSeconds = function(seconds){...}। हां, यह काम करता है, अपडेट के लिए धन्यवाद।

— इक्रोम

Answer 19

यहां 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

Answer 20

सभी उत्तरों को देखने और उनमें से अधिकांश से खुश नहीं होने के बाद, यह वही है जो मैं लेकर आया हूं। मुझे पता है कि मुझे बातचीत में बहुत देर हो गई है, लेकिन यहाँ यह वैसे भी है।

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" प्रारूप में परिणाम प्राप्त करने के लिए regex, तर्क और गणित कलाबाजी की आवश्यकता को हटाता है, और इसके बजाय यह तरीकों में निर्मित पर निर्भर करता है।

आप यहाँ प्रलेखन पर एक नज़र रखना चाहते हैं: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date

Answer 21

इस समस्या को हल करने के बहुत सारे विकल्प हैं, और स्पष्ट रूप से इसके बारे में सुझाए गए अच्छे विकल्प हैं, लेकिन मैं यहां एक और अनुकूलित कोड जोड़ना चाहता हूं

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

}

नमूना कोड http://fiddly.org/1c476/1

Answer 22

एक पंक्ति में, टीजे क्राउडर के समाधान का उपयोग कर:

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

Answer 23

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

Answer 24

आप नीचे दिए गए कोड का भी उपयोग कर सकते हैं:

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

Answer 25

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

परिणाम 15:08:03

Answer 26

AngularJS का उपयोग करने वाले किसी भी व्यक्ति के लिए, एक सरल उपाय यह है कि मूल्य को एपीआई के साथ फ़िल्टर किया जाए , जो मिलिसेकंड को अनुरोधित प्रारूप के आधार पर स्ट्रिंग में परिवर्तित करता है। उदाहरण:

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

ध्यान दें कि यह मिलीसेकंड की अपेक्षा करता है, इसलिए यदि आप सेकंड से परिवर्तित कर रहे हैं (जैसा मूल प्रश्न तैयार किया गया था) तो आप 1000 से गुणा कर सकते हैं।

Answer 27

मैं उस मामले में भाग गया, जहां कुछ लोगों ने उल्लेख किया है कि सेकंड की संख्या एक दिन से अधिक है। यहां @Hishish 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'

Answer 28

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

Answer 29

यहां कोई भी उत्तर मेरी आवश्यकताओं को पूरा नहीं करता है क्योंकि मैं संभालना चाहता हूं

1. सेकंड (दिन) की बड़ी संख्या, और
2. ऋणात्मक संख्या

हालांकि उन लोगों को ओपी की आवश्यकता नहीं होती है, यह किनारे के मामलों को कवर करने के लिए अच्छा अभ्यास है, खासकर जब यह बहुत कम प्रयास करता है।

यह बहुत स्पष्ट है कि ओपी का अर्थ है सेकंड का एक नंबर जब वह सेकंड कहता है । आपके कार्य पर खूंटी क्यों लगेगी 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

Comments

secondsToTimeSpan(8991)रिटर्न 6.00:05:51जबकि मुझे लगता है कि यह लौटना चाहिए00:02:29:51

— user1063287

Answer 30

मैंने एक साधारण टाइमपास ऑब्जेक्ट बनाने से पहले इस कोड का उपयोग किया है:

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

Comments

लूपिंग परिणाम एक बहुत खराब कोडिंग तकनीक है और इसका इस्तेमाल कभी नहीं किया जाना चाहिए, यह आपकी प्रसंस्करण शक्ति को

— हग