Compara dos fechas con JavaScript

¿Alguien puede sugerir una forma de comparar los valores de dos fechas mayores que, menores que y no en el pasado usando JavaScript? Los valores vendrán de cuadros de texto.

El objeto Date hará lo que usted quiere - una para cada constructo fecha, luego compararlas con el >, <, <=o >=.

El ==, !=, ===, y !==los operadores requieren el uso date.getTime()como en

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

para ser claros, solo verificar la igualdad directamente con los objetos de fecha no funcionará

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)

Sin embargo, le sugiero que use menús desplegables o alguna forma restringida similar de entrada de fecha en lugar de cuadros de texto, para no encontrarse en el infierno de la validación de entrada.

La forma más fácil de comparar fechas en javascript es convertirlo primero en un objeto Fecha y luego comparar estos objetos fecha.

A continuación encontrará un objeto con tres funciones:

• date.compare (a, b)

  Devuelve un número:

  • -1 si a <b
  • 0 si a = b
  • 1 si a> b
  • NaN si aob es una fecha ilegal

• date.inRange (d, inicio, fin)

  Devuelve un booleano o NaN:

  • verdadero si d está entre el inicio y el final (inclusive)
  • falso si d es antes del inicio o después del final .
  • NaN si una o más de las fechas son ilegales.

• convertir fechas

  Utilizado por las otras funciones para convertir su entrada en un objeto de fecha. La entrada puede ser

  • una fecha -objeto: la entrada se devuelve tal cual.
  • una matriz : Interpretada como [año, mes, día]. NOTA mes es 0-11.
  • un número : Interpretado como el número de milisegundos desde el 1 de enero de 1970 (una marca de tiempo)
  • una cadena : Se admiten varios formatos diferentes, como "AAAA / MM / DD", "MM / DD / AAAA", "31 de enero de 2009", etc.
  • un objeto : Interpretado como un objeto con atributos de año, mes y fecha. NOTA mes es 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
        );
    }
}

Compare <y >como de costumbre, pero cualquier cosa que implique =debe usar un +prefijo. Al igual que:

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

¡Espero que esto ayude!

Los operadores relacionales < <= > >=se pueden usar para comparar fechas de 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

Sin embargo, los operadores de igualdad == != === !==no se pueden usar para comparar (el valor de) las fechas porque :

• Dos objetos distintos nunca son iguales para comparaciones estrictas o abstractas.
• Una expresión que compara Objetos solo es verdadera si los operandos hacen referencia al mismo Objeto.

Puede comparar el valor de las fechas para la igualdad utilizando cualquiera de estos métodos:

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

Ambos Date.getTime()y Date.valueOf()devuelven el número de milisegundos desde el 1 de enero de 1970 a las 00:00 UTC. Tanto la Numberfunción como el +operador unario llaman a los valueOf()métodos detrás de escena.

Con mucho, el método más fácil es restar una fecha de la otra y comparar el resultado.

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

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

Comparar fechas en JavaScript es bastante fácil ... JavaScript tiene un sistema de comparación incorporado para las fechas, lo que facilita la comparación ...

Simplemente siga estos pasos para comparar el valor de 2 fechas, por ejemplo, tiene 2 entradas en las que cada una tiene un valor de Fecha Stringy puede compararlas ...

1. tiene 2 valores de cadena que obtiene de una entrada y desea compararlos, son los siguientes:

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

2. Deben Date Objectcompararse como valores de fecha, así que simplemente conviértalos a fecha, usando new Date(), simplemente los reasigno por simplicidad de explicación, pero puede hacerlo de la manera que desee:

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

3. Ahora simplemente compárelos, usando el> < >= <=

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

Comparar solo día (ignorando el componente de tiempo):

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

Uso:

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

que formato

Si construye un objeto Fecha de Javascript , solo puede restarlos para obtener una diferencia de milisegundos (editar: o simplemente compararlos):

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

usas este código,

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

Y también revise este enlace http://www.w3schools.com/js/js_obj_date.asp

RESPUESTA CORTA

Aquí hay una función que devuelve {boolean} si from from DateTime> to dateTime Demo en acción

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

Explicación

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 

dado que ahora tiene ambos datetime en tipo de número, puede compararlos con cualquier operación de comparación

(>, <, =,! =, ==,! ==,> = AND <=)

Entonces

si está familiarizado con C#la cadena de formato de fecha y hora personalizada, esta biblioteca debe hacer exactamente lo mismo y ayudarlo a formatear su fecha y hora dtmFRM, ya sea que pase la cadena de fecha o el formato unix

Uso

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

MANIFESTACIÓN

todo lo que tiene que hacer es pasar cualquiera de estos formatos pacificados en el jsarchivo de la biblioteca

La manera simple es,

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

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

Nota: Comparar solo la fecha Fecha:

Cuando comparamos dos fechas en javascript. También se necesitan horas, minutos y segundos. Entonces, si solo necesitamos comparar la fecha, este es el enfoque:

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

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

Ahora: if date1.valueOf()> date2.valueOf()funcionará como un encanto.

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

Solo para agregar otra posibilidad a las muchas opciones existentes, podría intentar:

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

