मुझे जावास्क्रिप्ट में दो तिथियों के बीच कितने दिन मिलते हैं?

Question

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

<input id="first" value="1/1/2000"/>
<input id="second" value="1/1/2001"/>

<script>
  alert(datediff("day", first, second)); // what goes here?
</script>

Comments

99% मामलों में जहां उपयोगकर्ता "दो तिथियों के बीच दिनों की संख्या" के लिए पूछता है वह जो नहीं समझता है वह यह है कि वह नाशपाती के साथ सेब की तुलना करने की कोशिश कर रहा है। यह समस्या इतनी सरल हो जाती है जब पूछा जाता है कि "DATE ​​RANGE में कितने दिनांक हैं?", या मुझे कैलेंडर पर कितने वर्ग पार करने हैं। यह समय और दिन की बचत के मुद्दों आदि को छोड़ देता है। भ्रम की स्थिति डेटाइम डेटा संरचना के कारण हम पर निहित है जो शुद्ध बकवास है। डेटटाइम जैसी कोई चीज नहीं है, तारीख और समय है, प्रकृति और व्यवहार दोनों में दो बहुत अलग वस्तुएं हैं

— मिहेल शिशकोव

एक फ़ंक्शन के लिए जो समय की (संपूर्ण) इकाइयों में अंतर को विभाजित करता है, इसका उत्तर stackoverflow.com/a/53092438/3787376 पर उपयोग करें ।

— एडवर्ड

मुझे लगता है कि इस प्रश्न को हटा दिया जाना चाहिए या कम से कम "बचना" चाहिए क्योंकि अधिकांश उत्तर गलत हैं या विभिन्न पुस्तकालयों पर निर्भर हैं।

— रॉबग

Answer 1

प्रश्न में प्रस्तुत समस्या को हल करने के लिए अवधारणा के प्रमाण के रूप में , एक त्वरित और गंदा कार्यान्वयन है datediff। यह इस तथ्य पर निर्भर करता है कि आप उन्हें घटाकर दो तिथियों के बीच बीता हुआ मिलीसेकंड प्राप्त कर सकते हैं, जो उन्हें उनके आदिम संख्या मान (1970 की शुरुआत से मिलीसेकंड) में ले जाता है।

// new Date("dateString") is browser-dependent and discouraged, so we'll write
// a simple parse function for U.S. date format (which does no error checking)
function parseDate(str) {
    var mdy = str.split('/');
    return new Date(mdy[2], mdy[0]-1, mdy[1]);
}

function datediff(first, second) {
    // Take the difference between the dates and divide by milliseconds per day.
    // Round to nearest whole number to deal with DST.
    return Math.round((second-first)/(1000*60*60*24));
}

alert(datediff(parseDate(first.value), parseDate(second.value)));

<input id="first" value="1/1/2000"/>
<input id="second" value="1/1/2001"/>

आपको पता होना चाहिए कि "सामान्य" दिनांक API (नाम में "UTC" के बिना) उपयोगकर्ता के ब्राउज़र के स्थानीय समय-क्षेत्र में काम करती है, इसलिए सामान्य तौर पर आप उन मुद्दों में भाग सकते हैं यदि आपका उपयोगकर्ता किसी समय-क्षेत्र में है जो आप नहीं करते हैं उम्मीद है, और आपके कोड को डेलाइट सेविंग टाइम संक्रमण से निपटना होगा। आपको दिनांक ऑब्जेक्ट और उसके तरीकों के लिए प्रलेखन को ध्यान से पढ़ना चाहिए, और कुछ अधिक जटिल के लिए, एक पुस्तकालय का उपयोग करने पर दृढ़ता से विचार करना चाहिए जो दिनांक हेरफेर के लिए अधिक सुरक्षित और शक्तिशाली एपीआई प्रदान करता है।

• नंबर और तारीखें - एमडीएन जावास्क्रिप्ट गाइड
• Date - एमडीएन जावास्क्रिप्ट संदर्भ

_{इसके अलावा, उदाहरण के प्रयोजनों के लिए, स्निपेट का उपयोग संक्षिप्तता के लिए वस्तु पर नामित नाम का उपयोगwindow करता है , लेकिन उत्पादन में आपको getElementById जैसे मानकीकृत एपीआई , या अधिक संभावना, कुछ यूआई फ्रेमवर्क का उपयोग करना चाहिए ।}

Comments

मुझे लगता है कि Math.trunc () अधिक उपयुक्त है। बस अगर कोई व्यक्ति अधिक सटीक दिनांक ऑब्जेक्ट (जैसे कि घंटे, मिनट और सेकंड सहित) का उपयोग करता है

— जिन वांग

सही और उच्चतम मतदान के रूप में चिह्नित किए गए उत्तर के रूप में (अब के रूप में), यह टिप्पणी योग्य है कि यह उत्तर डेलाइट सेविंग टाइम को सही ढंग से नहीं संभालता है। इसके बजाय माइकल लियू का जवाब देखें।

— ओसुलिक

