දින දෙකක් ජාවාස්ක්‍රිප්ට් සමඟ සසඳන්න

අතීතයේ දී ජාවාස්ක්‍රිප්ට් භාවිතයෙන් නොව, වඩා අඩු, වඩා අඩු හා දින දෙකක අගයන් සංසන්දනය කිරීමට යමෙකුට යෝජනා කළ හැකිද ? අගයන් පෙළ කොටු වලින් ලැබෙනු ඇත.

මෙම දිනය වස්තුව නම් භාවිතා කරමින් සන්සන්දනය, එක් එක් දිනය සඳහා ඉදිකිරීමක් එක් - ඔබට අවශ්ය දේ කරන්නේ >, <, <=හෝ >=.

මෙම ==, !=, ===, හා !==operators යොදා ඔබට අවශ්ය 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)

පෙළ පෙට්ටිවලට වඩා ඩ්‍රොප් ඩවුන්ස් හෝ ඒ හා සමාන සීමිත දින ප්‍රවේශයක් භාවිතා කිරීමට මම යෝජනා කරමි.

ජාවාස්ක්‍රිප්ට් හි දිනයන් සංසන්දනය කිරීමට ඇති පහසුම ක්‍රමය නම් පළමුව එය දින වස්තුවක් බවට පරිවර්තනය කර මෙම දිනය-වස්තු සංසන්දනය කිරීමයි.

පහත දැක්වෙන්නේ ශ්‍රිත තුනක් සහිත වස්තුවකි:

• dates.compare (a, b)

  අංකයක් ලබා දෙයි:

  • -1 නම් <b
  • 0 නම් a = b
  • 1 නම් a> ආ
  • A හෝ b නීති විරෝධී දිනයක් නම් NaN

• dates.inRange (d, start, end)

  බූලියන් හෝ NaN ලබා දෙයි:

  • ආරම්භය සහ අවසානය අතර d නම් සත්‍ය වේ (ඇතුළුව)
  • ආරම්භයට පෙර හෝ අවසානයට පසුව d නම් අසත්‍යය .
  • දිනයන් එකක් හෝ කිහිපයක් නීති විරෝධී නම් NaN.

• dates.convert

  අනෙකුත් කාර්යයන් මඟින් ඒවායේ ආදානය දින වස්තුවක් බවට පරිවර්තනය කිරීම සඳහා භාවිතා කරයි. ආදානය විය හැකිය

  • එය දිනය -object: පරිදි ආදාන ආපසු එවනු ලැබේ.
  • ක මාලාවක් : ලෙස අර්ථ [වසර, මාසය, දිනය]. සටහන මාසය 0-11.
  • එය සංඛ්යාව : 1 ජනවාරි 1970 (කාල මුද්රාව) සිට මිලි තත්පර සංඛ්යාව ලෙස අර්ථ
  • එය , සංගීත : විවිධ ආකෘති කිහිපයක්, "දැ ෙ / MM / DD" වැනි, සහාය "MM / DD / YYYY ආකාරය", "ජනවාරි 31, 2009" ආදිය
  • ක වස්තුව : වර්ෂය, මාසය සහ දිනය අනුව ගුණාංග සහිත වස්තුවක්, ලෙස අර්ථ. සටහන මාසය 0-11.

.

// Source: http://stackoverflow.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 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

මෙය උපකාරී වේ යැයි සිතමු!

< <= > >=ජාවාස්ක්‍රිප්ට් දිනයන් සංසන්දනය කිරීමට සම්බන්ධතා ක්‍රියාකරුවන් භාවිතා කළ හැකිය:

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

කෙසේ වෙතත්, සමානාත්මතා ක්‍රියාකරුවන් දින == != === !==සංසන්දනය කිරීමට භාවිතා කළ නොහැක (වටිනාකම) මන්ද :

• දැඩි හෝ වියුක්ත සැසඳීම් සඳහා එකිනෙකට වෙනස් වස්තු දෙකක් කිසි විටෙකත් සමාන නොවේ.
• වස්තූන් සංසන්දනය කරන ප්‍රකාශනයක් සත්‍ය වන්නේ ඔපෙරන්ඩ්ස් එකම වස්තුවක් සඳහන් කරන්නේ නම් පමණි.

මෙම ඕනෑම ක්‍රමයක් භාවිතා කර සමානාත්මතාවය සඳහා දිනයන්හි වටිනාකම ඔබට සැසඳිය හැකිය:

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.getTime()සහ Date.valueOf()1970 ජනවාරි 1 සිට 00:00 යූටීසී සිට මිලි තත්පර ගණන ආපසු එවන්න. Numberක්‍රියාකාරීත්වය සහ ඒකීය +ක්‍රියාකරු යන දෙකම valueOf()තිරය ​​පිටුපස ඇති ක්‍රම අමතයි.

