Zwei Daten mit JavaScript vergleichen

Question

Kann jemand einen Vorschlag machen, wie man die Werte von zwei Daten größer als, kleiner als, und nicht in der Vergangenheit mit JavaScript? Die Werte werden aus Textfeldern stammen.

Answer 1

El Datum Objekt wird das tun, was Sie wollen - einen für jedes Datum erstellen, dann die beiden mit der > , < , <= ou >= .

El == , != , === y !== Die Betreiber verlangen von Ihnen die Verwendung von date.getTime() wie in

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

um klar zu sein, wird die Prüfung auf Gleichheit direkt mit den Datumsobjekten nicht funktionieren

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)

Ich schlage vor, dass Sie Dropdown-Listen oder eine ähnliche eingeschränkte Form der Dateneingabe anstelle von Textfeldern verwenden, damit Sie sich nicht in der Hölle der Eingabeüberprüfung wiederfinden.

---

Für Neugierige, date.getTime() Dokumentation :

Gibt den numerischen Wert des angegebenen Datums als die Anzahl der Millisekunden seit dem 1. Januar 1970, 00:00:00 UTC, zurück. (Für frühere Zeiten werden negative Werte zurückgegeben.)

Answer 2

Vergleichen Sie < y > wie immer, aber alles, was mit == ou === sollte eine + Präfix. Zum Beispiel so:

const x = new Date('2013-05-23');
const y = new Date('2013-05-23');

// less than, greater than is fine:
console.log('x < y', x < y); // false
console.log('x > y', x > y); // false
console.log('x <= y', x <= y); // true
console.log('x >= y', x >= y); // true
console.log('x === y', x === y); // false, oops!

// anything involving '==' or '===' should use the '+' prefix
// it will then compare the dates' millisecond values

console.log('+x === +y', +x === +y); // true

Answer 3

Der einfachste Weg, um Daten in Javascript zu vergleichen ist, um es zunächst zu einem Datum Objekt konvertieren und dann vergleichen diese Datum-Objekte.

Nachfolgend finden Sie ein Objekt mit drei Funktionen:

• dates.compare(a,b)

  Gibt eine Zahl zurück:

  • -1 wenn a < b
  • 0 wenn a = b
  • 1 wenn a > b
  • NaN, wenn a oder b ein unzulässiges Datum ist

• dates.inRange (d,Anfang,Ende)

  Gibt einen booleschen Wert oder NaN zurück:

  • wahr si d liegt zwischen dem Start y Ende (einschließlich)
  • falsch si d ist vor Start oder nach Ende .
  • NaN, wenn eines oder mehrere der Daten illegal sind.

• dates.convert

  Wird von den anderen Funktionen verwendet, um ihre Eingabe in ein Datumsobjekt umzuwandeln. Die Eingabe kann sein

  • a Datum -Objekt : Die Eingabe wird so zurückgegeben, wie sie ist.
  • eine array : Interpretiert als [Jahr,Monat,Tag]. ANMERKUNG Monat ist 0-11.
  • a Nummer : Interpretiert als Anzahl der Millisekunden seit dem 1. Januar 1970 (ein Zeitstempel)
  • a String : Es werden verschiedene Formate unterstützt, wie "JJJJ/MM/TT", "MM/TT/JJJJ", "31. Januar 2009" usw.
  • eine Objekt : Wird als Objekt mit den Attributen Jahr, Monat und Datum interpretiert. ANMERKUNG Monat ist 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
        );
    }
}

Answer 4

Die relationalen Operatoren < <= > >= kann verwendet werden, um JavaScript-Daten zu vergleichen:

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

Allerdings sind die Gleichheitsoperatoren == != === !== kann nicht verwendet werden, um (den Wert von) Daten zu vergleichen denn :

• Zwei unterschiedliche Objekte sind niemals gleich, weder bei strengen noch bei abstrakten Vergleichen.
• Ein Ausdruck, der Objekte vergleicht, ist nur wahr, wenn die Operanden auf dasselbe Objekt verweisen.

Sie können den Wert von Datumsangaben mit jeder dieser Methoden auf Gleichheit vergleichen:

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

Beide Date.getTime() y Date.valueOf() gibt die Anzahl der Millisekunden seit dem 1. Januar 1970, 00:00 UTC, zurück. Beide Number Funktion und unär + Operator rufen die valueOf() Methoden hinter den Kulissen.

Answer 5

Die bei weitem einfachste Methode besteht darin, das eine Datum vom anderen abzuziehen und das Ergebnis zu vergleichen.

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

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