ParseDate वास्तव में क्या करता है?

— मोहम्मद करमानी

@ osullic-इस उत्तर के हैंडल के साथ बचत दिन के उजाले गणित.गोल , लेकिन यह हाथ तारीख केवल तार, नहीं दिनांक और समय होने की उम्मीद है।

— 1

बस याद रखें कि तारीख इस प्रारूप में अमेरिकी प्रारूप में है, अर्थात एमएम / डीडी / वाईवाईवाई। यदि आपको यूके संस्करण की आवश्यकता है, तो आपको होने की parseDateविधि को बदलने की आवश्यकता है:return new Date(mdy[2], mdy[1], mdy[0]-1);

— वियाकास

Answer 2

इस लेखन के रूप में, अन्य उत्तरों में से केवल एक ही सही ढंग से डीएसटी (दिन के समय की बचत समय) बदलाव को संभालता है। यहाँ कैलिफोर्निया में स्थित एक प्रणाली के परिणाम हैं:

                                        1/1/2013- 3/10/2013- 11/3/2013-
User       Formula                      2/1/2013  3/11/2013  11/4/2013  Result
---------  ---------------------------  --------  ---------  ---------  ---------
Miles                   (d2 - d1) / N   31        0.9583333  1.0416666  Incorrect
some         Math.floor((d2 - d1) / N)  31        0          1          Incorrect
fuentesjr    Math.round((d2 - d1) / N)  31        1          1          Correct
toloco     Math.ceiling((d2 - d1) / N)  31        1          2          Incorrect

N = 86400000

हालांकि Math.roundसही परिणाम देता है, मुझे लगता है कि यह कुछ हद तक क्लूनी है। इसके बजाय, स्पष्ट रूप से यूटीसी ऑफसेट के लिए लेखांकन द्वारा जब डीएसटी शुरू होता है या समाप्त होता है, हम सटीक अंकगणित का उपयोग कर सकते हैं:

function treatAsUTC(date) {
    var result = new Date(date);
    result.setMinutes(result.getMinutes() - result.getTimezoneOffset());
    return result;
}

function daysBetween(startDate, endDate) {
    var millisecondsPerDay = 24 * 60 * 60 * 1000;
    return (treatAsUTC(endDate) - treatAsUTC(startDate)) / millisecondsPerDay;
}

alert(daysBetween($('#first').val(), $('#second').val()));

व्याख्या

जावास्क्रिप्ट तिथि गणना मुश्किल है क्योंकि Dateऑब्जेक्ट UTC में आंतरिक रूप से संग्रहीत होते हैं , स्थानीय समय नहीं। उदाहरण के लिए, 3/10/2013 12:00 AM प्रशांत मानक समय (UTC-08: 00) 3/10/2013 8:00 AM UTC, और 3/11/2013 12:00 AM प्रशांत डेलाइट समय के रूप में संग्रहीत किया जाता है UTC-07: 00) को 3/11/2013 7:00 AM UTC के रूप में संग्रहीत किया जाता है। इस दिन, UTC में मध्यरात्रि से स्थानीय समय केवल 23 घंटे है!

हालांकि स्थानीय समय में एक दिन 24 घंटे से अधिक या कम हो सकता है, यूटीसी में एक दिन हमेशा 24 घंटे होता है। ¹daysBetween ऊपर दर्शाई गई विधि इस तथ्य का लाभ उठाकर पहली बार कॉल treatAsUTCकरके दोनों स्थानीय समय को आधी रात को यूटीसी को समायोजित करने से पहले घटाती और विभाजित करती है।

^{1. जावास्क्रिप्ट लीप सेकंड की अनदेखी करता है।}

Comments

UTC का उपयोग करने की कोई आवश्यकता नहीं है, यह केवल स्थानीय घंटे को मध्यरात्रि (या दोनों तिथियों के लिए समान मूल्य) पर सेट करने के लिए ठीक है। दिन के उजाले की बचत के द्वारा शुरू किया गया भिन्नात्मक दिन केवल by 0.04 है (और कुछ स्थानों पर कम), इसलिए यह Math.round के साथ बाहर निकलता है । ;-) तार निर्माण को पार्स स्ट्रिंग्स पर निर्भर करना एक अच्छा विचार नहीं है। यदि आप वास्तव में UTC मानों का उपयोग करना चाहते हैं, Date.UTC(...)तो पहली बार में स्ट्रिंग का उपयोग करें ।

— 1

@RobG: जैसा कि मैंने अपने जवाब में कहा था: "हालांकि मैथ.वार्ड सही परिणाम देता है, मुझे लगता है कि यह कुछ हद तक क्लिंक है। इसके बजाय, यूटीसी ऑफसेट में बदलाव के लिए स्पष्ट रूप से लेखांकन द्वारा जब डीएसटी शुरू होता है या समाप्त होता है, तो हम सटीक अंकगणितीय का उपयोग कर सकते हैं।"

— माइकल लियू

