जावास्क्रिप्ट सेकंड समय स्ट्रिंग के साथ प्रारूप hh: mm: ss

Question

मैं समय की अवधि को परिवर्तित करना चाहता हूं, यानी, कुछ सेकंड की संख्या में अलग-अलग समय स्ट्रिंग (hh: mm: ss)

मुझे यहाँ कुछ उपयोगी उत्तर मिले, लेकिन वे सभी x घंटे और x मिनट प्रारूप में बदलने की बात करते हैं।

तो वहाँ एक छोटा सा टुकड़ा है कि यह jQuery या सिर्फ कच्चे जावास्क्रिप्ट में करता है?

Comments

इस धागे में सुझाए गए कुछ जवाबों के बेंचमार्क। jsperf.com/ms-to-hh-mm-ss-time-format

— Claudijo

जावास्क्रिप्ट के साथ HH-MM-SS

— काइलमिट

Answer 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("5678".toHHMMSS());

कार्य स्निपेट:

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;
}
    
console.log("5678".toHHMMSS());

Comments

प्रोटोटाइप विचार के लिए धन्यवाद, मुझे पसंद है कि इसे कॉल करना कितना आसान है। मैंने नंबर को प्रोटोटाइप किया इसलिए मैं उन पर भी कॉल कर सकता हूं। मुझे यह जवाब भी मिला कि अगर ज़रूरत नहीं थी तो वे घंटों और मिनटों को हटा देंगे।

— alunsford3

"%" ऑपरेटर का उपयोग करें> var मिनट = Math.floor ((sec_num% 3600) / 60); var सेकंड = Math.floor (sec_num% 60);

— इवानम

आह धन्यवाद जब तक आप कॉल नहीं करते, तब तक मैं इसे स्ट्रिंग के रूप में दोनों तरीकों से काम नहीं करता। पूर्णांक पर .StString ()। आप इसे दूसरे तरीके से भी काम कर सकते हैं, यह भी

— सोनिक सोल

प्रोटोटाइप में मत डालो, बस एक उपयोगिता फ़ंक्शन करें।

— माइकल जे। कल्किंस

ऐसी चीज़ के लिए प्रोटोटाइप संशोधित करें? 390 upvotes? गंभीरता से?

— लुकास लाइजिस

Answer 2

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

var date = new Date(0);
date.setSeconds(45); // specify value for SECONDS here
var timeString = date.toISOString().substr(11, 8);
console.log(timeString)

Comments

यह जवाब इतना कम क्यों है? मुझे यह 2011 में मिलता है शायद IE 7 और 8 आधार था जो इसे समर्थन नहीं करेगा, लेकिन यह 2014 के अंत में है, इसलिए यह सरल मैदान, उपद्रव मुक्त समाधान उच्चतर होना चाहिए।

— एमिल बोरकोनी

MDN से: यदि आपके द्वारा निर्दिष्ट कोई पैरामीटर अपेक्षित सीमा से बाहर है, तो SetSeconds () दिनांक जानकारी को दिनांक ऑब्जेक्ट में तदनुसार अद्यतन करने का प्रयास करता है। उदाहरण के लिए, यदि आप सेकंड के लिए 100 का उपयोग करते हैं, तो दिनांक ऑब्जेक्ट में संग्रहीत मिनट 1 से बढ़ाए जाएंगे, और 40 सेकंड के लिए उपयोग किया जाएगा। तो हाँ, अच्छा लग रहा है!

— एंड्रयू

मुझे यह उत्तर पसंद है। यह भी कम किया जा सकता है: new Date(1000 * seconds).toISOString().substr(11, 8)।

— बोहुमीर ज़मेकनिक

अच्छा उत्तर। आप उपयोग कर सकते हैं .replace(/^[0:]+/, "")के बाद substrसभी शून्यों को दूर करने और :स्ट्रिंग की शुरुआत से।

— पालो

24 घंटों में समय को संभालने के लिए इसे सामने जोड़ें। parseInt (d / 86400) + "d"

