Confronta due date con JavaScript

Qualcuno può suggerire un modo per confrontare i valori di due date maggiori di, minori di e non in passato usando JavaScript? I valori verranno dalle caselle di testo.

L' oggetto Date farà quello che vuoi - costrutto uno per ogni data, poi confrontarli con il >, <, <=o >=.

Il ==, !=, ===, e !==gli operatori richiedono l'utilizzo date.getTime()come in

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

per essere chiari, semplicemente controllando l'uguaglianza direttamente con gli oggetti data non funzionerà

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)

Ti suggerisco di utilizzare gli elenchi a discesa o una forma vincolata simile di data entry piuttosto che caselle di testo, per non ritrovarti nell'inferno della validazione dell'input.

Il modo più semplice per confrontare le date in javascript è prima convertirlo in un oggetto Date e poi confrontare questi oggetti data.

Di seguito trovi un oggetto con tre funzioni:

• dates.compare (a, b)

  Restituisce un numero:

  • -1 se a <b
  • 0 se a = b
  • 1 se a> b
  • NaN se a o b è una data illegale

• date.inRange (d, inizio, fine)

  Restituisce un valore booleano o NaN:

  • vero se d è tra l' inizio e la fine (incluso)
  • false se d è prima dell'inizio o dopo la fine .
  • NaN se una o più date sono illegali.

• dates.convert

  Utilizzato dalle altre funzioni per convertire il loro input in un oggetto data. L'input può essere

  • a date -object: l'input viene restituito così com'è.
  • un array : interpretato come [anno, mese, giorno]. NOTA il mese è 0-11.
  • un numero : interpretato come numero di millisecondi dal 1 ° gennaio 1970 (un timestamp)
  • una stringa : sono supportati diversi formati, come "AAAA / MM / GG", "MM / GG / AAAA", "31 gennaio 2009" ecc.
  • un oggetto : interpretato come un oggetto con attributi anno, mese e data. NOTA il mese è 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
        );
    }
}

Confronta <e >come al solito, ma tutto ciò che riguarda =dovrebbe usare un +prefisso. Così:

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

Spero che sia di aiuto!

Gli operatori relazionali < <= > >=possono essere utilizzati per confrontare le date 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

Tuttavia, gli operatori di uguaglianza == != === !==non possono essere utilizzati per confrontare (il valore di) date perché :

• Due oggetti distinti non sono mai uguali per confronti rigorosi o astratti.
• Un'espressione che confronta oggetti è vera solo se gli operandi fanno riferimento allo stesso oggetto.

Puoi confrontare il valore delle date per l'uguaglianza usando uno di questi metodi:

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

Entrambi Date.getTime()e Date.valueOf()restituiscono il numero di millisecondi dal 1 ° gennaio 1970 alle 00:00 UTC. Sia la Numberfunzione che l' +operatore unario chiamano i valueOf()metodi dietro le quinte.

Il metodo di gran lunga più semplice è sottrarre una data dall'altra e confrontare il risultato.

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

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

Confrontando le date in JavaScript è abbastanza facile ... JavaScript è incorporato sistema di confronto per le date che lo rende così facile da fare il confronto ...

Segui questi passaggi per confrontare il valore di 2 date, ad esempio hai 2 input in cui ognuno ha un valore di Data Stringe devi confrontarli ...

1. hai 2 valori di stringa che ottieni da un input e desideri confrontarli, sono i seguenti:

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

2. Devono Date Objectessere confrontati come valori di data, quindi è sufficiente convertirli in data, usando new Date(), li riassegnerò per semplicità di spiegazione, ma puoi farlo comunque come preferisci:

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

3. Ora confrontali semplicemente, usando il> < >= <=

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

Confronta solo giorno (ignorando la componente temporale):

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
}

quale formato?

Se costruisci un oggetto Date JavaScript , puoi semplicemente sottrarlo per ottenere una differenza di millisecondi (modifica: o semplicemente confrontarli):

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

usi questo codice,

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 controlla anche questo link http://www.w3schools.com/js/js_obj_date.asp

RISPOSTA BREVE

Ecco una funzione che restituisce {booleano} se la demo da dateTime> a dateTime in azione

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

Spiegazione

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 

poiché ora hai entrambi i datetime nel tipo di numero, puoi confrontarli con qualsiasi operazione di confronto

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

Poi

se hai familiarità con la C#stringa di formato data e ora personalizzata questa libreria dovrebbe fare esattamente la stessa cosa e aiutarti a formattare la tua data e ora dtmFRM sia che passi la stringa di data o il 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

tutto quello che devi fare è passare uno di questi formati pacificati nel jsfile della libreria

Il modo semplice è,

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

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

Nota: confronta solo la parte della data:

Quando confrontiamo due date in javascript. Ci vogliono ore, minuti e secondi anche in considerazione .. Quindi, se abbiamo solo bisogno di confrontare solo la data, questo è l'approccio:

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

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

Ora: if date1.valueOf()> date2.valueOf()funzionerà come un fascino.

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 per aggiungere un'altra possibilità alle molte opzioni esistenti, puoi provare:

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