दरअसल, जिस समय को आपने "गलत" के रूप में दर्शाया है, तकनीकी रूप से, सही है। आप DateTimes को UTC में नहीं बदल रहे हैं ... आप एक कृत्रिम पूरा नंबर प्राप्त करने के लिए प्रत्येक DateTime का समय बदल रहे हैं। गोलाई "क्लंकी" नहीं है ... यह यहाँ बिल्कुल सही दृष्टिकोण है क्योंकि यही आप अपने सिर में वैसे भी कर रहे हैं: आप समय भाग (घंटे, मिनट, सेकंड) को दूर कर रहे हैं और बस एक पूरी कोशिश कर रहे हैं दिन की संख्या।

— JDB अभी भी

Answer 3

दो तिथियों के बीच अंतर पाने का सबसे आसान तरीका:

var diff =  Math.floor(( Date.parse(str2) - Date.parse(str1) ) / 86400000); 

आपको अंतर दिन मिलते हैं (या यदि एक या दोनों को पार्स नहीं किया जा सकता है)। पार्स डेट ने मिलीसेकंड में परिणाम प्राप्त किया और इसे दिन तक प्राप्त करने के लिए आपको इसे 24 * 60 * 60 * 100 से विभाजित करना होगा

यदि आप इसे दिन, घंटे, मिनट, सेकंड और मिलीसेकंड से विभाजित करना चाहते हैं:

function dateDiff( str1, str2 ) {
    var diff = Date.parse( str2 ) - Date.parse( str1 ); 
    return isNaN( diff ) ? NaN : {
        diff : diff,
        ms : Math.floor( diff            % 1000 ),
        s  : Math.floor( diff /     1000 %   60 ),
        m  : Math.floor( diff /    60000 %   60 ),
        h  : Math.floor( diff /  3600000 %   24 ),
        d  : Math.floor( diff / 86400000        )
    };
}

यहाँ मेरा जेम्स संस्करण का नया संस्करण है:

function mydiff(date1,date2,interval) {
    var second=1000, minute=second*60, hour=minute*60, day=hour*24, week=day*7;
    date1 = new Date(date1);
    date2 = new Date(date2);
    var timediff = date2 - date1;
    if (isNaN(timediff)) return NaN;
    switch (interval) {
        case "years": return date2.getFullYear() - date1.getFullYear();
        case "months": return (
            ( date2.getFullYear() * 12 + date2.getMonth() )
            -
            ( date1.getFullYear() * 12 + date1.getMonth() )
        );
        case "weeks"  : return Math.floor(timediff / week);
        case "days"   : return Math.floor(timediff / day); 
        case "hours"  : return Math.floor(timediff / hour); 
        case "minutes": return Math.floor(timediff / minute);
        case "seconds": return Math.floor(timediff / second);
        default: return undefined;
    }
}

Comments

बुरा जवाब। Math.floor () आपको एक दिन खो देगा जब घड़ियां दिन के उजाले की बचत में आगे बढ़ेंगी। Math.round () अधिकांश स्थितियों में सही उत्तर देगा लेकिन अन्य उत्तर में भी बेहतर विकल्प हैं।

— फिल बी

Answer 4

