javascript जावास्क्रिप्ट के साथ दो तिथियों की तुलना करें




date datetime (24)

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


संक्षिप्त जवाब

यहां एक ऐसा फ़ंक्शन है जो {Boolean} को वापस कर देता है यदि तिथि से दिनांक> तिथि तक समय डेमो कार्रवाई में

var from = '08/19/2013 00:00'
var to = '08/12/2013 00:00 '

function isFromBiggerThanTo(dtmfrom, dtmto){
   return new Date(dtmfrom).getTime() >=  new Date(dtmto).getTime() ;
}
console.log(isFromBiggerThanTo(from, to)); //true

व्याख्या

jsFiddle

var date_one = '2013-07-29 01:50:00',
date_two = '2013-07-29 02:50:00';
//getTime() returns the number of milliseconds since 01.01.1970.
var timeStamp_date_one = new Date(date_one).getTime() ; //1375077000000 
console.log(typeof timeStamp_date_one);//number 
var timeStamp_date_two = new Date(date_two).getTime() ;//1375080600000 
console.log(typeof timeStamp_date_two);//number 

चूंकि अब आप दोनों प्रकार के डेटाटाइम में हैं, आप किसी भी तुलना ऑपरेशन के साथ उनकी तुलना कर सकते हैं

(>, <, =,! =, ==,! ==,> = और <=)

फिर

यदि आप C# कस्टम डेट और टाइम फॉर्मेट स्ट्रिंग से परिचित हैं, तो इस लाइब्रेरी को एक ही चीज़ करना चाहिए और आपको अपनी तिथि और समय dtmFRM करने में मदद करना चाहिए dtmFRM चाहे आप डेट टाइम स्ट्रिंग या यूनिक्स प्रारूप में गुज़र रहे हों

प्रयोग

var myDateTime = new dtmFRM();

alert(myDateTime.ToString(1375077000000, "MM/dd/yyyy hh:mm:ss ampm"));
//07/29/2013 01:50:00 AM

alert(myDateTime.ToString(1375077000000,"the year is yyyy and the day is dddd"));
//this year is 2013 and the day is Monday

alert(myDateTime.ToString('1/21/2014', "this month is MMMM and the day is dd"));
//this month is january and the day is 21

DEMO

आपको बस लाइब्रेरी js फ़ाइल में चुने गए इन प्रारूपों में से कोई भी पास करना है


संबंधपरक ऑपरेटरों < <= > >= जावास्क्रिप्ट तिथियों की तुलना करने के लिए उपयोग किया जा सकता है:

var d1 = new Date(2013, 0, 1);
var d2 = new Date(2013, 0, 2);
d1 <  d2; // true
d1 <= d2; // true
d1 >  d2; // false
d1 >= d2; // false

हालांकि, समानता ऑपरेटरों == != === !== उपयोग दिनांक (मान के) की तुलना करने के लिए नहीं किया जा सकता है because :

  • सख्त या अमूर्त तुलना के लिए दो अलग-अलग वस्तुएं कभी बराबर नहीं होती हैं।
  • ऑब्जेक्ट्स की तुलना में एक अभिव्यक्ति केवल तभी सत्य होती है जब ऑपरेंड एक ही ऑब्जेक्ट को संदर्भित करता है।

आप इनमें से किसी भी विधि का उपयोग करके समानता के लिए तिथियों के मूल्य की तुलना कर सकते हैं:

var d1 = new Date(2013, 0, 1);
var d2 = new Date(2013, 0, 1);
/*
 * note: d1 == d2 returns false as described above
 */
d1.getTime() == d2.getTime(); // true
d1.valueOf() == d2.valueOf(); // true
Number(d1)   == Number(d2);   // true
+d1          == +d2;          // true

Date.valueOf() Date.getTime() और Date.valueOf() दोनों जनवरी 1, 1 9 70, 00:00 यूटीसी के बाद मिलीसेकंड की संख्या लौटाते हैं। दोनों Number फ़ंक्शन और यूनरी + ऑपरेटर दृश्यों के पीछे valueOf() विधियों को कॉल करते हैं।