— टोफंडेल

Answer 3

प्रारूप में समय का हिस्सा पाने के लिए hh:MM:ss, आप इस नियमित अभिव्यक्ति का उपयोग कर सकते हैं:

(यह किसी के द्वारा एक ही पोस्ट में ऊपर उल्लेख किया गया था, उसके लिए धन्यवाद।)

    var myDate = new Date().toTimeString().replace(/.*(\d{2}:\d{2}:\d{2}).*/, "$1");
    console.log(myDate)

Comments

+1 - सुपर-सरल; धन्यवाद! बस इसके एक प्रकार का उपयोग केवल मिनट और सेकंड दिखाने के लिए किया जाता है:var myDate = new Date().toTimeString().replace(/.*(\d{2}:\d{2})(:\d{2}).*/, "$1");

— Topher Fangio

ऐसा नहीं होना चाहिए "नया दिनांक (अशक्त, अशक्त, अशक्त, अशक्त, timeInSecs) .toTimeString ()। प्रतिस्थापन (/। \ _ \ _ {2}:) (\ d {{2}: d / 2) })। * /, "$ 2") "?

— ओबी

का उपयोग replaceभ्रामक है। उपयोग क्यों नहीं new Date(null, null, null, null, null, timeInSeconds).toTimeString().match(/\d{2}:\d{2}:\d{2}/)[0]?

— सिलीन डैरी

यह किसी दिए गए समय को दिखाने के लिए ठीक है, लेकिन ध्यान दें कि प्रश्न (और यहां अन्य उत्तर) एक अवधि दिखाने के बारे में हैं, यानी वर्तमान समय से स्वतंत्र सेकंड की संख्या।

— माहीमॉफ

इसका सरल संस्करण:new Date().toTimeString().split(" ")[0]

— हेनरिक एन

Answer 4

मैं दिनांक ऑब्जेक्ट का उपयोग करके सामान्य जावास्क्रिप्ट की सलाह देता हूं:

var seconds = 9999;
// multiply by 1000 because Date() requires miliseconds
var date = new Date(seconds * 1000);
var hh = date.getUTCHours();
var mm = date.getUTCMinutes();
var ss = date.getSeconds();
// If you were building a timestamp instead of a duration, you would uncomment the following line to get 12-hour (not 24) time
// if (hh > 12) {hh = hh % 12;}
// These lines ensure you have two-digits
if (hh < 10) {hh = "0"+hh;}
if (mm < 10) {mm = "0"+mm;}
if (ss < 10) {ss = "0"+ss;}
// This formats your string to HH:MM:SS
var t = hh+":"+mm+":"+ss;
document.write(t);

(बेशक, बनाई गई दिनांक ऑब्जेक्ट में इसके साथ एक वास्तविक तारीख जुड़ी होगी, लेकिन वह डेटा बाहरी है, इसलिए इन उद्देश्यों के लिए, आपको इसके बारे में चिंता करने की ज़रूरत नहीं है।)

Comments

यह स्थानीय समय क्षेत्र में तारीख तय करता है, जो मेरे मामले में 1 घंटे का समय जोड़ता है। सेकंड = 0 के साथ, मुझे "01:00:00" (Thu Jan 01 1970 01:00:00 GMT + 0100 (CET)) मिलता है, जो गलत है।

— शाम

यदि मैं उपयोग करता हूं date.getUTCHours()और मुझे एक सही परिणाम मिलता है date.getUTCMinutes()।

— ६

मुझे समझ में नहीं आता कि जब आप अवधि के लिए पूछते हैं तो आप 12 घंटे का टाइमस्टैम्प क्यों लौटा रहे हैं?

— नाथन सी। ट्रेश

@JellicleCat ने +1 और अच्छा नाम बदल दिया।

— नाथन सी। ट्रेश

मुझे यह पसंद है, लेकिन यह मानती है कि अवधि 24h से कम है

— रोरी

Answer 5

Google खोज ने इस परिणाम को बदल दिया :