मैं क्षण.js लाइब्रेरी ( http://momentjs.com/docs/#/displaying/difference/ ) का उपयोग करने की सलाह देता हूं । यह दिन के उजाले की बचत का समय सही ढंग से और सामान्य रूप से काम करने के लिए बहुत अच्छा है।

उदाहरण:

var start = moment("2013-11-03");
var end = moment("2013-11-04");
end.diff(start, "days")
1

Comments

बस एक चेतावनी के रूप में जबकि क्षणिकाएं महान हैं, यह काफी बड़ी निर्भरता है

— जेसन एक्सलसन

यह वास्तव में होना चाहिए end.diff(start,"days")हालांकि लिखित रूप में कोड काम करेगा क्योंकि प्रारंभ तिथि अंतिम तिथि के बाद है!

— gordon613

Answer 5

मैं आगे बढ़ूंगा और इस छोटी सी उपयोगिता को पकड़ूंगा और इसमें आपको इसके लिए कार्य मिलेंगे। यहाँ एक छोटा उदाहरण दिया गया है:

        <script type="text/javascript" src="date.js"></script>
        <script type="text/javascript">
            var minutes = 1000*60;
            var hours = minutes*60;
            var days = hours*24;

            var foo_date1 = getDateFromFormat("02/10/2009", "M/d/y");
            var foo_date2 = getDateFromFormat("02/12/2009", "M/d/y");

            var diff_date = Math.round((foo_date2 - foo_date1)/days);
            alert("Diff date is: " + diff_date );
        </script>

Answer 6

const startDate = '2017-11-08';
const endDate   = '2017-10-01';
const timeDiff  = (new Date(startDate)) - (new Date(endDate));
const days      = timeDiff / (1000 * 60 * 60 * 24)

1. प्रारंभ तिथि निर्धारित करें
2. अंतिम तिथि निर्धारित करें
3. अंतर की गणना करें
4. मिलीसेकंड को दिनों में परिवर्तित करें

अद्यतन: मुझे पता है कि यह आपके सवालों का हिस्सा नहीं है, लेकिन सामान्य तौर पर मैं वैनिला जावास्क्रिप्ट में किसी भी तारीख की गणना या हेरफेर करने की सिफारिश नहीं करूंगा, बल्कि कई किनारे के मामलों के कारण इसके लिए डेट-फेन या क्षण जैसी एक लाइब्रेरी का उपयोग करें ।

Comments

मैं इन जैसे उत्तरों की सराहना करता हूं: लघु, सरल और कोई यादृच्छिक निर्भरता की आवश्यकता नहीं है! चीयर्स।

— दाकोडा

क्या यह सिर्फ मैं है जो timeDiffनकारात्मक में लौट आया है? नहीं timeDiffहोना चाहिए (new Date(endDate)) - (new Date(startDate));?

— फेयिसायो सोनुबी

@ feyisayo-sonubi इस बात पर निर्भर करता है कि आप किस क्रम में शुरू और अंतिम तिथि से गुजरते हैं। इस उदाहरण में(new Date('2017-11-08')) - (new Date('2017-10-01')) // 3283200000

— marcobiedermann 9

const timeDiff = +(new Date(start)) - +(new Date(end));

— बेन रेसिकॉट

महान। हालाँकि मैं पसंद करता हूँreturn (Date.UTC(yr2, mo2-1, dy2) - Date.UTC(yr1, mo1-1, dy1)) / 86400000;

— dcromley

Answer 7

Moment.js का उपयोग करना

var future = moment('05/02/2015');
var start = moment('04/23/2015');
var d = future.diff(start, 'days'); // 9
console.log(d);

<script src="https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.17.1/moment-with-locales.min.js"></script>

Comments

क्षण.जैस वास्तव में YTD की तरह चीजों के लिए काम var now = moment(), yearStart = moment().startOf('year'); var ytdDays = now.diff(yearStart, 'days'); // this can be years, months, weeks, days, hours, minutes, and seconds console.log(ytdDays); करता है यहाँ अधिक मायने रखता है: momentjs.com

— शरीफ

Answer 8

जेएस में दिनांक मान डेटाइम मान हैं।

इसलिए, प्रत्यक्ष तिथि गणना असंगत है:

(2013-11-05 00:00:00) - (2013-11-04 10:10:10) < 1 day

उदाहरण के लिए हमें डी 2 तारीख बदलने की जरूरत है:

(2013-11-05 00:00:00) - (2013-11-04 00:00:00) = 1 day

विधि दोनों तिथियों में मिलों को काट सकती है:

var date1 = new Date('2013/11/04 00:00:00');
var date2 = new Date('2013/11/04 10:10:10'); //less than 1
var start = Math.floor(date1.getTime() / (3600 * 24 * 1000)); //days as integer from..
var end = Math.floor(date2.getTime() / (3600 * 24 * 1000)); //days as integer from..
var daysDiff = end - start; // exact dates
console.log(daysDiff);

date2 = new Date('2013/11/05 00:00:00'); //1

var start = Math.floor(date1.getTime() / (3600 * 24 * 1000)); //days as integer from..
var end = Math.floor(date2.getTime() / (3600 * 24 * 1000)); //days as integer from..
var daysDiff = end - start; // exact dates
console.log(daysDiff);

Answer 9

UTC समय का उपयोग करके DST, Math.ceil, Math.floor आदि से छुटकारा पाने के लिए बेहतर है:

var firstDate = Date.UTC(2015,01,2);
var secondDate = Date.UTC(2015,04,22);
var diff = Math.abs((firstDate.valueOf() 
    - secondDate.valueOf())/(24*60*60*1000));

यह उदाहरण 109 दिन का अंतर देता है। 24*60*60*1000मिलीसेकंड में एक दिन है।

Answer 10

2 दी गई तारीखों के बीच के दिनों की गणना करने के लिए आप निम्नलिखित कोड का उपयोग कर सकते हैं। मेरे द्वारा यहां उपयोग किए गए जनवरी 01 2016 और 31 दिसंबर 2016 हैं

var day_start = new Date("Jan 01 2016");
var day_end = new Date("Dec 31 2016");
var total_days = (day_end - day_start) / (1000 * 60 * 60 * 24);
document.getElementById("demo").innerHTML = Math.round(total_days);

<h3>DAYS BETWEEN GIVEN DATES</h3>
<p id="demo"></p>

Answer 11

निम्नलिखित सूत्र का उपयोग करके अलग-अलग टीके में आराम करने वाली दो तिथियों के बीच एक पूर्ण सबूत दिनों के अंतर की गणना करना संभव है:

var start = new Date('10/3/2015');
var end = new Date('11/2/2015');
var days = (end - start) / 1000 / 60 / 60 / 24;
console.log(days);
// actually its 30 ; but due to daylight savings will show 31.0xxx
// which you need to offset as below
days = days - (end.getTimezoneOffset() - start.getTimezoneOffset()) / (60 * 24);
console.log(days);

Comments

यह सबसे सही उत्तर है, आपको डीएसटी को ध्यान में रखना होगा! धन्यवाद

— Gisway

Answer 12

मुझे यह प्रश्न तब मिला जब मैं चाहता हूं कि दो तारीख को कुछ गणना करें, लेकिन तारीख में घंटे और मिनट का मूल्य है, मैंने अपनी आवश्यकता के अनुसार @ michael-liu के उत्तर को संशोधित किया और इसने मेरी परीक्षा उत्तीर्ण की।

दिन के अंतर को बराबर करना चाहिए 2012-12-31 23:00और 2013-01-01 01:001. (2 घंटे) को दिन के बराबर होना चाहिए 2012-12-31 01:00और 2013-01-01 23:001. (46 घंटे) के बराबर होना चाहिए

function treatAsUTC(date) {
    var result = new Date(date);
    result.setMinutes(result.getMinutes() - result.getTimezoneOffset());
    return result;
}

var millisecondsPerDay = 24 * 60 * 60 * 1000;
function diffDays(startDate, endDate) {
    return Math.floor(treatAsUTC(endDate) / millisecondsPerDay) - Math.floor(treatAsUTC(startDate) / millisecondsPerDay);
}

Answer 13

var start= $("#firstDate").datepicker("getDate");
var end= $("#SecondDate").datepicker("getDate");
var days = (end- start) / (1000 * 60 * 60 * 24);
 alert(Math.round(days));

jsfiddle उदाहरण :)