जावास्क्रिप्ट में तिथियों की तुलना करना काफी आसान है ... जावास्क्रिप्ट ने तिथियों के लिए तुलनात्मक तुलना प्रणाली बनाई है जो तुलना करने के लिए इतना आसान बनाता है ...

बस 2 दिनांक मान की तुलना करने के लिए इन चरणों का पालन करें, उदाहरण के लिए आपके पास 2 इनपुट हैं जिनमें प्रत्येक के पास String में दिनांक मान है और आप उनकी तुलना करने के लिए ...

1. आपके पास इनपुट से प्राप्त 2 स्ट्रिंग मान हैं और आप उनकी तुलना करना चाहते हैं, वे नीचे दिए गए हैं:

var date1 = '01/12/2018';
var date2 = '12/12/2018';

2. उन्हें तिथि मान के रूप में तुलना करने के लिए Date Object होने की आवश्यकता है, इसलिए new Date() का उपयोग करके उन्हें बस तारीख में रूपांतरित करें, मैं उन्हें स्पष्टीकरण की सादगी के लिए फिर से असाइन करें, लेकिन आप इसे वैसे भी कर सकते हैं:

date1 = new Date(date1);
date2 = new Date(date2);

3. अब बस < >= <= का उपयोग करके उनकी तुलना करें

date1 > date2;  //false
date1 < date2;  //true
date1 >= date2; //false
date1 <= date2; //true


var curDate=new Date();
var startDate=document.forms[0].m_strStartDate;

var endDate=document.forms[0].m_strEndDate;
var startDateVal=startDate.value.split('-');
var endDateVal=endDate.value.split('-');
var firstDate=new Date();
firstDate.setFullYear(startDateVal[2], (startDateVal[1] - 1), startDateVal[0]);

var secondDate=new Date();
secondDate.setFullYear(endDateVal[2], (endDateVal[1] - 1), endDateVal[0]);
if(firstDate > curDate) {
    alert("Start date cannot be greater than current date!");
    return false;
}
if (firstDate > secondDate) {
    alert("Start date cannot be greater!");
    return false;
}

var date = new Date(); // will give you todays date.

// following calls, will let you set new dates.
setDate()   
setFullYear()   
setHours()  
setMilliseconds()   
setMinutes()    
setMonth()  
setSeconds()    
setTime()

var yesterday = new Date();
yesterday.setDate(...date info here);

if(date>yesterday)  // will compare dates

दो तारीखों की तुलना करने के लिए हम date.js जावास्क्रिप्ट लाइब्रेरी का उपयोग कर सकते हैं जो यहां पाया जा सकता है: https://code.google.com/archive/p/datejs/downloads

और Date.compare( Date date1, Date date2 ) विधि का उपयोग करें और यह एक संख्या लौटाता है जिसका अर्थ निम्न परिणाम है:

-1 = date1 lessthan date2 है।

0 = मान बराबर हैं।

1 = date1 अधिक तारीख 2 है।


डेट ऑब्जेक्ट वह करेगा जो आप चाहते हैं - प्रत्येक दिनांक के लिए एक का निर्माण करें, फिर > , < , <= या >= का उपयोग करके उनकी तुलना करें।

== != , === , और !== ऑपरेटरों के लिए आपको date.getTime() का उपयोग करने की आवश्यकता है

var d1 = new Date();
var d2 = new Date(d1);
var same = d1.getTime() === d2.getTime();
var notSame = d1.getTime() !== d2.getTime();

स्पष्ट रूप से डेटा ऑब्जेक्ट्स के साथ समानता की जांच करना स्पष्ट नहीं होगा

var d1 = new Date();
var d2 = new Date(d1);