function secondsToTime(secs)
{
    secs = Math.round(secs);
    var hours = Math.floor(secs / (60 * 60));

    var divisor_for_minutes = secs % (60 * 60);
    var minutes = Math.floor(divisor_for_minutes / 60);

    var divisor_for_seconds = divisor_for_minutes % 60;
    var seconds = Math.ceil(divisor_for_seconds);

    var obj = {
        "h": hours,
        "m": minutes,
        "s": seconds
    };
    return obj;
}

Comments

secondsToTime(119.9)=> Object {h: 0, m: 1, s: 60}। इसे ठीक करने के लिए, secs = Math.round(secs);विधि की शुरुआत में जोड़ें । बेशक, हमने डेमो के दौरान इस बग को देखा ...

— बेंजामिन क्राउज़ियर

Answer 6

एक विषय पर भिन्नता। एकल अंक सेकंड को थोड़ा अलग तरीके से संभालता है

seconds2time(0)  ->  "0s" 
seconds2time(59) -> "59s" 
seconds2time(60) -> "1:00" 
seconds2time(1000) -> "16:40" 
seconds2time(4000) -> "1:06:40"

function seconds2time (seconds) {
    var hours   = Math.floor(seconds / 3600);
    var minutes = Math.floor((seconds - (hours * 3600)) / 60);
    var seconds = seconds - (hours * 3600) - (minutes * 60);
    var time = "";

    if (hours != 0) {
      time = hours+":";
    }
    if (minutes != 0 || time !== "") {
      minutes = (minutes < 10 && time !== "") ? "0"+minutes : String(minutes);
      time += minutes+":";
    }
    if (time === "") {
      time = seconds+"s";
    }
    else {
      time += (seconds < 10) ? "0"+seconds : String(seconds);
    }
    return time;
}

Comments

इस पर मुझे एक घंटे बचाने के लिए धन्यवाद

— स्टारिनमपाइप्स

Answer 7

यहाँ मेरा उस पर ले लो:

function formatTime(seconds) {
  const h = Math.floor(seconds / 3600);
  const m = Math.floor((seconds % 3600) / 60);
  const s = Math.round(seconds % 60);
  return [
    h,
    m > 9 ? m : (h ? '0' + m : m || '0'),
    s > 9 ? s : '0' + s
  ].filter(Boolean).join(':');
}

अपेक्षित परिणाम:

const expect = require('expect');
expect(formatTime(0)).toEqual('0:00');
expect(formatTime(1)).toEqual('0:01');
expect(formatTime(599)).toEqual('9:59');
expect(formatTime(600)).toEqual('10:00');
expect(formatTime(3600)).toEqual('1:00:00');
expect(formatTime(360009)).toEqual('100:00:09');
expect(formatTime(0.2)).toEqual('0:00');

Comments

आप इसे इस प्रकार लिख सकते हैं: const formatTime = (seconds, h = Math.floor(seconds / 3600), m = Math.floor((seconds % 3600) / 60), s = seconds % 60) => [h, m > 9 ? m : '0' + m, s > 9 ? s : '0' + s].filter(s => s).join(':');

— रूबेन स्टोक

@ रूबेनस्टॉक मुझे ऐसा लगता है कि दो secondतर्कों को लेने वाले एक फ़ंक्शन को भ्रमित करना थोड़ा मुश्किल है । मुझे अपना संस्करण स्पष्ट लगता है, भले ही यह थोड़ा और अधिक हो।

— टॉम एस्टरेस

seconds: numberप्रकार एनोटेशन, es6 में?

— ओलिएन ०४

@pstanton ट्रेलिंग कॉमा IE9 के बाद से समर्थित है: caniuse.com/#feat=mdn-javascript_grammar_trailing_commas । मैं व्यक्तिगत रूप से अब उन पुराने ब्राउज़रों को अनदेखा करना चुन रहा हूं। लेकिन आप सही कह रहे हैं, मैंने इसे हटा दिया है इसलिए उत्तर अधिक सामान्य है।