බොහෝ දුරට පහසුම ක්‍රමය වන්නේ එක් දිනයක් අනෙකාගෙන් අඩු කර ප්‍රති .ලය සංසන්දනය කිරීමයි.

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

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

හා සසඳා බැලීමේ දින JavaScript තරමක් පහසු ... JavaScript ඇත වේ බිල්ට් සංසන්දනය පද්ධතිය සඳහා දින වකවානු හා සංසන්දනාත්මකව කරන්න එය එසේ පහසු කරයි වන ...

දින 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

දවස පමණක් සසඳන්න (කාල සංරචකය නොසලකා හැරීම):

Date.prototype.sameDay = function(d) {
  return this.getFullYear() === d.getFullYear()
    && this.getDate() === d.getDate()
    && this.getMonth() === d.getMonth();
}

භාවිතය:

if(date1.sameDay(date2)) {
    // highlight day on calendar or something else clever
}

කුමන ආකෘතියද?

ඔබ ජාවාස්ක්‍රිප්ට් දිනය වස්තුවක් සාදන්නේ නම්, මිලි තත්පර වෙනසක් ලබා ගැනීම සඳහා ඔබට ඒවා අඩු කළ හැකිය (සංස්කරණය කරන්න: නැතහොත් ඒවා සංසන්දනය කරන්න):

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

ඔබ මෙම කේතය භාවිතා කරයි,

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

කෙටි පිළිතුර

මෙහි ක්රියාව බව නැවත {වීජ} දිනයවේලාව සිට නම් වේ> දිනයවේලාව කිරීමට පියවර දී Demo

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 සංයුති කිරීමට උපකාරී වේ.

භාවිතය

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

ඩෙමෝ

ඔබ කළ යුතුව ඇත්තේ පුස්තකාල jsගොනුවේ මෙම ඕනෑම ආකෘතියක් සමනය කිරීමයි

සරලම ක්‍රමය නම්,

var first = '2012-11-21';
var second = '2012-11-03';