console.log(d1 == d2);   // prints false (wrong!) 
console.log(d1 === d2);  // prints false (wrong!)
console.log(d1 != d2);   // prints true  (wrong!)
console.log(d1 !== d2);  // prints true  (wrong!)
console.log(d1.getTime() === d2.getTime()); // prints true (correct)

मेरा सुझाव है कि आप टेक्स्ट बॉक्स के बजाय ड्रॉप-डाउन या डेट एंट्री के कुछ समान बाधित फॉर्म का उपयोग करें, हालांकि, आप खुद को इनपुट सत्यापन नरक में नहीं पाते हैं।


function datesEqual(a, b)
{
   return (!(a>b || b>a))
}

मैं आमतौर पर डेटाबेस में डेटाबेस में timestamps(Number) रूप में स्टोर करता हूं।

जब मुझे तुलना करने की आवश्यकता होती है, तो मैं बस उन टाइमस्टैम्प के बीच तुलना करता हूं या

इसे तिथि ऑब्जेक्ट में कनवर्ट करें और फिर > < यदि आवश्यक हो तो इसकी तुलना करें।

ध्यान दें कि == या === ठीक से काम नहीं करता है जब तक कि आपके चर एक ही दिनांक वस्तु के संदर्भ न हों।

उन दिनांक वस्तुओं को पहले टाइमस्टैंप (संख्या) में कनवर्ट करें और फिर उनकी समानता की तुलना करें।

टाइमस्टैम्प की तिथि

var timestamp_1970 = new Date(0).getTime(); // 1970-01-01 00:00:00
var timestamp = new Date().getTime(); // Current Timestamp

तिथि के लिए टाइमस्टैंप

var timestamp = 0; // 1970-01-01 00:00:00
var DateObject = new Date(timestamp);

Moment.js माध्यम से

जेएसफ़िल्ड: http://jsfiddle.net/guhokemk/1/

function compare(dateTimeA, dateTimeB) {
    var momentA = moment(dateTimeA,"DD/MM/YYYY");
    var momentB = moment(dateTimeB,"DD/MM/YYYY");
    if (momentA > momentB) return 1;
    else if (momentA < momentB) return -1;
    else return 0;
}

alert(compare("11/07/2015", "10/07/2015"));

विधि dateTimeA 1 देता है यदि dateTimeA से अधिक है

विधि dateTimeA 0 देता है यदि dateTimeA बराबर है

विधि 1 लौटाती है यदि dateTimeA से कम है


Dates ऑब्जेक्ट की तुलना करने से पहले, उनके दोनों मिलीसेकंड्स को Date.setMilliseconds(0); तरह शून्य पर सेट करने का प्रयास करें Date.setMilliseconds(0);

कुछ मामलों में जहां Date ऑब्जेक्ट जावास्क्रिप्ट में गतिशील रूप से बनाया गया है, यदि आप Date.getTime() प्रिंट करते रहते हैं, तो आप मिलीसेकंड बदलते देखेंगे, जो दोनों तिथियों की समानता को रोक देगा।


मान लें कि आपको तिथि ऑब्जेक्ट ए और बी मिल गया है, अपने ईपीओसी समय मान प्राप्त करें, फिर मिलीसेकंड में अंतर प्राप्त करने के लिए घटाएं।

var diff = +A - +B;

बस इतना ही।


< और > सामान्य की तरह तुलना करें, लेकिन इसमें शामिल कुछ भी = एक उपसर्ग का उपयोग करना चाहिए। इस तरह:

var x = new Date('2013-05-23');
var y = new Date('2013-05-23');

// less than, greater than is fine:
x < y; => false
x > y; => false
x === y; => false, oops!

// anything involving '=' should use the '+' prefix
// it will then compare the dates' millisecond values
+x <= +y;  => true
+x >= +y;  => true
+x === +y; => true

उम्मीद है की यह मदद करेगा!


क्या प्रारूप?

यदि आप जावास्क्रिप्ट दिनांक ऑब्जेक्ट बनाते हैं, तो आप उन्हें मिलीसेकंड अंतर प्राप्त करने के लिए केवल घटा सकते हैं (संपादित करें: या बस उनकी तुलना करें):