— टॉम एस्टेरेज़

महान समाधान। हो सकता है कि बस सेकंड बदल जाएconst s = Math.round(seconds % 60);

— Raff

Answer 8

मुझे पहला उत्तर पसंद है। वहाँ कुछ अनुकूलन:

• source data एक नंबर है। अतिरिक्त गणना की जरूरत नहीं है।

• बहुत अधिक कंप्यूटिंग

परिणाम कोड:

Number.prototype.toHHMMSS = function () {
    var seconds = Math.floor(this),
        hours = Math.floor(seconds / 3600);
    seconds -= hours*3600;
    var minutes = Math.floor(seconds / 60);
    seconds -= minutes*60;

    if (hours   < 10) {hours   = "0"+hours;}
    if (minutes < 10) {minutes = "0"+minutes;}
    if (seconds < 10) {seconds = "0"+seconds;}
    return hours+':'+minutes+':'+seconds;
}

Comments

मुझे लगता है कि यह फ़ंक्शन एक विशेषता है जिसका उपयोग सामने वाले में किया जाता है और उसके बाद मैं स्ट्रिंग स्ट्रिंग करता हूं और नंबर नहीं। और नंबर हमेशा एक स्ट्रिंग हो सकता है लेकिन दूसरे तरीके से नहीं।

— पावटाक

मुझे लगता Numberहै कि सही है क्योंकि secondsवास्तव में, एक संख्या है। आपको इस फ़ंक्शन का उपयोग करने से पहले स्ट्रिंग से परिवर्तित करना चाहिए, जो कि सही काम है!

— कैसरसोल

उत्तोलित उत्तर, बस इस तरह, एक खराब हैं। मुझे यकीन है कि आपको इस विधि के लिए सभी नंबरों की आवश्यकता नहीं है। यादृच्छिक उपयोगिता सामान के लिए प्रोटोटाइप को संशोधित न करें।

— लुकास लाइज़िस

या केवल प्रोटोटाइप करने के लिए और इसे एक फंक्शन बनायें numToHHMMSS या strTOHHMMSS

— yeahdixon

यह समाधान काम करता है जबकि चुना हुआ समाधान कुछ निश्चित मानों के लिए 60 सेकंड उत्पन्न करता है।

— AndroidDev

Answer 9

अद्भुत क्षण का उपयोग करते हुए। जेएस पुस्तकालय:

function humanizeDuration(input, units ) { 
  // units is a string with possible values of y, M, w, d, h, m, s, ms
  var duration = moment().startOf('day').add(units, input),
    format = "";

  if(duration.hour() > 0){ format += "H [hours] "; }

  if(duration.minute() > 0){ format += "m [minutes] "; }

  format += " s [seconds]";

  return duration.format(format);
}

यह आपको किसी भी अवधि को निर्दिष्ट करने की अनुमति देता है यह घंटे, मिनट, सेकंड, मिल्स, और एक मानव पठनीय संस्करण देता है।

Answer 10

function formatTime(seconds) {
    return [
        parseInt(seconds / 60 / 60),
        parseInt(seconds / 60 % 60),
        parseInt(seconds % 60)
    ]
        .join(":")
        .replace(/\b(\d)\b/g, "0$1")
}

Comments

आगे यह स्पष्टीकरण क्यों यह उत्तर प्रश्नकर्ता के लिए काम करेगा या मूल प्रश्न में क्या गलत हो सकता है, इस उत्तर की गुणवत्ता को बढ़ाने में मदद करेगा।

— जोश बर्गेस

सुंदर आत्म व्याख्यात्मक और अच्छा उत्तर, शीर्ष उत्तर को कम और सरल बनाया।

— अलेक्सियोव्यू

सटीक उत्तर

— :)

Answer 11

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

परिणाम 15:08:03

Comments

