Compare duas datas com JavaScript

Alguém pode sugerir uma maneira de comparar os valores de duas datas maiores que, menores que e não no passado usando JavaScript? Os valores serão provenientes de caixas de texto.

O objeto Date vai fazer o que quiser - construção um para cada data, em seguida, compará-los usando o >, <, <=ou >=.

A ==, !=, ===, e !==operadoras exigem que você use date.getTime()como em

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

para ficar claro, basta verificar a igualdade diretamente com os objetos de data que não funcionam

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)

Sugiro que você use listas suspensas ou alguma forma similar restrita de entrada de data em vez de caixas de texto, para que você não se encontre no inferno da validação de entrada.

A maneira mais fácil de comparar datas em javascript é primeiro convertê-las em um objeto Date e, em seguida, comparar esses objetos de data.

Abaixo, você encontra um objeto com três funções:

• datas.compare (a, b)

  Retorna um número:

  • -1 se a <b
  • 0 se a = b
  • 1 se a> b
  • NaN se a ou b for uma data ilegal

• datas.inRange (d, início, fim)

  Retorna um booleano ou NaN:

  • true se d estiver entre o início e o fim (inclusive)
  • false se d for antes do início ou depois do fim .
  • NaN se uma ou mais datas forem ilegais.

• datas.converter

  Usado por outras funções para converter suas entradas em um objeto de data. A entrada pode ser

  • a data -object: A entrada é retornada como está.
  • uma matriz : interpretada como [ano, mês, dia]. NOTA mês é 0-11.
  • um número : interpretado como número de milissegundos desde 1 de janeiro de 1970 (um carimbo de data / hora)
  • uma sequência : vários formatos diferentes são suportados, como "AAAA / MM / DD", "MM / DD / AAAA", "31 de janeiro de 2009" etc.
  • um objeto : interpretado como um objeto com atributos de ano, mês e data. NOTA mês é 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 <e, >como sempre, mas qualquer coisa que envolva =deve usar um +prefixo. Igual a:

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 isto ajude!

Os operadores relacionais < <= > >=podem ser usados ​​para comparar datas do 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

No entanto, os operadores de igualdade == != === !==não podem ser usados ​​para comparar (o valor de) datas porque :

• Dois objetos distintos nunca são iguais para comparações estritas ou abstratas.
• Uma expressão comparando Objetos só é verdadeira se os operandos fizerem referência ao mesmo Objeto.

Você pode comparar o valor das datas para a igualdade usando qualquer um destes 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()e Date.valueOf()retornam o número de milissegundos desde 1 de janeiro de 1970, 00:00 UTC. Tanto a Numberfunção quanto o +operador unário chamam os valueOf()métodos nos bastidores.

De longe, o método mais fácil é subtrair uma data da outra e comparar o resultado.

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

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

Comparar datas em JavaScript é bastante fácil ... JavaScript possui um sistema de comparação interno para datas, o que facilita a comparação ...

Basta seguir estas etapas para comparar o valor de 2 datas, por exemplo, você tem 2 entradas nas quais cada um tem um valor de Data Stringe você pode compará-las ...

1. você tem 2 valores de string obtidos de uma entrada e deseja compará-los, são os seguintes:

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

2. Eles precisam Date Objectser comparados como valores de data, portanto, simplesmente converta-os para data, usando new Date(), eu apenas os redesigno por simplicidade de explicação, mas você pode fazer o que quiser:

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

3. Agora basta compará-los, usando o> < >= <=

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

Comparar apenas o dia (ignorando o componente de hora):

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?

Se você construir um objeto Data Javascript , poderá subtraí-lo para obter uma diferença de milissegundos (editar: ou apenas compará-lo):

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

você usa esse 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");
  }

E também verifique este link http://www.w3schools.com/js/js_obj_date.asp

RESPOSTA CURTA

Aqui está uma função que retorna {boolean} se a demonstração from dateTime> to dateTime em ação

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

Explicação

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 

Como agora você tem as duas horas no tipo de número, você pode compará-las com qualquer operação de comparação

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

Então

se você estiver familiarizado com a sequência personalizada deC# formato de data e hora, esta biblioteca deve fazer exatamente a mesma coisa e ajudá-lo a formatar sua data e hora dtmFRM, independentemente de você estar passando na sequência de data e hora ou no 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

DEMO

tudo o que você precisa fazer é passar qualquer um desses formatos pacificados no jsarquivo da biblioteca

A maneira mais simples é,

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

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

Nota - Comparar apenas a parte da data:

Quando comparamos duas datas em javascript. Também leva horas, minutos e segundos. Então, se precisarmos comparar apenas a data, esta é a abordagem:

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

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

Agora: if date1.valueOf()> date2.valueOf()funcionará como um 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

Apenas para adicionar mais uma possibilidade às muitas opções existentes, você pode tentar:

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

