Question Comparez deux dates avec JavaScript

Le moyen le plus simple de comparer les dates en javascript consiste à le convertir en un objet Date, puis à comparer ces objets-date.

Ci-dessous vous trouvez un objet avec trois fonctions:

• dates.compare (a, b)

  Renvoie un nombre:

  • -1 si un <b
  • 0 si a = b
  • 1 si a> b
  • NaN si a ou b est une date illégale

• dates.inRange (d, début, fin)

  Renvoie un booléen ou un NaN:

  • vrai si ré est entre le début et fin (compris)
  • faux si ré est avant début ou après fin.
  • NaN si une ou plusieurs des dates sont illégales.

• dates.convert

  Utilisé par les autres fonctions pour convertir leur entrée en objet de date. L'entrée peut être

  • une rendez-vous amoureux-object: L'entrée est retournée telle quelle.
  • un tableau: Interprété comme [année, mois, jour]. REMARQUE le mois est 0-11.
  • une nombre : Interprété en nombre de millisecondes depuis le 1er janvier 1970 (un horodatage)
  • une chaîne : Plusieurs formats différents sont supportés, comme "AAAA / MM / JJ", "MM / JJ / AAAA", "31 janvier 2009" etc.
  • un objet: Interprété comme un objet avec des attributs d'année, de mois et de date. REMARQUE le mois est 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
        );
    }
}

Comparer < et > comme d'habitude, mais tout ce qui implique = devrait utiliser un + préfixe. Ainsi:

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

J'espère que cela t'aides!

Les opérateurs relationnels <  <=  >  >= peut être utilisé pour comparer les dates JavaScript:

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

Cependant, les opérateurs d'égalité ==  !=  ===  !== ne peut pas être utilisé pour comparer (la valeur de) dates car:

• Deux objets distincts ne sont jamais égaux pour des comparaisons strictes ou abstraites.
• Une expression comparant les objets n'est vraie que si les opérandes font référence au même objet.

Vous pouvez comparer la valeur des dates pour l'égalité en utilisant l'une des méthodes suivantes:

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

Tous les deux Date.getTime() et Date.valueOf() renvoie le nombre de millisecondes écoulées depuis le 1er janvier 1970 à 00:00 UTC. Tous les deux Number fonction et unaire + l'opérateur appelle le valueOf() les méthodes dans les coulisses.

La méthode la plus simple est de loin de soustraire une date de l'autre et de comparer le résultat.

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

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

Comparer le jour seulement (en ignorant le composant temps):

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

Usage:

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

Comparant Rendez-vous en JavaScript est assez facile ... JavaScript a intégré système de comparaison pour Rendez-vous ce qui le rend si facile à faire la comparaison ...

Il suffit de suivre ces étapes pour comparer la valeur de 2 dates, par exemple vous avez 2 entrées qui ont chacune une valeur Date dans String et vous de les comparer ...

1. vous avez 2 valeurs de chaîne que vous obtenez d'une entrée et vous souhaitez les comparer, ils sont comme ci-dessous:

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

2. Ils doivent être Date Object être comparés en tant que valeurs de date, il suffit donc de les convertir à ce jour, en utilisant new Date(), Je les réattribue juste pour la simplicité de l'explication, mais vous pouvez le faire quand même:

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

3. Maintenant, comparez-les simplement en utilisant >  <  >=  <=

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

quel format?

Si vous construisez un Javascript Objet de date, vous pouvez simplement les soustraire pour obtenir une différence de millisecondes (modifier: ou simplement les comparer):

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

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

vous utilisez ce code,

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

Et aussi vérifier ce lien http://www.w3schools.com/js/js_obj_date.asp