js>t1 = new Date()
Thu Jan 29 2009 14:19:28 GMT-0500 (Eastern Standard Time)
js>t2 = new Date()
Thu Jan 29 2009 14:19:31 GMT-0500 (Eastern Standard Time)
js>t2-t1
2672
js>t3 = new Date('2009 Jan 1')
Thu Jan 01 2009 00:00:00 GMT-0500 (Eastern Standard Time)
js>t1-t3
2470768442
js>t1>t3
true

"कुछ" द्वारा पोस्ट किए गए कोड का एक बेहतर संस्करण

/* Compare the current date against another date.
 *
 * @param b  {Date} the other date
 * @returns   -1 : if this < b
 *             0 : if this === b
 *             1 : if this > b
 *            NaN : if a or b is an illegal date
*/ 
Date.prototype.compare = function(b) {
  if (b.constructor !== Date) {
    throw "invalid_date";
  }

 return (isFinite(this.valueOf()) && isFinite(b.valueOf()) ? 
          (this>b)-(this<b) : NaN 
        );
};

उपयोग:

  var a = new Date(2011, 1-1, 1);
  var b = new Date(2011, 1-1, 1);
  var c = new Date(2011, 1-1, 31);
  var d = new Date(2011, 1-1, 31);

  assertEquals( 0, a.compare(b));
  assertEquals( 0, b.compare(a));
  assertEquals(-1, a.compare(c));
  assertEquals( 1, c.compare(a));

        from_date ='10-07-2012';
        to_date = '05-05-2012';
        var fromdate = from_date.split('-');
        from_date = new Date();
        from_date.setFullYear(fromdate[2],fromdate[1]-1,fromdate[0]);
        var todate = to_date.split('-');
        to_date = new Date();
        to_date.setFullYear(todate[2],todate[1]-1,todate[0]);
        if (from_date > to_date ) 
        {
            alert("Invalid Date Range!\nStart Date cannot be after End Date!")

            return false;
        }

जावास्क्रिप्ट का उपयोग कर तारीख की तुलना करने के लिए इस कोड का प्रयोग करें।

धन्यवाद डी। जीवा


अब तक का सबसे आसान तरीका दूसरे से एक तारीख घटाना और परिणाम की तुलना करना है।

var oDateOne = new Date();
var oDateTwo = new Date();

alert(oDateOne - oDateTwo === 0);
alert(oDateOne - oDateTwo < 0);
alert(oDateOne - oDateTwo > 0);

var date_today=new Date();
var formated_date = formatDate(date_today);//Calling formatDate Function

var input_date="2015/04/22 11:12 AM";

var currentDateTime = new Date(Date.parse(formated_date));
var inputDateTime   = new Date(Date.parse(input_date));

if (inputDateTime <= currentDateTime){
    //Do something...
}

function formatDate(date) {
    var hours = date.getHours();
    var minutes = date.getMinutes();
    var ampm = hours >= 12 ? 'PM' : 'AM';

    hours = hours % 12;
    hours = hours ? hours : 12; // the hour '0' should be '12'
    hours   = hours < 10 ? '0'+hours : hours ;

    minutes = minutes < 10 ? '0'+minutes : minutes;

    var strTime = hours+":"+minutes+ ' ' + ampm;
    return  date.getFullYear()+ "/" + ((date.getMonth()+1) < 10 ? "0"+(date.getMonth()+1) :
    (date.getMonth()+1) ) + "/" + (date.getDate() < 10 ? "0"+date.getDate() :
    date.getDate()) + " " + strTime;
}

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

आप Date.parse () का उपयोग कर सकते हैं जो मुफ्त टेक्स्ट लेता है इसे एक नई तारीख में बदलने की कोशिश करता है लेकिन यदि आपके पास पृष्ठ पर नियंत्रण है तो मैं इसके बजाय एचटीएमएल चयन बॉक्स या यूआईआई कैलेंडर नियंत्रण या jQuery यूआई जैसे डेट पिकर का उपयोग करने की सलाह दूंगा डेटपिकर