... o que parece funcionar para mim. Claro que você precisa garantir que as duas datas não sejam indefinidas ...

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

Dessa forma, podemos garantir uma comparação positiva se ambos forem indefinidos também, ou ...

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

... se você preferir que eles não sejam iguais.

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

O método retorna 1 se dateTimeAfor maior quedateTimeB

O método retorna 0 se for dateTimeAigualdateTimeB

O método retorna -1 se dateTimeAfor menor quedateTimeB

Cuidado com o fuso horário

Uma data javascript não tem noção de fuso horário . É um momento no tempo (ticks desde a época) com funções úteis para traduzir de e para strings no fuso horário "local". Se você deseja trabalhar com datas usando objetos de data, como todo mundo aqui está fazendo, você deseja que suas datas representem a meia-noite do UTC no início da data em questão. Essa é uma convenção comum e necessária que permite trabalhar com datas, independentemente da estação ou do fuso horário de sua criação. Portanto, você precisa estar muito vigilante para gerenciar a noção de fuso horário, principalmente quando criar seu objeto UTC Date da meia-noite.

Na maioria das vezes, você deseja que sua data reflita o fuso horário do usuário. Clique se hoje é seu aniversário . Os usuários da Nova Zelândia e EUA clicam ao mesmo tempo e obtêm datas diferentes. Nesse caso, faça isso ...

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

Às vezes, a comparabilidade internacional supera a precisão local. Nesse caso, faça isso ...

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

Agora você pode comparar diretamente seus objetos de data, conforme as outras respostas sugerem.

Tendo tomado o cuidado de gerenciar o fuso horário ao criar, também é necessário manter o fuso horário ao converter novamente em uma representação de sequência. Então você pode usar com segurança ...

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

E evite totalmente tudo o mais, especialmente ...

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

Digamos que você tenha os objetos de data A e B, obtenha o valor de tempo do EPOC e subtraia para obter a diferença em milissegundos.

var diff = +A - +B;

Isso é tudo.

Para comparar duas datas, podemos usar a biblioteca JavaScript date.js. que pode ser encontrada em: https://code.google.com/archive/p/datejs/downloads

e use o Date.compare( Date date1, Date date2 )método e ele retornará um número que significa o seguinte resultado:

-1 = data1 é menor que data2.

0 = valores são iguais.

1 = data1 é maior que data2.

Subtrair duas datas, obter a diferença em milissegundos, se você obtiver 0a mesma data

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

Para criar datas a partir de texto livre em Javascript, você precisa analisá-lo no objeto Date ().

Você pode usar Date.parse (), que usa texto livre para convertê-lo em uma nova data, mas se você tiver controle sobre a página, recomendo usar caixas de seleção HTML ou um seletor de datas como o controle de calendário YUI ou a interface do usuário do jQuery Datepicker .

Depois de ter uma data como as outras pessoas apontaram, você pode usar a aritmética simples para subtrair as datas e convertê-la novamente em vários dias, dividindo o número (em segundos) pelo número de segundos em um dia (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;
}

Uma versão aprimorada do código postada por "some"

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

Se a seguir for o seu formato de data, você poderá 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)){
   //...
}

Ele verificará se o 20121121número é maior 20121103ou não.

Eu costumo armazenar Datescomo timestamps(Number)em bancos de dados.

Quando preciso comparar, simplesmente comparo entre os carimbos de data e hora ou

converta-o em objeto de data e compare com > <se necessário.

Observe que == ou === não funciona corretamente, a menos que suas variáveis ​​sejam referências do mesmo objeto Data.

Converta esses objetos Date em timestamp (number) primeiro e depois compare a igualdade deles.

Data até a data e hora

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

Data e hora até a data

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

Antes de comparar o Datesobjeto, tente definir os dois milissegundos para zero como Date.setMilliseconds(0);.

Em alguns casos em que o Dateobjeto é criado dinamicamente em javascript, se você continuar imprimindo Date.getTime(), verá os milissegundos mudando, o que impedirá a igualdade das duas datas.

atuação

Hoje 2020.02.27 Realizo testes de soluções escolhidas no Chrome v80.0, Safari v13.0.5 e Firefox 73.0.1 no MacOs High Sierra v10.13.6

Conclusões

• As soluções d1==d2(D) e d1===d2(E) são mais rápidas para todos os navegadores
• A solução getTime(A) é mais rápida que valueOf(B) (ambas são de velocidade média)
• As soluções F, L, N são as mais lentas para todos os navegadores

Detalhes

Abaixo, são apresentadas as soluções usadas nos testes de desempenho. Você pode executar o teste em sua máquina AQUI

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 chrome

        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 a data usando javascript.

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

Aqui está o que eu fiz em um dos meus projetos,

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

chamando isso no formulário ao enviar. espero que isto ajude.