अच्छा धन्यवाद! और एक छोटी सी सुधार जो मैंने अपनी जरूरतों के लिए की थी, वह मिलीसेकेंड में एक अवधि को एचएच: एमएम: एसएस - में परिवर्तित करना था, new Date(new Date().getTime() - startTime).toUTCString().split(" ")[4]जहां startTimeपहले उपयोग किया गया था startTime = new Date().getTime();। (मुझे इसका उपयोग करना था toUTCString()क्योंकि अन्यथा समय एक घंटा बाहर था।)

— रिचर्ड विस्मैन

Answer 12

यह बहुत आसान है,

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

Comments

यह केवल तभी काम करता है जब आपकी समय अवधि 1 दिन से कम हो। लेकिन अन्यथा, बहुत अच्छा।

— cjbarth

Answer 13

s2t=function (t){
  return parseInt(t/86400)+'d '+(new Date(t%86400*1000)).toUTCString().replace(/.*(\d{2}):(\d{2}):(\d{2}).*/, "$1h $2m $3s");
}

s2t(123456);

परिणाम:

1d 10h 17m 36s

Answer 14

मुझे पसंद आया कि वेबजिन्स ने सबसे अधिक उत्तर दिया, इसलिए मैंने इसे विज्ञापन प्रत्यय के साथ प्रदर्शित करने के लिए बढ़ाया, प्रदर्शन सशर्त बनाया और सादे सेकंड में प्रत्यय के रूप में शामिल किया:

function sec2str(t){
    var d = Math.floor(t/86400),
        h = ('0'+Math.floor(t/3600) % 24).slice(-2),
        m = ('0'+Math.floor(t/60)%60).slice(-2),
        s = ('0' + t % 60).slice(-2);
    return (d>0?d+'d ':'')+(h>0?h+':':'')+(m>0?m+':':'')+(t>60?s:s+'s');
}

"3D 16:32:12" या "16:32:12" या "32:12" या "12s" रिटर्न

Comments

यह 24 दिनों या उससे अधिक की अवधि के लिए गलत होगा

— चार्ली मार्टिन

आप 0 से अधिक तार की तुलना क्यों कर रहे हैं?

— जिमी केन

@ जिमीकेन क्योंकि ऑटोमैटिक टाइपकास्टिंग - मैं इसे लूप करता हूँ! (प्लस: कोड को पढ़ना अधिक आसान है (आपको एक कारण के लिए टाइपकास्टिंग मिल गया है, लेकिन चलो ट्रोल करना बंद कर दें (हम दोनों))। प्लस: फ़ंक्शन केवल तभी विफल होगा जब टी NaN है - इसलिए यदि आप सुरक्षा चाहते हैं: तो इनपुट पर!)

— n thekö

@ n @kö ठीक है मैं समझता हूं लेकिन अधिक सख्त नए जेएस संस्करण, लिंटर आदि की शिकायत कर सकते हैं। सिर्फ कह रहा है, मुझे गलत हो जाओ। मुझे आपका जवाब पसंद है

— जिमी केन

Answer 15

मुझे पॉव्टैक का जवाब पसंद था, लेकिन मैं इसे कोणीय.जेएस में इस्तेमाल करना चाहता था, इसलिए मैंने उनके कोड का उपयोग करके एक फ़िल्टर बनाया।

.filter('HHMMSS', ['$filter', function ($filter) {
    return function (input, decimals) {
        var sec_num = parseInt(input, 10),
            decimal = parseFloat(input) - sec_num,
            hours   = Math.floor(sec_num / 3600),
            minutes = Math.floor((sec_num - (hours * 3600)) / 60),
            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;}
        var time    = hours+':'+minutes+':'+seconds;
        if (decimals > 0) {
            time += '.' + $filter('number')(decimal, decimals).substr(2);
        }
        return time;
    };
}])

यह कार्यात्मक रूप से समान है, सिवाय इसके कि मैंने एक वैकल्पिक दशमलव क्षेत्र में आंशिक सेकंड प्रदर्शित करने के लिए जोड़ा। इसका उपयोग ऐसे करें जैसे आप कोई अन्य फ़िल्टर करेंगे:

