javascript - जावा स्क्रिप्ट इन हिंदी




जावास्क्रिप्ट में दिनांक अंतर(दिन के समय को अनदेखा करना) (10)

+ ऊपर दिए गए उदाहरण को यूटीसी कन्स्ट्रक्टर का उपयोग करता है। ऐसा करने के बिना, आपको डेलाइट सेविंग्स / ग्रीष्मकालीन घंटे से घिरा जाएगा।

यदि आप उनमें से कुछ में मतभेद लेते हैं, तो यह आपके समय क्षेत्र के लिए एक दिशा में डीएसटी लाइन को पार करते समय एक घंटे छोटा हो सकता है (वसंत-आगे, फरवरी में अर्थ अप्रैल के लिए पूछना, उदाहरण के लिए)। जब आप एन +23 / 24 मंजिल करते हैं, तो आप एन के साथ समाप्त हो जाएंगे।

दूसरी दिशा (अक्टूबर में दिसंबर के लिए पूछना) ठीक होना चाहिए, आप एक घंटा आगे बढ़ेंगे जो मंजिल () सही ढंग से सौदा करेगा।

मैं एक उपकरण किराए पर लेने का आवेदन लिख रहा हूं जहां ग्राहकों को किराए पर लेने की अवधि (दिनों में) के आधार पर उपकरण किराए पर लेने के लिए शुल्क लिया जाता है। तो, मूल रूप से, (दैनिक शुल्क * दिनों की संख्या) = कुल शुल्क।

क्लाइंट साइड पर तत्काल प्रतिक्रिया के लिए, मैं दो कैलेंडर तिथियों में अंतर जानने के लिए जावास्क्रिप्ट का उपयोग करने की कोशिश कर रहा हूं। मैंने चारों ओर खोज की है, लेकिन मुझे जो कुछ भी मिला है वह काफी है जो मैं ढूंढ रहा हूं। मैंने देखा है कि ज्यादातर समाधान फार्म के हैं:

function dateDiff1(startDate, endDate) {
    return ((endDate.getTime() - startDate.getTime()) / 1000*60*60*24);
}

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

उदाहरण के लिए, अगर किसी ने 6 जुलाई को 6 बजे उपकरण की जांच की और इसे 7 जुलाई को 10 बजे वापस कर दिया, तो उपर्युक्त कोड गणना करेगा कि एक से अधिक 24 घंटे की अवधि बीत चुकी है, और वापस आ जाएगी 2. वांछित परिणाम 1 है, केवल इसलिए एक कैलेंडर तिथि समाप्त हो गई है (यानी 6 वें से 7 वें)।

मैंने पाया सबसे नज़दीकी समाधान यह कार्य है:

function dateDiff2(startDate, endDate) {
    return endDate.getDate() - startDate.getDate();
}

जो वही करता है जो मैं चाहता हूं, जब तक कि दो तिथियां एक ही महीने के भीतर हों। हालांकि, चूंकि GetDate () केवल महीने का दिन (यानी 1-31) लौटाता है, यह तब काम नहीं करता है जब तिथियां कई महीनों तक फैली होती हैं (उदाहरण के लिए 31 जुलाई से 1 अगस्त 1 दिन है, लेकिन उपरोक्त कैलक्यूट 1 - 31, या -29)।

बैकएंड पर, PHP में, मैं gregoriantojd () का उपयोग कर रहा हूं, जो ठीक काम करता प्रतीत होता है (उदाहरण के लिए यह पोस्ट देखें)। मुझे जावास्क्रिप्ट में समकक्ष समाधान नहीं मिल रहा है।

क्या किसी के भी पास कोई सुझाव है?


Date.js की आवश्यकता है, http://code.google.com/p/datejs/