Answer 14

मुझे लगता है कि समाधान सही 100% मैं का प्रयोग करेंगे नहीं हैं प्लस्तर लगाना बजाय फर्श , गोल इच्छा काम है, लेकिन यह सही संचालन नहीं है।

function dateDiff(str1, str2){
    var diff = Date.parse(str2) - Date.parse(str1); 
    return isNaN(diff) ? NaN : {
        diff: diff,
        ms: Math.ceil(diff % 1000),
        s: Math.ceil(diff / 1000 % 60),
        m: Math.ceil(diff / 60000 % 60),
        h: Math.ceil(diff / 3600000 % 24),
        d: Math.ceil(diff / 86400000)
    };
}

Comments

दिन 24 घंटे से अधिक हो सकते हैं और मिनट 60 सेकंड से अधिक हो सकते हैं। इन मामलों में Math.ceil () का उपयोग करना अधिक होगा।

— रिच डफ़र्टी

Answer 15

DatePicker विजेट से formatDate का उपयोग करने के बारे में क्या ? आप इसका उपयोग टाइमस्टैम्प प्रारूप (01/01/1970 से मिलीसेकंड) में तिथियों को परिवर्तित करने के लिए कर सकते हैं और फिर एक साधारण घटाव कर सकते हैं।

Answer 16

function timeDifference(date1, date2) {
  var oneDay = 24 * 60 * 60; // hours*minutes*seconds
  var oneHour = 60 * 60; // minutes*seconds
  var oneMinute = 60; // 60 seconds
  var firstDate = date1.getTime(); // convert to milliseconds
  var secondDate = date2.getTime(); // convert to milliseconds
  var seconds = Math.round(Math.abs(firstDate - secondDate) / 1000); //calculate the diffrence in seconds
  // the difference object
  var difference = {
    "days": 0,
    "hours": 0,
    "minutes": 0,
    "seconds": 0,
  }
  //calculate all the days and substract it from the total
  while (seconds >= oneDay) {
    difference.days++;
    seconds -= oneDay;
  }
  //calculate all the remaining hours then substract it from the total
  while (seconds >= oneHour) {
    difference.hours++;
    seconds -= oneHour;
  }
  //calculate all the remaining minutes then substract it from the total 
  while (seconds >= oneMinute) {
    difference.minutes++;
    seconds -= oneMinute;
  }
  //the remaining seconds :
  difference.seconds = seconds;
  //return the difference object
  return difference;
}
console.log(timeDifference(new Date(2017,0,1,0,0,0),new Date()));

Comments

मैं आपसे अनुरोध कर सकता हूं कि कृपया अपने उत्तर के आसपास कुछ और संदर्भ जोड़ दें। कोड-केवल उत्तर समझना मुश्किल है। यह पूछने वाले और भविष्य के पाठकों दोनों की मदद करेगा यदि आप अपनी पोस्ट में अधिक जानकारी जोड़ सकते हैं।

— RBT