... che sembra funzionare per me. Ovviamente devi assicurarti che entrambe le date non siano indefinite ...

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

In questo modo possiamo garantire che venga effettuato un confronto positivo se entrambi sono anche indefiniti, oppure ...

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

... se preferisci che non siano uguali.

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

Il metodo restituisce 1 se dateTimeAè maggiore didateTimeB

Il metodo restituisce 0 se dateTimeAugualedateTimeB

Il metodo restituisce -1 se dateTimeAè inferiore adateTimeB

ATTENZIONE AL FUSO ORARIO

Una data javascript non ha nozione di fuso orario . È un momento nel tempo (segni di spunta dall'epoca) con utili funzioni per la traduzione da e verso le stringhe nel fuso orario "locale". Se vuoi lavorare con le date usando gli oggetti date, come fanno tutti qui, vuoi che le tue date rappresentino la mezzanotte UTC all'inizio della data in questione. Questa è una convenzione comune e necessaria che ti consente di lavorare con le date indipendentemente dalla stagione o dal fuso orario della loro creazione. Quindi è necessario essere molto vigili per gestire la nozione di fuso orario, in particolare quando si crea l'oggetto Data UTC di mezzanotte.

Il più delle volte, vorrai che la tua data rifletta il fuso orario dell'utente. Fai clic su se oggi è il tuo compleanno . Gli utenti in Nuova Zelanda e Stati Uniti fanno clic contemporaneamente e ottengono date diverse. In tal caso, fai questo ...

// 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 volte, la comparabilità internazionale supera l'accuratezza locale. In tal caso, fai questo ...

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

Ora puoi confrontare direttamente i tuoi oggetti data come suggeriscono le altre risposte.

Avendo cura di gestire il fuso orario quando crei, devi anche essere sicuro di mantenere il fuso orario fuori quando converti di nuovo in una rappresentazione di stringa. Quindi puoi usare tranquillamente ...

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

Ed evita totalmente tutto il resto, specialmente ...

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

Supponi di avere gli oggetti data A e B, ottieni il loro valore di tempo EPOC, quindi sottrai per ottenere la differenza in millisecondi.

var diff = +A - +B;

È tutto.

Per confrontare due date possiamo usare la libreria JavaScript date.js che può essere trovata su: https://code.google.com/archive/p/datejs/downloads

e usa il Date.compare( Date date1, Date date2 )metodo e restituisce un numero che significa il seguente risultato:

-1 = data1 è minore di data2.

0 = i valori sono uguali.

1 = data1 è maggiore di data2.

Sottrai due date ottieni la differenza in millisecondi, se ottieni 0la stessa data

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

Per creare date dal testo libero in Javascript è necessario analizzarlo nell'oggetto Date ().

È possibile utilizzare Date.parse () che accetta il testo libero e tenta di convertirlo in una nuova data, ma se si ha il controllo sulla pagina, si consiglia di utilizzare invece le caselle di selezione HTML o un selettore di date come il controllo del calendario YUI o l' interfaccia utente jQuery Datepicker .

Una volta che hai una data, come altri hanno sottolineato, puoi usare l'aritmetica semplice per sottrarre le date e riconvertirle in un numero di giorni dividendo il numero (in secondi) per il numero di secondi in un giorno (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 versione migliorata del codice pubblicata da "alcuni"

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

utilizzo:

  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 il formato della data è il seguente, puoi utilizzare questo codice:

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

Verificherà se il 20121121numero è maggiore 20121103o meno.

Di solito immagazzino Datescome timestamps(Number)nei database.

Quando ho bisogno di confrontare, faccio semplicemente un confronto tra quei timestamp o

convertilo in oggetto data e confrontalo con > <se necessario.

Si noti che == o === non funziona correttamente a meno che le variabili non siano riferimenti dello stesso oggetto data.

Converti prima quegli oggetti Date in timestamp (numero) e poi confronta la loro uguaglianza.

Data al timestamp

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

Data e ora ad oggi

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

Prima di confrontare l' Datesoggetto, prova a impostare entrambi i loro millisecondi su zero come Date.setMilliseconds(0);.

In alcuni casi in cui l' Dateoggetto viene creato dinamicamente in javascript, se continui a stampare Date.getTime(), vedrai cambiare i millisecondi, il che impedirà l'uguaglianza di entrambe le date.

Prestazione

Oggi 2020.02.27 eseguo test delle soluzioni scelte su Chrome v80.0, Safari v13.0.5 e Firefox 73.0.1 su MacOs High Sierra v10.13.6

conclusioni

• le soluzioni d1==d2(D) e d1===d2(E) sono più veloci per tutti i browser
• la soluzione getTime(A) è più veloce di valueOf(B) (entrambi sono di media velocità)
• le soluzioni F, L, N sono le più lente per tutti i browser

Dettagli

Di seguito vengono presentate le soluzioni utilizzate nei test delle prestazioni. Puoi eseguire il test nella tua macchina QUI

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>

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

Usa questo codice per confrontare la data usando JavaScript.

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

Ecco cosa ho fatto in uno dei miei progetti,

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

chiamando questo sul modulo onsubmit. spero che sia di aiuto.