फ़ंक्शन की गणना अवधि (स्टार्टडेट, एंडडेट) {

var sdt = Date.parse(startDate);
var edt = Date.parse(endDate);

var sdtYear = sdt.getYear();
var edtYear = edt.getYear();
var sdtMonth = sdt.getMonth();
var edtMonth = edt.getMonth();
var sdtDay = sdt.getDate();
var edtDay = edt.getDate();

var StartDateMonthDays = Date.getDaysInMonth(sdtYear, sdtMonth);
var EndDateMonthDays = Date.getDaysInMonth(edtYear, edtMonth);

if (edtMonth < sdtMonth) { //Means the ending month is earlier, which invalidates the operation

    alert("Ending month cannot be earlier than the starting month")

}

//Months are equal, if month is the next month of the start date month, 
//the operation fails, thus we need to calculate month difference first
else if (edtMonth > sdtMonth) {

    //Need to count how many days are left to finish the month
    var daysToMonthFinish = StartDateMonthDays - sdtDay;
    var calculatedDuration = daysToMonthFinish + edtDay;
    $("#hdn_duration").val(calculatedDuration);

}
//If months are the same, it is safe to just calculate the end day minus the start day
else {

    var calcDuration = edtDay - sdtDay;
    $("#hdn_duration").val(calcDuration);
}

आप उसी दिन की आधी रात को प्रारंभ तिथि समायोजित कर सकते हैं, फिर तिथियों के बीच 24 घंटे की अवधि की गणना करें। फिर, आप उस दिन की छत या मंजिल लेंगे, इस पर निर्भर करता है कि आप दिन के किसी भी हिस्से को पूरे दिन के रूप में गिनना चाहते हैं या नहीं।

function dateDiff(startDate, endDate) {
    // set startDate to the beginning of the day
    startDate = new Date(
        startDate.getFullYear(),
        startDate.getMonth(),
        startDate.getDate());

    return Math.floor((endDate - startDate) / 1000*60*60*24);
}

चूंकि जूलियन दिवस प्रभावी रूप से एक निश्चित तारीख के बाद दिनों की संख्या (और कुछ मामलों में भी दिनों की संख्या का अंश) है, यह वास्तव में यूनिक्स टाइमस्टैम्प के समान ही है, जो अलग-अलग प्रस्तुत किया गया है। 1 9 70 से आप पूरे दिन की संख्या प्राप्त कर सकते हैं:

Date.prototype.getWholeDays = function () {
    return Math.floor(new Date() / 1000*60*60*24);
};

function dateDiff(startDate, endDate) {
    return endDate.getWholeDays() - startDate.getWholeDays();
}

दिए गए समाधानों में एक बग है!

यह तिथि मतभेदों पर लागू होता है जहां समय की अवहेलना होती है और आप एक पूर्णांक परिणाम चाहते हैं, यानी, पूरे दिनों की संख्या।

ऊपर दिए गए कई उदाहरणों में हम Math.floor अन्य उदाहरण देखते हैं, मैंने Math.ceil अन्य स्थानों को भी देखा है। ये परिणामों को एक पूर्णांक संख्या के दौर के दौर के लिए किया जाता है। समस्या यह है कि डेलाइट बचत समय Math.ceil का उपयोग करके गिरावट में गलत परिणाम देगा - आपका परिणाम एक दिन बहुत बड़ा होगा या वसंत ऋतु में यदि आप Math.floor का उपयोग करते हैं तो आप एक दिन से बहुत कम हो जाएंगे। बस Math.round का उपयोग करें क्योंकि 1 घंटे या तो परिणाम नतीजा नहीं जा रहा है।

function dateDiff(dateEarlier, dateLater) {
    var one_day=1000*60*60*24
    return (  Math.round((dateLater.getTime()-dateEarlier.getTime())/one_day)  );
}

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


मुझे पता है कि यह आंशिक समाधान है लेकिन आप तिथियों के बीच के दिनों को प्राप्त करने में सक्षम हो सकते हैं (जब तक तिथियों में समय निर्धारित नहीं होता है)। फिर आप वहां से काम कर सकते हैं।

मैं आपके द्वारा प्रस्तुत की गई समस्या के साथ इस समाधान का आधार बना रहा हूं ((दैनिक शुल्क * दिनों की संख्या) = कुल शुल्क); वास्तविक तिथि अंतर सवाल नहीं। यह आपकी मदद करनी चाहिए।

var Main = function() {
    var startDate = new Date('08/20/2014');
    var endDate = new Date('08/22/2014');
    var totalCharge = monthlyFee * daysBetween(startDate, endDate);
}

var daysBetween = function(startDate, endDate) {
    return Math.round(Math.abs((startDate.getTime() - endDate.getTime())/(24*60*60*1000)));
};

मैं अविश्वसनीय moment.js लाइब्रेरी को देखने का भी सुझाव moment.js । इसमें एक बहुमुखी diff फ़ंक्शन है, जिसका उपयोग आप उपरोक्त उदाहरण को हल करने के लिए कर सकते हैं:

function is_same_date(startDate, endDate) {
   var startMoment = moment(startDate).clone().startOf('day'),
       endMoment = moment(endDate).clone().startOf('day');
   return startMoment.diff(endMoment, 'days') == 0;
}

moment.js diff का उपयोग कर कुछ उदाहरण यहां दिए गए हैं:

> d1 = new Date(2012,04,04,0,0)
Fri May 04 2012 00:00:00 GMT-0400 (EDT)

> d2 = new Date(2012,04,03,23,0)
Thu May 03 2012 23:00:00 GMT-0400 (EDT)

> d3 = new Date(2012,04,05,23,0)
Sat May 05 2012 23:00:00 GMT-0400 (EDT)

> moment(d2).diff(d1, 'days')
0

> moment(d1).diff(d2, 'days')
0

> moment(d1).diff(d3, 'days') // uh oh. this is why we use `startOf`
-2

> moment(d2).diff(d3, 'days')
-2

> moment(d3).startOf('day') // this modified d3, sets the time to 00:00:00.0000
> d3
Sat May 05 2012 00:00:00 GMT-0400 (EDT)

यदि moment.utc() चिंता का विषय है, तो आप सामान्यीकृत moment.utc() कनवर्ट करने के लिए moment.utc() का भी उपयोग कर सकते हैं।


मैं दिनांकित फ़ंक्शन का परिणाम जांचता था जो 18 वीं शताब्दी के लिए एक्सेल के साथ .getTime () का उपयोग करता है। परिणाम सही देता है। मेरे पास अलग-अलग दिनों की गणना करने का एक और तरीका है:

    function DaysOfYear(nYear) {
        if ((nYear % 4) == 0) {
            return 366;
        }
        else {
            return 365;
        }
    }


    function DiffDays(fDate, tDate) {
        var fYear = fDate.getFullYear();
        var tYear = tDate.getFullYear();
        var fMonth = fDate.getMonth();
        var tMonth = tDate.getMonth();
        var fDay = fDate.getDate();
        var tDay = tDate.getDate();
        var nDays = 0;

        if (tYear > fYear) {   // different year
            // remain days of from year
            nDays = DaysOfYear(fYear) - YTD_Days(fDate);
            // days of between fYear to tYear
            for (y = (fYear + 1); y < tYear; y++) {
                nDays = nDays + DaysOfYear(y);
            }
            // days from the beginning of tYear
            nDays = nDays + YTD_Days(tDate);
        }
        else {   // in the same year
            nDays = YTD_Days(tDate) - YTD_Days(fDate);
        };
        return nDays;
    }

    function YTD_Days(dDate) {
        var y = dDate.getFullYear();
        var m = dDate.getMonth();
        var nDays = 0

        for (i = 0; i < m; i++) {
            switch (i) {
                case 0:     // January
                    nDays = nDays + 31;
                    break;
                case 1:     // February
                    if ((y % 4) == 0) {
                        nDays = nDays + 29;
                    }
                    else {
                        nDays = nDays + 28;
                    };
                    break;
                case 2:     // March
                    nDays = nDays + 31;
                    break;
                case 3:     // April
                    nDays = nDays + 30;
                    break;
                case 4:     // May
                    nDays = nDays + 31;
                    break;
                case 5:     // June
                    nDays = nDays + 30;
                    break;
                case 6:     // July
                    nDays = nDays + 31;
                    break;
                case 7:     // August
                    nDays = nDays + 31;
                    break;
                case 8:     // September
                    nDays = nDays + 30;
                    break;
                case 9:     // October
                    nDays = nDays + 31;
                    break;
                case 10:     // November
                    nDays = nDays + 30;
                    break;
                case 11:     // December
                    nDays = nDays + 31;
                    break;
            }
        }
        nDays = nDays + dDate.getDate();
        return nDays;
    }

यदि आप अपने छात्र कैमरे के किराये के उदाहरण के लिए पूरे दिन चाहते हैं ...

function daysBetween(first, second) {

    // Copy date parts of the timestamps, discarding the time parts.
    var one = new Date(first.getFullYear(), first.getMonth(), first.getDate());
    var two = new Date(second.getFullYear(), second.getMonth(), second.getDate());

    // Do the math.
    var millisecondsPerDay = 1000 * 60 * 60 * 24;
    var millisBetween = two.getTime() - one.getTime();
    var days = millisBetween / millisecondsPerDay;

    // Round down.
    return Math.floor(days);
}





date