मैं संपादित करना चाहता था, लेकिन मुझे त्रुटियां हो रही थीं, मैं संपादन प्रस्तुत कर सकता था :(।

— नॉरडाइन बेलहडज शेख

@ N.Belhadj आप उन सभी जगह ले सकता है, जबकि सरल div और आधुनिक (%) संचालन के साथ छोरों

— Mihail Shishkov

Answer 17

यह सबसे सुरुचिपूर्ण समाधान नहीं हो सकता है, लेकिन यह अपेक्षाकृत सरल बिट कोड के साथ प्रश्न का उत्तर देता है, मुझे लगता है। आप इस तरह से कुछ का उपयोग नहीं कर सकते हैं:

function dayDiff(startdate, enddate) {
  var dayCount = 0;

  while(enddate >= startdate) {
    dayCount++;
    startdate.setDate(startdate.getDate() + 1);
  }

return dayCount; 
}

यह मान रहा है कि आप दिनांक ऑब्जेक्ट्स को पैरामीटर के रूप में पास कर रहे हैं।

Answer 18

यदि आपके पास दो यूनिक्स टाइमस्टैम्प हैं, तो आप इस फ़ंक्शन का उपयोग कर सकते हैं (स्पष्टता के लिए थोड़ी अधिक क्रिया करना):

// Calculate number of days between two unix timestamps
// ------------------------------------------------------------
var daysBetween = function(timeStampA, timeStampB) {
    var oneDay = 24 * 60 * 60 * 1000; // hours * minutes * seconds * milliseconds
    var firstDate = new Date(timeStampA * 1000);
    var secondDate = new Date(timeStampB * 1000);
    var diffDays = Math.round(Math.abs((firstDate.getTime() - secondDate.getTime())/(oneDay)));
    return diffDays;
};

उदाहरण:

daysBetween(1096580303, 1308713220); // 2455

Answer 19

मिलीसेकंड का उपयोग करते समय सावधान रहें ।

Date.getTime () मिलीसेकेंड वापस आती है और कर रही मिलीसेकेंड के साथ गणित आपरेशन शामिल करने के लिए की आवश्यकता है

• डेलाइट सेविंग टाइम (DST)
• जाँच करना कि क्या दोनों तिथियों में एक ही समय (घंटे, मिनट, सेकंड, मिलीसेकंड) है
• यह सुनिश्चित करें कि दिनों के व्यवहार में क्या अंतर है: 19 सितंबर 2016 - 29 सितंबर 2016 = 1 या 2 दिन का अंतर?

ऊपर टिप्पणी से उदाहरण मुझे अब तक मिला सबसे अच्छा समाधान है https://stackoverflow.com/a/11252167/2091095 । लेकिन यदि आप चाहते हैं कि सभी दिनों की गणना के लिए +1 का उपयोग उसके परिणाम में करें।

function treatAsUTC(date) {
    var result = new Date(date);
    result.setMinutes(result.getMinutes() - result.getTimezoneOffset());
    return result;
}

function daysBetween(startDate, endDate) {
    var millisecondsPerDay = 24 * 60 * 60 * 1000;
    return (treatAsUTC(endDate) - treatAsUTC(startDate)) / millisecondsPerDay;
}

var diff = daysBetween($('#first').val(), $('#second').val()) + 1;

Answer 20

Date.prototype.days = function(to) {
  return Math.abs(Math.floor(to.getTime() / (3600 * 24 * 1000)) - Math.floor(this.getTime() / (3600 * 24 * 1000)))
}


console.log(new Date('2014/05/20').days(new Date('2014/05/23'))); // 3 days

console.log(new Date('2014/05/23').days(new Date('2014/05/20'))); // 3 days

Answer 21

एंगुलर में मेरा भी यही मुद्दा था। मैं कॉपी करता हूं क्योंकि वह पहली तारीख को ओवरराइट कर देगा। दोनों तिथियों का समय 00:00:00 (जाहिर है) होना चाहिए

 /*
* Deze functie gebruiken we om het aantal dagen te bereken van een booking.
* */
$scope.berekenDagen = function ()
{
    $scope.booking.aantalDagen=0;

    /*De loper is gelijk aan de startdag van je reservatie.
     * De copy is nodig anders overschijft angular de booking.van.
     * */
    var loper = angular.copy($scope.booking.van);

    /*Zolang de reservatie beschikbaar is, doorloop de weekdagen van je start tot einddatum.*/
    while (loper < $scope.booking.tot) {
        /*Tel een dag op bij je loper.*/
        loper.setDate(loper.getDate() + 1);
        $scope.booking.aantalDagen++;
    }

    /*Start datum telt natuurlijk ook mee*/
    $scope.booking.aantalDagen++;
    $scope.infomsg +=" aantal dagen: "+$scope.booking.aantalDagen;
};

Answer 22

मैंने समाचार पोस्ट के लिए पोस्टिंग की कार्यक्षमता का उपयोग करने के लिए नीचे दिए गए कोड का उपयोग किया था। मैं पोस्टिंग की तारीख और वर्तमान तिथि के आधार पर मिनट या घंटे या दिन या वर्ष की गणना करता हूं।

var startDate= new Date("Mon Jan 01 2007 11:00:00");
var endDate  =new Date("Tue Jan 02 2007 12:50:00");
var timeStart = startDate.getTime();
var timeEnd = endDate.getTime();
var yearStart = startDate.getFullYear();
var yearEnd   = endDate.getFullYear();
if(yearStart == yearEnd)
 {
  var hourDiff = timeEnd - timeStart; 
  var secDiff = hourDiff / 1000;
  var minDiff = hourDiff / 60 / 1000; 
  var hDiff = hourDiff / 3600 / 1000; 
  var myObj = {};
  myObj.hours = Math.floor(hDiff);
  myObj.minutes = minDiff  
  if(myObj.hours >= 24)
   {
    console.log(Math.floor(myObj.hours/24) + "day(s) ago")
   } 
 else if(myObj.hours>0)
  {
   console.log(myObj.hours +"hour(s) ago")
  }
 else
  {
   console.log(Math.abs(myObj.minutes) +"minute(s) ago")
  }
}
else
{
var yearDiff = yearEnd - yearStart;
console.log( yearDiff +" year(s) ago");
}

Comments

कृपया अपने कोड की व्याख्या करें और आपने समस्या को हल कर दिया है, बस कोड चिपकाना एक बुरा जवाब माना जाता है।

— मार्को स्कैबियोलो जू

इस कोड को इस सवाल का जवाब कर सकते हैं, के बारे में अतिरिक्त संदर्भ प्रदान करने के लिए कैसे और / या क्यों यह हल करती है समस्या जवाब की दीर्घकालिक मूल्य में सुधार होगा।

— माइकल पार्कर

धन्यवाद @ MarcoScabbiolo, @ माइकल पार्कर टिप्पणियों के लिए। क्या मैं जवाब देने के मामले में स्टाकेवरफ्लो में नया हूं, मुझे इस बारे में जानकारी नहीं थी कि समाधान कैसे

— विभाजित

Answer 23

अगर आप चाहते हैं कि तारीख के साथ एक DateArray हो तो यह कोशिश करें:

<script>
        function getDates(startDate, stopDate) {
        var dateArray = new Array();
        var currentDate = moment(startDate);
        dateArray.push( moment(currentDate).format('L'));

        var stopDate = moment(stopDate);
        while (dateArray[dateArray.length -1] != stopDate._i) {
            dateArray.push( moment(currentDate).format('L'));
            currentDate = moment(currentDate).add(1, 'days');
        }
        return dateArray;
      }
</script>

DebugSnippet

Answer 24

दो तिथियों के बीच के दिनों की गणना करने का सरल तरीका है कि दोनों अपने समय घटक को हटा दें अर्थात घंटे, मिनट, सेकंड और मिलीसेकंड को 0 पर सेट करें और फिर अपना समय घटाएं और इसे एक दिन के मूल्य के मिलीसेकेंड के साथ डाइविंग करें।

var firstDate= new Date(firstDate.setHours(0,0,0,0));
var secondDate= new Date(secondDate.setHours(0,0,0,0));
var timeDiff = firstDate.getTime() - secondDate.getTime();
var diffDays =timeDiff / (1000 * 3600 * 24);

Comments

आपके समाधान के साथ समस्या यह है, आप फर्स्टडेट और सेकंडडेट को तिथियां मान रहे हैं, फिर उन्हें फिर से तारीख में बदलने की आवश्यकता नहीं है, और यदि वे तारीख नहीं हैं * जो नहीं हैं) तो आपको सेटहॉर्स पर त्रुटि मिलेगी। इसे ठीक करने के लिए, आपको setHours से बाहर निकलने की जरूरत हैnew Date