एक बार जब आपके पास एक तिथि हो, जैसा कि अन्य लोगों ने इंगित किया है कि आप तारीखों को घटाने के लिए सरल अंकगणित का उपयोग कर सकते हैं और दिन में सेकंड की संख्या (सेकंड * 60 * *) को विभाजित करके इसे कई दिनों में परिवर्तित कर सकते हैं (60 * 60 * 24 = 86400)।


जावास्क्रिप्ट में तिथियों की तुलना करने का सबसे आसान तरीका यह है कि इसे पहले दिनांक वस्तु में परिवर्तित करें और फिर इन दिनांक-वस्तुओं की तुलना करें।

नीचे आपको तीन कार्यों के साथ एक वस्तु मिलती है:

  • dates.compare (क, ख)

    एक संख्या देता है:

    • -1 अगर एक <बी
    • 0 अगर ए = बी
    • 1 अगर ए> बी
    • NaN अगर ए या बी एक अवैध तारीख है
  • तिथियां.in श्रेणी (डी, शुरू, अंत)

    एक बुलियन या NaN देता है:

    • सच है अगर डी प्रारंभ और अंत (समावेशी) के बीच है
    • झूठ अगर डी शुरू से पहले या अंत के बाद है।
    • NaN यदि एक या अधिक तिथियां अवैध हैं।
  • dates.convert

    अपने इनपुट को डेट ऑब्जेक्ट में कनवर्ट करने के लिए अन्य कार्यों द्वारा उपयोग किया जाता है। इनपुट हो सकता है

    • एक तिथि- वस्तु: इनपुट के रूप में वापस आ गया है।
    • एक सरणी : [वर्ष, महीना, दिन] के रूप में व्याख्या की गई। नोट महीने 0-11 है।
    • एक संख्या : 1 जनवरी 1 9 70 से मिलीसेकंड की संख्या के रूप में व्याख्या (एक टाइमस्टैम्प)
    • एक स्ट्रिंग : कई अलग-अलग प्रारूप समर्थित हैं, जैसे "YYYY / MM / DD", "MM / DD / YYYY", "31 जनवरी 200 9" आदि।
    • एक वस्तु : वर्ष, महीने और दिनांक विशेषताओं के साथ किसी ऑब्जेक्ट के रूप में व्याख्या की गई। नोट महीने 0-11 है।

// Source: http://.com/questions/497790
var dates = {
    convert:function(d) {
        // Converts the date in d to a date-object. The input can be:
        //   a date object: returned without modification
        //  an array      : Interpreted as [year,month,day]. NOTE: month is 0-11.
        //   a number     : Interpreted as number of milliseconds
        //                  since 1 Jan 1970 (a timestamp) 
        //   a string     : Any format supported by the javascript engine, like
        //                  "YYYY/MM/DD", "MM/DD/YYYY", "Jan 31 2009" etc.
        //  an object     : Interpreted as an object with year, month and date
        //                  attributes.  **NOTE** month is 0-11.
        return (
            d.constructor === Date ? d :
            d.constructor === Array ? new Date(d[0],d[1],d[2]) :
            d.constructor === Number ? new Date(d) :
            d.constructor === String ? new Date(d) :
            typeof d === "object" ? new Date(d.year,d.month,d.date) :
            NaN
        );
    },
    compare:function(a,b) {
        // Compare two dates (could be of any type supported by the convert
        // function above) and returns:
        //  -1 : if a < b
        //   0 : if a = b
        //   1 : if a > b
        // NaN : if a or b is an illegal date
        // NOTE: The code inside isFinite does an assignment (=).
        return (
            isFinite(a=this.convert(a).valueOf()) &&
            isFinite(b=this.convert(b).valueOf()) ?
            (a>b)-(a<b) :
            NaN
        );
    },
    inRange:function(d,start,end) {
        // Checks if date in d is between dates in start and end.
        // Returns a boolean or NaN:
        //    true  : if d is between start and end (inclusive)
        //    false : if d is before start or after end
        //    NaN   : if one or more of the dates is illegal.
        // NOTE: The code inside isFinite does an assignment (=).
       return (
            isFinite(d=this.convert(d).valueOf()) &&
            isFinite(start=this.convert(start).valueOf()) &&
            isFinite(end=this.convert(end).valueOf()) ?
            start <= d && d <= end :
            NaN
        );
    }
}