... lo que parece funcionar para mí. Por supuesto, debe asegurarse de que ambas fechas no estén indefinidas ...

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

De esta manera podemos asegurarnos de que se haga una comparación positiva si ambos están indefinidos también, o ...

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

... si prefieres que no sean iguales.

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

El método devuelve 1 si dateTimeAes mayor quedateTimeB

El método devuelve 0 si dateTimeAes igualdateTimeB

El método devuelve -1 si dateTimeAes menor quedateTimeB

CUIDADO CON LA TIMEZONA

Una fecha de JavaScript no tiene noción de zona horaria . Es un momento en el tiempo (tics desde la época) con prácticas funciones para traducir hacia y desde cadenas en la zona horaria "local". Si desea trabajar con fechas utilizando objetos de fecha, como todos los que están aquí, quiere que sus fechas representen la medianoche UTC al comienzo de la fecha en cuestión. Esta es una convención común y necesaria que le permite trabajar con fechas independientemente de la temporada o zona horaria de su creación. Por lo tanto, debe estar muy atento para administrar la noción de zona horaria, especialmente cuando crea su objeto UTC Date de medianoche.

La mayoría de las veces, querrá que su fecha refleje la zona horaria del usuario. Haz clic si hoy es tu cumpleaños . Los usuarios de NZ y EE. UU. Hacen clic al mismo tiempo y obtienen fechas diferentes. En ese caso, haz esto ...

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

A veces, la comparabilidad internacional supera la precisión local. En ese caso, haz esto ...

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

Ahora puede comparar directamente sus objetos de fecha como sugieren las otras respuestas.

Habiendo tenido cuidado de administrar la zona horaria cuando crea, también debe asegurarse de mantener la zona horaria fuera cuando convierta nuevamente a una representación de cadena. Para que pueda usar con seguridad ...

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

Y evita totalmente todo lo demás, especialmente ...

• getYear()` getMonth()`getDate()

Digamos que obtuvo los objetos de fecha A y B, obtenga su valor de tiempo EPOC, luego reste para obtener la diferencia en milisegundos.

var diff = +A - +B;

Eso es todo.

Para comparar dos fechas, podemos usar la biblioteca de JavaScript date.js que se puede encontrar en: https://code.google.com/archive/p/datejs/downloads

y usa el Date.compare( Date date1, Date date2 )método y devuelve un número que significa el siguiente resultado:

-1 = fecha1 es menor que fecha2.

0 = los valores son iguales.

1 = date1 es mayor que date2.

Resta dos fechas y obtén la diferencia en milisegundos, si la obtienes 0es la misma fecha

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

Para crear fechas a partir de texto libre en Javascript, debe analizarlo en el objeto Date ().

Puede usar Date.parse (), que toma texto libre para convertirlo en una nueva fecha, pero si tiene control sobre la página, recomendaría usar cuadros de selección HTML o un selector de fecha como el control de calendario YUI o la interfaz de usuario jQuery Selector de fechas .

Una vez que tenga una fecha como han señalado otras personas, puede usar aritmética simple para restar las fechas y convertirla nuevamente en una cantidad de días dividiendo la cantidad (en segundos) por la cantidad de segundos en un día (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;
}

Una versión mejorada del código publicado por "algunos"

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

uso:

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

Si el siguiente es su formato de fecha, puede usar este código:

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

Verificará si el 20121121número es mayor 20121103o no.

Usualmente almaceno Datescomo timestamps(Number)en bases de datos.

Cuando necesito comparar, simplemente comparo entre esas marcas de tiempo o

conviértalo a Date Object y luego compárelo > <si es necesario.

Tenga en cuenta que == o === no funciona correctamente a menos que sus variables sean referencias del mismo Objeto de fecha.

Convierta esos objetos de Fecha en marca de tiempo (número) primero y luego compare la igualdad de ellos.

Fecha a la marca de tiempo

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

Marca de tiempo hasta la fecha

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

Antes de comparar el Datesobjeto, intente configurar ambos milisegundos como cero Date.setMilliseconds(0);.

En algunos casos donde el Dateobjeto se crea dinámicamente en javascript, si sigue imprimiendo Date.getTime(), verá que cambian los milisegundos, lo que evitará la igualdad de ambas fechas.

Actuación

Hoy 2020.02.27 realizo pruebas de las soluciones elegidas en Chrome v80.0, Safari v13.0.5 y Firefox 73.0.1 en MacOs High Sierra v10.13.6

Conclusiones

• Las soluciones d1==d2(D) y d1===d2(E) son más rápidas para todos los navegadores
• la solución getTime(A) es más rápida que valueOf(B) (ambas son medianamente rápidas)
• Las soluciones F, L, N son las más lentas para todos los navegadores

Detalles

A continuación se presentan las soluciones de fragmentos utilizadas en las pruebas de rendimiento. Puede realizar la prueba en su máquina AQUÍ

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>

Resultados para el cromo

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

Use este código para comparar la fecha usando javascript.

Gracias D.Jeeva

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

Esto es lo que hice en uno de mis proyectos,

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

llamando a esto en el formulario de envío. espero que esto ayude.