— AaA

Answer 25

function formatDate(seconds, dictionary) {
    var foo = new Date;
    var unixtime_ms = foo.getTime();
    var unixtime = parseInt(unixtime_ms / 1000);
    var diff = unixtime - seconds;
    var display_date;
    if (diff <= 0) {
        display_date = dictionary.now;
    } else if (diff < 60) {
        if (diff == 1) {
            display_date = diff + ' ' + dictionary.second;
        } else {
            display_date = diff + ' ' + dictionary.seconds;
        }
    } else if (diff < 3540) {
        diff = Math.round(diff / 60);
        if (diff == 1) {
            display_date = diff + ' ' + dictionary.minute;
        } else {
            display_date = diff + ' ' + dictionary.minutes;
        }
    } else if (diff < 82800) {
        diff = Math.round(diff / 3600);
        if (diff == 1) {
            display_date = diff + ' ' + dictionary.hour;
        } else {
            display_date = diff + ' ' + dictionary.hours;
        }
    } else {
        diff = Math.round(diff / 86400);
        if (diff == 1) {
            display_date = diff + ' ' + dictionary.day;
        } else {
            display_date = diff + ' ' + dictionary.days;
        }
    }
    return display_date;
}

Answer 26

सरल आसान और परिष्कृत। यह फ़ंक्शन अपडेट करने के लिए हर 1 सेकंड में कॉल किया जाएगा।

const year = (new Date().getFullYear());
const bdayDate = new Date("04,11,2019").getTime();  //mmddyyyy