{{ elapsedTime | HHMMSS }} प्रदर्शित करता है: 01:23:45

{{ elapsedTime | HHMMSS : 3 }} प्रदर्शित करता है: 01:23:45.678

Comments

मेरे पास दो डेटाइम ऑब्जेक्ट हैं और मैं इस 2 डेटाइम ऑब्जेक्ट और रिटर्न आउटपुट के अंतर की गणना इस प्रारूप में करना चाहता हूं: घंटा: मिनट: डबल अंक के साथ सेकंड जैसे: 01: 02: 45. आप मुझे बताएं या मुझे थोड़ा गाइड करें अपने कोड के साथ ??

— लर्निंग-ओवरथिंकर-जुलाहा

Answer 16

मुझे लगता है कि यह प्रदर्शन अब तक का सबसे तेज है:

var t = 34236; // your seconds
var time = ('0'+Math.floor(t/3600) % 24).slice(-2)+':'+('0'+Math.floor(t/60)%60).slice(-2)+':'+('0' + t % 60).slice(-2)
//would output: 09:30:36

Comments

वाकई शानदार। बधाई!

— ब्रायनर फेरेरा

अच्छा ... और> 24 घंटे सुरक्षित।

— जेफ़ज़

Answer 17

function toHHMMSS(seconds) {
    var h, m, s, result='';
    // HOURs
    h = Math.floor(seconds/3600);
    seconds -= h*3600;
    if(h){
        result = h<10 ? '0'+h+':' : h+':';
    }
    // MINUTEs
    m = Math.floor(seconds/60);
    seconds -= m*60;
    result += m<10 ? '0'+m+':' : m+':';
    // SECONDs
    s=seconds%60;
    result += s<10 ? '0'+s : s;
    return result;
}

उदाहरण

    toHHMMSS (111); 
    "01:51"

    toHHMMSS (4444);
    "01:14:04"

    toHHMMSS (33);
    "00:33"

Comments

मैं Math.floor()सेकंड पर भी डाल दिया था क्योंकि वे दशमलव में दिया जा सकता है। (मेरे साथ हुआ।)

— विंटर

Answer 18

यहाँ अभी तक एक और संस्करण है, जो दिन भी संभालता है:

function FormatSecondsAsDurationString( seconds )
{
    var s = "";

    var days = Math.floor( ( seconds / 3600 ) / 24 );
    if ( days >= 1 )
    {
        s += days.toString() + " day" + ( ( days == 1 ) ? "" : "s" ) + " + ";
        seconds -= days * 24 * 3600;
    }

    var hours = Math.floor( seconds / 3600 );
    s += GetPaddedIntString( hours.toString(), 2 ) + ":";
    seconds -= hours * 3600;

    var minutes = Math.floor( seconds / 60 );
    s += GetPaddedIntString( minutes.toString(), 2 ) + ":";
    seconds -= minutes * 60;

    s += GetPaddedIntString( Math.floor( seconds ).toString(), 2 );

    return s;
}

function GetPaddedIntString( n, numDigits )
{
    var nPadded = n;
    for ( ; nPadded.length < numDigits ; )
    {
        nPadded = "0" + nPadded;
    }

    return nPadded;
}

Answer 19

toString()दिनांक ऑब्जेक्ट की विधि से लौटी स्ट्रिंग में प्रतिस्थापित समय का मिलान करने के लिए एक नियमित अभिव्यक्ति का उपयोग किया जा सकता है , जो निम्नानुसार स्वरूपित है: "थू जूल 05 2012 02:45:12 GMT + 0100 (GMT डेलाइट टाइम)"। ध्यान दें कि यह समाधान युग के बाद के समय का उपयोग करता है: 1 जनवरी, 1970 की आधी रात। यह समाधान एक-लाइनर हो सकता है, हालांकि इसे विभाजित करने से इसे समझना बहुत आसान हो जाता है।