नोट - केवल दिनांक भाग की तुलना करें:

जब हम जावास्क्रिप्ट में दो तारीख की तुलना करते हैं। इसमें घंटों, मिनट और सेकंड भी ध्यान में लगते हैं .. इसलिए यदि हमें केवल तारीख की तुलना करने की आवश्यकता है, तो यह दृष्टिकोण है:

var date1= new Date("01/01/2014").setHours(0,0,0,0);

var date2= new Date("01/01/2014").setHours(0,0,0,0);

अब: if date1.valueOf()> date2.valueOf() एक आकर्षण की तरह काम करेगा।


आप इस कोड का उपयोग करते हैं,

var firstValue = "2012-05-12".split('-');
var secondValue = "2014-07-12".split('-');

 var firstDate=new Date();
 firstDate.setFullYear(firstValue[0],(firstValue[1] - 1 ),firstValue[2]);

 var secondDate=new Date();
 secondDate.setFullYear(secondValue[0],(secondValue[1] - 1 ),secondValue[2]);     

  if (firstDate > secondDate)
  {
   alert("First Date  is greater than Second Date");
  }
 else
  {
    alert("Second Date  is greater than First Date");
  }

और यह लिंक http://www.w3schools.com/js/js_obj_date.asp भी http://www.w3schools.com/js/js_obj_date.asp


मेरी परियोजनाओं में से एक में मैंने यही किया है,

function CompareDate(tform){
     var startDate = new Date(document.getElementById("START_DATE").value.substring(0,10));
     var endDate = new Date(document.getElementById("END_DATE").value.substring(0,10));

     if(tform.START_DATE.value!=""){
         var estStartDate = tform.START_DATE.value;
         //format for Oracle
         tform.START_DATE.value = estStartDate + " 00:00:00";
     }

     if(tform.END_DATE.value!=""){
         var estEndDate = tform.END_DATE.value;
         //format for Oracle
         tform.END_DATE.value = estEndDate + " 00:00:00";
     }

     if(endDate <= startDate){
         alert("End date cannot be smaller than or equal to Start date, please review you selection.");
         tform.START_DATE.value = document.getElementById("START_DATE").value.substring(0,10);
         tform.END_DATE.value = document.getElementById("END_DATE").value.substring(0,10);
         return false;
     }
}

इसे फॉर्म पर कॉल करने पर कॉल करें। उम्मीद है की यह मदद करेगा।


हाय तारीखों की तुलना करने के लिए मेरा कोड यहाँ है। मेरे मामले में मैं पिछली तिथियों का चयन करने की अनुमति न देने के लिए एक चेक कर रहा हूं।

var myPickupDate = <pick up date> ;
var isPastPickupDateSelected = false;
var currentDate = new Date();

if(currentDate.getFullYear() <= myPickupDate.getFullYear()){
    if(currentDate.getMonth()+1 <= myPickupDate.getMonth()+1 || currentDate.getFullYear() < myPickupDate.getFullYear()){
                        if(currentDate.getDate() <= myPickupDate.getDate() || currentDate.getMonth()+1 < myPickupDate.getMonth()+1 || currentDate.getFullYear() < myPickupDate.getFullYear()){
                                            isPastPickupDateSelected = false;
                                            return;
                                        }
                    }
}
console.log("cannot select past pickup date");
isPastPickupDateSelected = true;






compare