// countdown
let timer = setInterval(function() {

// get today's date
const today = new Date().getTime();

// get the difference
const diff = bdayDate - today;

// math
let days = Math.floor(diff / (1000 * 60 * 60 * 24));
let hours = Math.floor((diff % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60));
let minutes = Math.floor((diff % (1000 * 60 * 60)) / (1000 * 60));
let seconds = Math.floor((diff % (1000 * 60)) / 1000);

}, 1000);

Answer 27

इससे बेहतर उपाय

समय भाग की अनदेखी

यदि दोनों तिथियां समान हैं तो यह 0 पर वापस आ जाएगी।

function dayDiff(firstDate, secondDate) {
  firstDate = new Date(firstDate);
  secondDate = new Date(secondDate);
  if (!isNaN(firstDate) && !isNaN(secondDate)) {
    firstDate.setHours(0, 0, 0, 0); //ignore time part
    secondDate.setHours(0, 0, 0, 0); //ignore time part
    var dayDiff = secondDate - firstDate;
    dayDiff = dayDiff / 86400000; // divide by milisec in one day
    console.log(dayDiff);
  } else {
    console.log("Enter valid date.");
  }
}

$(document).ready(function() {
  $('input[type=datetime]').datepicker({
    dateFormat: "mm/dd/yy",
    changeMonth: true,
    changeYear: true
  });
  $("#button").click(function() {
    dayDiff($('#first').val(), $('#second').val());
  });
});

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" href="//code.jquery.com/ui/1.12.1/themes/base/jquery-ui.css">
<script src="//code.jquery.com/ui/1.12.1/jquery-ui.js"></script>

<input type="datetime" id="first" value="12/28/2016" />
<input type="datetime" id="second" value="12/28/2017" />
<input type="button" id="button" value="Calculate">

Answer 28

एक योगदान, 1970-01-01 से पहले और 2038-01-19 के बाद की तारीख के लिए

function DateDiff(aDate1, aDate2) {
  let dDay = 0;
  this.isBissexto = (aYear) => {
    return (aYear % 4 == 0 && aYear % 100 != 0) || (aYear % 400 == 0);
  };
  this.getDayOfYear = (aDate) => {
    let count = 0;
    for (let m = 0; m < aDate.getUTCMonth(); m++) {
      count += m == 1 ? this.isBissexto(aDate.getUTCFullYear()) ? 29 : 28 : /(3|5|8|10)/.test(m) ? 30 : 31;
    }
    count += aDate.getUTCDate();
    return count;
  };
  this.toDays = () => {
    return dDay;
  };
  (() => {
    let startDate = aDate1.getTime() <= aDate2.getTime() ? new Date(aDate1.toISOString()) : new Date(aDate2.toISOString());
    let endDate = aDate1.getTime() <= aDate2.getTime() ? new Date(aDate2.toISOString()) : new Date(aDate1.toISOString());
    while (startDate.getUTCFullYear() != endDate.getUTCFullYear()) {
      dDay += (this.isBissexto(startDate.getFullYear())? 366 : 365) - this.getDayOfYear(startDate) + 1;
      startDate = new Date(startDate.getUTCFullYear()+1, 0, 1);
    }
    dDay += this.getDayOfYear(endDate) - this.getDayOfYear(startDate);
  })();
}

Answer 29

   function validateDate() {
        // get dates from input fields
        var startDate = $("#startDate").val();
        var endDate = $("#endDate").val();
        var sdate = startDate.split("-");
        var edate = endDate.split("-");
        var diffd = (edate[2] - sdate[2]) + 1;
        var leap = [ 0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 ];
        var nonleap = [ 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 ];
        if (sdate[0] > edate[0]) {
            alert("Please enter End Date Year greater than Start Date Year");
            document.getElementById("endDate").value = "";
            diffd = "";
        } else if (sdate[1] > edate[1]) {
            alert("Please enter End Date month greater than Start Date month");
            document.getElementById("endDate").value = "";
            diffd = "";
        } else if (sdate[2] > edate[2]) {
            alert("Please enter End Date greater than Start Date");
            document.getElementById("endDate").value = "";
            diffd = "";
        } else {
            if (sdate[0] / 4 == 0) {
                while (sdate[1] < edate[1]) {
                    diffd = diffd + leap[sdate[1]++];
                }
            } else {
                while (sdate[1] < edate[1]) {
                    diffd = diffd + nonleap[sdate[1]++];
                }
            }
            document.getElementById("numberOfDays").value = diffd;
        }
    }

Answer 30

अंतर स्वरूपण और गणना के लिए आप UnderscoreJS का उपयोग कर सकते हैं।

डेमो https://jsfiddle.net/sumitridhal/8sv94msp/

 var startDate = moment("2016-08-29T23:35:01");
var endDate = moment("2016-08-30T23:35:01");  
  

console.log(startDate);
console.log(endDate);

var resultHours = endDate.diff(startDate, 'hours', true);

document.body.innerHTML = "";
document.body.appendChild(document.createTextNode(resultHours));

body { white-space: pre; font-family: monospace; }

<script src="https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.5.1/moment.min.js"></script>