function secondsToTime(seconds) {
    const start = new Date(1970, 1, 1, 0, 0, 0, 0).getTime();
    const end = new Date(1970, 1, 1, 0, 0, parseInt(seconds), 0).getTime();
    const duration = end - start;

    return new Date(duration).toString().replace(/.*(\d{2}:\d{2}:\d{2}).*/, "$1");
}

Answer 20

यहाँ है कि मैं यह कैसे किया। यह काफी अच्छी तरह से काम करने लगता है, और यह बहुत कॉम्पैक्ट है। (यह बहुत सारे टर्नरी ऑपरेटरों का उपयोग करता है, हालांकि)

function formatTime(seconds) {
  var hh = Math.floor(seconds / 3600),
    mm = Math.floor(seconds / 60) % 60,
    ss = Math.floor(seconds) % 60;
  return (hh ? (hh < 10 ? "0" : "") + hh + ":" : "") + ((mm < 10) && hh ? "0" : "") + mm + ":" + (ss < 10 ? "0" : "") + ss
}

... और तार स्वरूपण के लिए ...

String.prototype.toHHMMSS = function() {
  formatTime(parseInt(this, 10))
};

Answer 21

आप समय (सेकंड में) को HH:MM:SSप्रारूप में बदलने के लिए निम्नलिखित फ़ंक्शन का उपयोग कर सकते हैं :

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

---

डेमो

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

document.body.innerHTML = '<pre>' + JSON.stringify({
    5.3515555 : convertTime(5.3515555),
    126.2344452 : convertTime(126.2344452, '-'),
    1156.1535548 : convertTime(1156.1535548, '.'),
    9178.1351559 : convertTime(9178.1351559, ':'),
    13555.3515135 : convertTime(13555.3515135, ',')
}, null, '\t') +  '</pre>';

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

Answer 22

ब्लॉक पर स्ट्रिंग्स के लिए एक नया तरीका है: पैडस्टार्ट

const str = '5';
str.padStart(2, '0'); // 05

यहां एक नमूना उपयोग का मामला है: जावास्क्रिप्ट की 4 लाइनों में YouTube अवधि

Answer 23

मैंने इस तरह से इसे किया

function timeFromSecs(seconds)
{
    return(
    Math.floor(seconds/86400)+'d :'+
    Math.floor(((seconds/86400)%1)*24)+'h : '+
    Math.floor(((seconds/3600)%1)*60)+'m : '+
    Math.round(((seconds/60)%1)*60)+'s');
}

टाइमफ्रेमसेकस (22341938) '258 डी 14 एच 5 एम 38 एस' लौटाएगा

Answer 24

मैं व्यक्तिगत रूप से अग्रणी शून्य के बिना अग्रणी इकाई (दिन, घंटे, मिनट) को प्राथमिकता देता हूं। लेकिन सेकंड को हमेशा मिनटों (0:13) तक ले जाना चाहिए, इस प्रस्तुति को आसानी से 'अवधि' के रूप में माना जाता है, आगे की व्याख्या (मिनट, सेकंड (एस), आदि के रूप में चिह्नित), विभिन्न भाषाओं (अंतर्राष्ट्रीयकरण) में प्रयोग करने योग्य।

    // returns  (-)d.h:mm:ss(.f)
    //          (-)h:mm:ss(.f)
    //          (-)m:ss(.f)
    function formatSeconds (value, fracDigits) {
        var isNegative = false;
        if (isNaN(value)) {
            return value;
        } else if (value < 0) {
            isNegative = true;
            value = Math.abs(value);
        }
        var days = Math.floor(value / 86400);
        value %= 86400;
        var hours = Math.floor(value / 3600);
        value %= 3600;
        var minutes = Math.floor(value / 60);
        var seconds = (value % 60).toFixed(fracDigits || 0);
        if (seconds < 10) {
            seconds = '0' + seconds;
        }

        var res = hours ? (hours + ':' + ('0' + minutes).slice(-2) + ':' + seconds) : (minutes + ':' + seconds);
        if (days) {
            res = days + '.' + res;
        }
        return (isNegative ? ('-' + res) : res);
    }