if (new Date(first) > new Date(second) {
    .....
}

සටහන - සංසන්දනය කරන්න දිනය කොටස:

අපි javascript හි දින දෙකක් සංසන්දනය කරන විට. පැය, මිනිත්තු සහ තත්පර ද සැලකිල්ලට ගත යුතුය .. එබැවින් අපට දිනය පමණක් සංසන්දනය කිරීමට අවශ්‍ය නම්, මෙය ප්‍රවේශයයි:

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()චාම් එකක් වගේ වැඩ කරයි.

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

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

පවතින බොහෝ විකල්ප සඳහා තවත් හැකියාවක් එක් කිරීමට, ඔබට උත්සාහ කළ හැකිය:

if (date1.valueOf()==date2.valueOf()) .....

... එය මට වැඩ කරන බව පෙනේ. ඇත්ත වශයෙන්ම ඔබ දින දෙකම නිර්වචනය කර නොමැති බවට සහතික විය යුතුය ...

if ((date1?date1.valueOf():0)==(date2?date2.valueOf():0) .....

මේ ආකාරයෙන් දෙකම නිර්වචනය කර නොමැති නම් ධනාත්මක සංසන්දනයක් සිදු කරන බවට අපට සහතික විය හැකිය, හෝ ...

if ((date1?date1.valueOf():0)==(date2?date2.valueOf():-1) .....

... ඔබ කැමති නම් ඔවුන් සමාන නොවීමට.

Moment.js හරහා

Jsfiddle: 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 ලබා දෙයිdateTimeB

dateTimeAසමාන නම් ක්‍රමය 0 ලබා දෙයිdateTimeB

dateTimeAවඩා අඩු නම් ක්‍රමය -1 නැවත ලබා දෙයිdateTimeB

කාල පරාසය පරෙස්සම් වන්න

ජාවාස්ක්‍රිප්ට් දිනයකට කාල කලාපය පිළිබඳ අදහසක් නොමැත . එය "දේශීය" කාල කලාපයේ ඇති නූල් වලට සහ ඉන් පරිවර්තනය කිරීම සඳහා පහසු කාර්යයන් සහිත කාල පරිච්ඡේදයක් (යුගයේ සිට කිනිතුල්ලන්). මෙහි සිටින සියල්ලන්ම කරන පරිදි, දින වස්තු භාවිතා කරමින් දිනයන් සමඟ වැඩ කිරීමට ඔබට අවශ්‍ය නම්, ඔබගේ දිනයන් ප්‍රශ්නාර්ථ දිනය ආරම්භයේදී යූටීසී මධ්‍යම රාත්‍රිය නියෝජනය කිරීමට ඔබට අවශ්‍යය. මෙය පොදු සහ අවශ්‍ය සම්මුතියක් වන අතර ඒවා නිර්මාණය කිරීමේ සමය හෝ කාල කලාපය නොසලකා දින සමඟ වැඩ කිරීමට ඔබට ඉඩ සලසයි. එබැවින් කාල කලාපය පිළිබඳ සංකල්පය කළමනාකරණය කිරීම සඳහා ඔබ ඉතා සුපරීක්ෂාකාරී විය යුතුය, විශේෂයෙන් ඔබ මධ්‍යම රාත්‍රියේ UTC දිනය වස්තුව නිර්මාණය කරන විට.

බොහෝ විට, ඔබගේ දිනය පරිශීලකයාගේ කාල කලාපය පිළිබිඹු කිරීමට ඔබට අවශ්‍ය වනු ඇත. අද ඔබේ උපන් දිනය නම් ක්ලික් කරන්න . NZ සහ US හි පරිශීලකයින් එකවර ක්ලික් කර විවිධ දිනයන් ලබා ගනී. එවැනි අවස්ථාවක, මෙය කරන්න ...

// create a date (utc midnight) reflecting the value of myDate and the environment's timezone offset.
new Date(Date.UTC(myDate.getFullYear(),myDate.getMonth(), myDate.getDate()));

සමහර විට, ජාත්‍යන්තර සංසන්දනය මගින් දේශීය නිරවද්‍යතාව තල්ලු කරයි. එවැනි අවස්ථාවක, මෙය කරන්න ...

// the date in London of a moment in time. Device timezone is ignored.
new Date(Date.UTC(myDate.getUTCYear(), myDate.getyUTCMonth(), myDate.getUTCDate()));

අනෙක් පිළිතුරු යෝජනා කරන පරිදි දැන් ඔබට ඔබගේ දින වස්තු කෙලින්ම සැසඳිය හැකිය.

ඔබ නිර්මාණය කරන විට කාල කලාපය කළමනාකරණය කිරීමට සැලකිලිමත් වූ පසු, ඔබ නැවත සංගීත නිරූපණයක් බවට පරිවර්තනය කරන විට කාල කලාපය වළක්වා ගැනීමට වග බලා ගත යුතුය. එබැවින් ඔබට ආරක්ෂිතව භාවිතා කළ හැකිය ...

• toISOString()
• getUTCxxx()
• getTime() //returns a number with no time or timezone.
• .toLocaleDateString("fr",{timezone:"UTC"}) // whatever locale you want, but ALWAYS UTC.

අනෙක් සියල්ල මුළුමනින්ම මග හරින්න, විශේෂයෙන් ...

• getYear(), getMonth(),getDate()

ඔබට දින වස්තු A සහ ​​B ලැබී ඇති බව පවසන්න, ඒවායේ EPOC කාල අගය ලබා ගන්න, ඉන්පසු මිලි තත්පරවල වෙනස ලබා ගැනීම සඳහා අඩු කරන්න.

var diff = +A - +B;

එච්චරයි.

දිනය දෙකක් සංසන්දනය කිරීම සඳහා අපට date.js ජාවාස්ක්‍රිප්ට් පුස්තකාලය භාවිතා කළ හැකිය: https://code.google.com/archive/p/datejs/downloads

සහ Date.compare( Date date1, Date date2 )ක්‍රමය භාවිතා කරන්න , එය පහත ප්‍රති result ලය අදහස් කරන අංකයක් ලබා දෙයි:

-1 = දිනය 1 යනු ලෙස්තාන් දිනය 2 වේ.

0 = අගයන් සමාන වේ.

1 = date1 යනු ශ්‍රේෂ් ern දිනය 2 වේ.

දින දෙකක් අඩු කිරීමෙන් මිලි තත්පරයේ වෙනස ලබා ගන්න, ඔබට 0එය ලැබෙන්නේ එකම දිනයකි

function areSameDate(d1, d2){
    return d1 - d2 === 0
}

ජාවාස්ක්‍රිප්ට් හි නොමිලේ පෙළෙන් දින නිර්මාණය කිරීම සඳහා ඔබ එය දිනය () වස්තුවට විග්‍රහ කළ යුතුය.

ඔබට Date.parse () භාවිතා කළ හැකි අතර එය නොමිලේ පෙළක් ගෙන එය නව දිනයක් බවට පරිවර්තනය කිරීමට උත්සාහ කරයි, නමුත් ඔබට පිටුව පාලනය කළ හැකි නම් ඒ වෙනුවට HTML තෝරාගත් පෙට්ටි හෝ YUI දින දර්ශන පාලනය හෝ jQuery UI වැනි දිනයක් තෝරන්න ඩේට්පිකර් .

වෙනත් පුද්ගලයින් පෙන්වා දී ඇති පරිදි ඔබට දිනයක් ලැබීමෙන් පසු, දිනයන් අඩු කිරීමට සරල අංක ගණිතය භාවිතා කර දින ගණනකට තත්පර ගණනකින් (තත්පර වලින්) බෙදීමෙන් එය දින කිහිපයකට පරිවර්තනය කළ හැකිය (60 * 60 * 24 = 86400).

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

"සමහරු" විසින් පළ කරන ලද කේතයේ වැඩිදියුණු කළ අනුවාදයකි

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

පහත දැක්වෙන්නේ ඔබගේ දින ආකෘතිය නම්, ඔබට මෙම කේතය භාවිතා කළ හැකිය:

var first = '2012-11-21';
var second = '2012-11-03';
if(parseInt(first.replace(/-/g,""),10) > parseInt(second.replace(/-/g,""),10)){
   //...
}

එය 20121121සංඛ්‍යාවට වඩා විශාලද නැද්ද යන්න පරීක්ෂා කරනු ඇත 20121103.

මම සාමාන්‍යයෙන් ගබඩා Datesකරන්නේ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);

Datesවස්තුව සංසන්දනය කිරීමට පෙර , ඒවායේ මිලි තත්පර දෙකම ශුන්‍යයට සැකසීමට උත්සාහ කරන්නDate.setMilliseconds(0); .

Dateජාවාස්ක්‍රිප්ට් හි වස්තුව ගතිකව නිර්මාණය කර ඇති සමහර අවස්ථාවල , ඔබ දිගටම මුද්‍රණය කරන්නේ නම් Date.getTime(), මිලි තත්පර වෙනස් වීම ඔබට පෙනෙනු ඇත, එමඟින් දින දෙකේම සමානාත්මතාවය වළක්වනු ඇත.

කාර්ය සාධනය

අද මම 2020.02.27 මැක්ඕස් හයි සියෙරා v10.13.6 හි ක්‍රෝම් v80.0, සෆාරි v13.0.5 සහ ෆයර්ෆොක්ස් 73.0.1 මත තෝරාගත් විසඳුම් පරීක්ෂා කරමි.

නිගමන

• විසඳුම් d1==d2(D) සහ d1===d2(E) සියලුම බ්‍රව්සර් සඳහා වේගවත් වේ
• විසඳුම getTime(A) valueOf(B) ට වඩා වේගවත් වේ (දෙකම මධ්‍යම වේගවත්)
• F, L, N විසඳුම් සියලු බ්‍රව්සර් සඳහා මන්දගාමී වේ

විස්තර

කාර්ය සාධන පරීක්ෂණ සඳහා භාවිතා කරන ස්නිපෙට් විසඳුම් පහත දැක්වේ. ඔබ යන්ත්රය පරීක්ෂණ සිදු කළ හැකි මුල්

function A(d1,d2) {
	return d1.getTime() == d2.getTime();
}

function B(d1,d2) {
	return d1.valueOf() == d2.valueOf();
}

function C(d1,d2) {
	return Number(d1)   == Number(d2);
}

function D(d1,d2) {
	return d1 == d2;
}

function E(d1,d2) {
	return d1 === d2;
}

function F(d1,d2) {
	return (!(d1>d2 || d2>d1));
}

function G(d1,d2) {
	return d1*1 == d2*1;
}

function H(d1,d2) {
	return +d1 == +d2;
}

function I(d1,d2) {
	return !(+d1 - +d2);
}

function J(d1,d2) {
	return !(d1 - d2);
}

function K(d1,d2) {
	return d1 - d2 == 0;
}

function L(d1,d2) {
	return !((d1>d2)-(d1<d2));
}

function M(d1,d2) {
  return d1.getFullYear() === d2.getFullYear()
    && d1.getDate() === d2.getDate()
    && d1.getMonth() === d2.getMonth();
}

function N(d1,d2) {
	return (isFinite(d1.valueOf()) && isFinite(d2.valueOf()) ? !((d1>d2)-(d1<d2)) : false );
}


// TEST

let past= new Date('2002-12-24'); // past
let now= new Date('2020-02-26');  // now

console.log('Code  d1>d2  d1<d2  d1=d2')
var log = (l,f) => console.log(`${l}     ${f(now,past)}  ${f(past,now)}  ${f(now,now)}`);

log('A',A);
log('B',B);
log('C',C);
log('D',D);
log('E',E);
log('G',G);
log('H',H);
log('I',I);
log('J',J);
log('K',K);
log('L',L);
log('M',M);
log('N',N);

p {color: red}

<p>This snippet only presents tested solutions (it not perform tests itself)</p>

ක්‍රෝම් සඳහා ප්‍රති Results ල

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

මෙන්න මගේ එක් ව්‍යාපෘතියක මම කළ දේ,

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

මෙය onsubmit පෝරමයට කැඳවීම. මෙය උපකාරී වේ යැයි සිතමි.