// सर्वर साइड की नकल करना (.net, C #) अवधि स्वरूपण जैसे:

    public static string Format(this TimeSpan interval)
    {
        string pattern;
        if (interval.Days > 0)          pattern = @"d\.h\:mm\:ss";
        else if (interval.Hours > 0)    pattern = @"h\:mm\:ss";
        else                            pattern = @"m\:ss";
        return string.Format("{0}", interval.ToString(pattern));
    }

Answer 25

आप पल-अवधि-प्रारूप प्लगइन के साथ Momement.js का उपयोग कर सकते हैं :

var seconds = 3820;
var duration = moment.duration(seconds, 'seconds');
var formatted = duration.format("hh:mm:ss");
console.log(formatted); // 01:03:40

<!-- Moment.js library -->
<script src="https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.18.1/moment.min.js"></script>

<!-- moment-duration-format plugin -->
<script src="https://cdnjs.cloudflare.com/ajax/libs/moment-duration-format/1.3.0/moment-duration-format.min.js"></script>

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

Comments

आकर्षण की तरह काम करता है (प्रारूप को छोड़कर जो परिभाषित नहीं है) किसी वस्तु को अवधि, महीने, घंटे, मिनट और सेकंड में बदलने के लिए

— Pi Home Server

Answer 26

const secondsToTime = (seconds, locale) => {
    const date = new Date(0);
    date.setHours(0, 0, seconds, 0);
    return date.toLocaleTimeString(locale);
}
console.log(secondsToTime(3610, "en"));

जहां स्थानीय पैरामीटर ("एन", "डी", आदि) वैकल्पिक है

Answer 27

secToHHMM(number: number) {
    debugger;
    let hours = Math.floor(number / 3600);
    let minutes = Math.floor((number - (hours * 3600)) / 60);
    let seconds = number - (hours * 3600) - (minutes * 60);
    let H, M, S;
    if (hours < 10) H = ("0" + hours);
    if (minutes < 10) M = ("0" + minutes);
    if (seconds < 10) S = ("0" + seconds);
    return (H || hours) + ':' + (M || minutes) + ':' + (S || seconds);
}

Answer 28

यहां 2019 के लिए वन-लाइनर अपडेट किया गया है:

//your date
var someDate = new Date("Wed Jun 26 2019 09:38:02 GMT+0100") 

var result = `${String(someDate.getHours()).padStart(2,"0")}:${String(someDate.getMinutes()).padStart(2,"0")}:${String(someDate.getSeconds()).padStart(2,"0")}`

//result will be "09:38:02"

Comments

मुझे लगता है कि ओपी एक अवधि (सेकंड) को एक Dateवस्तु नहीं बदलना चाहता है ।

— मुरलीगिरी

उफ़, मेरा बुरा :(

— डेटागृह

Answer 29

यहाँ एक काफी सरल समाधान है जो निकटतम दूसरे के लिए गोल है!

var returnElapsedTime = function(epoch) {
  //We are assuming that the epoch is in seconds
  var hours = epoch / 3600,
      minutes = (hours % 1) * 60,
      seconds = (minutes % 1) * 60;
  return Math.floor(hours) + ":" + Math.floor(minutes) + ":" + Math.round(seconds);
}

Answer 30

यह एक है जिसे मैंने हाल ही में MM: SS के लिए लिखा है। यह सवाल के लिए सटीक नहीं है, लेकिन यह एक अलग लाइनर प्रारूप है।

const time = 60 * 2 + 35; // 2 minutes, 35 seconds
const str = (~~(time / 60) + "").padStart(2, '0') + ":" + (~~((time / 60) % 1 * 60) + "").padStart(2, '0');

str // 02:35

संपादित करें: यह विविधता के लिए जोड़ा गया था, लेकिन यहां सबसे अच्छा समाधान https://stackoverflow.com/a/25279399/639679 है।