Ich möchte den Unterschied zwischen gültigen und ungültigen Datumsobjekten in JS feststellen, konnte aber nicht herausfinden, wie:

var d = new Date("foo");
console.log(d.toString()); // shows 'Invalid Date'
console.log(typeof d); // shows 'object'
console.log(d instanceof Date); // shows 'true'

Irgendwelche Ideen zum Schreiben einer isValidDateFunktion?

• Ash wird Date.parsezum Parsen von Datumszeichenfolgen empfohlen. Auf diese Weise können Sie überprüfen, ob die Datumszeichenfolge gültig ist.
• Wenn möglich, würde ich es vorziehen, wenn meine API eine Datumsinstanz akzeptiert und prüfen / bestätigen kann, ob sie gültig ist oder nicht. Borgars Lösung macht das, aber ich muss es browserübergreifend testen. Ich frage mich auch, ob es einen eleganteren Weg gibt.
• Ash ließ mich überlegen, ob meine API überhaupt keine DateInstanzen akzeptieren sollte. Dies wäre am einfachsten zu überprüfen.
• Borgar schlug vor, eine DateInstanz zu testen und dann den DateZeitwert der Instanz zu testen . Wenn das Datum ungültig ist, ist der Zeitwert NaN. Ich habe mit ECMA-262 nachgefragt und dieses Verhalten ist im Standard enthalten, genau das, wonach ich suche.

So würde ich es machen:

if (Object.prototype.toString.call(d) === "[object Date]") {
  // it is a date
  if (isNaN(d.getTime())) {  // d.valueOf() could also work
    // date is not valid
  } else {
    // date is valid
  }
} else {
  // not a date
}

Update [2018-05-31] : Wenn Sie sich nicht mit Datumsobjekten aus anderen JS-Kontexten (externen Fenstern, Frames oder Iframes) befassen, wird diese einfachere Form möglicherweise bevorzugt:

function isValidDate(d) {
  return d instanceof Date && !isNaN(d);
}

Anstatt zu verwenden new Date(), sollten Sie verwenden:

var timestamp = Date.parse('foo');

if (isNaN(timestamp) == false) {
  var d = new Date(timestamp);
}

Date.parse()Gibt einen Zeitstempel zurück, eine Ganzzahl, die die Anzahl der Millisekunden seit dem 01. Januar 1970 angibt. Es wird zurückgegeben, NaNwenn die angegebene Datumszeichenfolge nicht analysiert werden kann.

Sie können die Gültigkeit eines DateObjekts düber überprüfen

d instanceof Date && isFinite(d)

Um rahmenübergreifende Probleme zu vermeiden, könnte man die instanceofPrüfung durch ersetzen

Object.prototype.toString.call(d) === '[object Date]'

Ein Aufruf getTime()wie in Borgar Antwort ist nicht notwendig , da isNaN()und isFinite()beide konvertieren implizit Nummer.

Meine Lösung besteht darin, einfach zu überprüfen, ob Sie ein gültiges Datumsobjekt erhalten:

Implementierung

Date.prototype.isValid = function () {
    // An invalid date object returns NaN for getTime() and NaN is the only
    // object not strictly equal to itself.
    return this.getTime() === this.getTime();
};  

Verwendungszweck

var d = new Date("lol");

console.log(d.isValid()); // false

d = new Date("2012/09/11");

console.log(d.isValid()); // true

kürzeste Antwort, um das gültige Datum zu überprüfen

if(!isNaN(date.getTime()))

Sie können einfach moment.js verwenden

Hier ist ein Beispiel:

var m = moment('2015-11-32', 'YYYY-MM-DD');
m.isValid(); // false

Der Validierungsabschnitt in der Dokumentation ist ziemlich klar.

Außerdem führen die folgenden Analyseflags zu einem ungültigen Datum:

• overflow: Ein Überlauf eines Datumsfelds, z. B. ein 13. Monat, ein 32. Tag des Monats (oder ein 29. Februar bei Nicht-Schaltjahren), ein 367. Tag des Jahres usw. Überlauf enthält den Index der ungültigen Einheit um mit #invalidAt übereinzustimmen (siehe unten); -1 bedeutet kein Überlauf.
• invalidMonth: Ein ungültiger Monatsname, z. B. Moment ('Marbruary', 'MMMM');. Enthält die ungültige Monatszeichenfolge selbst oder null.
• empty: Eine Eingabezeichenfolge, die nichts Analysierbares enthält, wie z. B. Moment ('das ist Unsinn');. Boolescher Wert.
• Usw.

Quelle: http://momentjs.com/docs/

Ich möchte erwähnen, dass das jQuery UI DatePicker-Widget über eine sehr gute Datumsüberprüfungs-Dienstprogrammmethode verfügt, die das Format und die Gültigkeit überprüft (z. B. keine Datumsangaben vom 03.01.2013 zulässig).

Auch wenn Sie das Datepicker-Widget auf Ihrer Seite nicht als UI-Element verwenden möchten, können Sie die .js-Bibliothek jederzeit zu Ihrer Seite hinzufügen und dann die Validator-Methode aufrufen und den zu validierenden Wert übergeben. Um das Leben noch einfacher zu machen, wird eine Zeichenfolge als Eingabe verwendet, kein JavaScript-Datumsobjekt.

Siehe: http://api.jqueryui.com/datepicker/

Es ist nicht als Methode aufgeführt, aber es ist da - als Dienstprogrammfunktion. Durchsuchen Sie die Seite nach "parsedate" und Sie werden finden:

$ .datepicker.parseDate (Format, Wert, Einstellungen) - Extrahieren Sie ein Datum aus einem Zeichenfolgenwert mit einem angegebenen Format.

Anwendungsbeispiel:

var stringval = '01/03/2012';
var testdate;

try {
  testdate = $.datepicker.parseDate('mm/dd/yy', stringval);
             // Notice 'yy' indicates a 4-digit year value
} catch (e)
{
 alert(stringval + ' is not valid.  Format must be MM/DD/YYYY ' +
       'and the date value must be valid for the calendar.';
}

(Weitere Informationen zur Angabe von Datumsformaten finden Sie unter http://api.jqueryui.com/datepicker/#utility-parseDate )

Im obigen Beispiel wird die Warnmeldung nicht angezeigt, da '01 / 03/2012 'ein kalendergültiges Datum im angegebenen Format ist. Wenn Sie beispielsweise 'stringval' gleich '13 / 04/2013 'gemacht haben, wird die Warnmeldung angezeigt, da der Wert '13 / 04/2013' nicht für den Kalender gültig ist.

Wenn ein übergebener Zeichenfolgenwert erfolgreich analysiert wurde, ist der Wert von 'testdate' ein Javascript Date-Objekt, das den übergebenen Zeichenfolgenwert darstellt. Wenn nicht, wäre es undefiniert.

Ich mochte Christophs Ansatz sehr (hatte aber nicht genug Ruf, um darüber abzustimmen). Ich weiß, dass ich immer ein Date-Objekt haben werde, also habe ich das Datum nur mit einer valid () -Methode erweitert.

Date.prototype.valid = function() {
  return isFinite(this);
}

Jetzt kann ich das einfach schreiben und es ist viel aussagekräftiger als nur das Überprüfen von isFinite im Code ...

d = new Date(userDate);
if (d.valid()) { /* do stuff */ }

// check whether date is valid
var t = new Date('2011-07-07T11:20:00.000+00:00x');
valid = !isNaN(t.valueOf());

Mit diesem Scirpt können Sie das gültige Format von txDate.value überprüfen. Wenn es im falschen Format war, wurde das Datumsobjekt nicht instanziiert und es wurde null an dt zurückgegeben.

 var dt = new Date(txtDate.value)
 if (isNaN(dt))

Und wie @ MiF's kurz vorgeschlagen hat

 if(isNaN(new Date(...)))

Ich verwende den folgenden Code, um Werte für Jahr, Monat und Datum zu validieren.

function createDate(year, month, _date) {
  var d = new Date(year, month, _date);
  if (d.getFullYear() != year 
    || d.getMonth() != month
    || d.getDate() != _date) {
    throw "invalid date";
  }
  return d;
}

Weitere Informationen finden Sie unter Überprüfen des Datums in Javascript

Hier gibt es bereits zu viele komplizierte Antworten, aber eine einfache Zeile reicht aus (ES5):

Date.prototype.isValid = function (d) { return !isNaN(Date.parse(d)) } ;

oder sogar in ES6:

Date.prototype.isValid = d => !isNaN(Date.parse(d));

Ich habe einige Antworten gesehen, die diesem kleinen Ausschnitt sehr nahe kamen.

JavaScript-Methode:

function isValidDate(dateObject){ return new Date(dateObject).toString() !== 'Invalid Date'; }
isValidDate(new Date('WTH'));

TypeScript-Methode:

const isValidDate = dateObject => new Date(dateObject ).toString() !== 'Invalid Date';
isValidDate(new Date('WTH'));

Schöne Lösung! In meiner Bibliothek mit Hilfsfunktionen enthalten, sieht es jetzt so aus:

Object.isDate = function(obj) {
/// <summary>
/// Determines if the passed object is an instance of Date.
/// </summary>
/// <param name="obj">The object to test.</param>

    return Object.prototype.toString.call(obj) === '[object Date]';
}

Object.isValidDate = function(obj) {
/// <summary>
/// Determines if the passed object is a Date object, containing an actual date.
/// </summary>
/// <param name="obj">The object to test.</param>

    return Object.isDate(obj) && !isNaN(obj.getTime());
}

Das hat gerade bei mir funktioniert

new Date('foo') == 'Invalid Date'; //is true

Dies hat jedoch nicht funktioniert

new Date('foo') === 'Invalid Date'; //is false

Für Angular.js-Projekte können Sie Folgendes verwenden:

angular.isDate(myDate);

Keine dieser Antworten funktionierte für mich (getestet in Safari 6.0), wenn ich versuchte, ein Datum wie den 31.02.2012 zu validieren. Sie funktionieren jedoch einwandfrei, wenn ich ein Datum größer als 31 versuche.

Also musste ich ein wenig brutale Gewalt anwenden. Angenommen, das Datum hat das Format mm/dd/yyyy. Ich benutze @broox Antwort:

Date.prototype.valid = function() {
    return isFinite(this);
}    

function validStringDate(value){
    var d = new Date(value);
    return d.valid() && value.split('/')[0] == (d.getMonth()+1);
}

validStringDate("2/29/2012"); // true (leap year)
validStringDate("2/29/2013"); // false
validStringDate("2/30/2012"); // false

Keine der oben genannten Lösungen hat bei mir funktioniert, was jedoch funktioniert hat

function validDate (d) {
        var date = new Date(d);
        var day = ""+date.getDate();
        if( day.length == 1)day = "0"+day;
        var month = "" +( date.getMonth() + 1);
        if( month.length == 1)month = "0"+month;
        var year = "" + date.getFullYear();

        return ((month + "/" + day + "/" + year) == d);
    }

Der obige Code wird sehen, wenn JS den 31.02.2012 zum 02.03.2012 macht, dass er nicht gültig ist

IsValidDate: function(date) {
        var regex = /\d{1,2}\/\d{1,2}\/\d{4}/;
        if (!regex.test(date)) return false;
        var day = Number(date.split("/")[1]);
        date = new Date(date);
        if (date && date.getDate() != day) return false;
        return true;
}

Ich habe diese Funktion geschrieben. Übergeben Sie ihm einen String-Parameter und er bestimmt anhand dieses Formats "TT / MM / JJJJ", ob es sich um ein gültiges Datum handelt oder nicht.

Hier ist ein Test

Eingabe: "hahaha", Ausgabe: false.

Eingabe: "29/2/2000", Ausgabe: true.

Eingabe: "29/2/2001", Ausgabe: false.

function isValidDate(str) {
    var parts = str.split('/');
    if (parts.length < 3)
        return false;
    else {
        var day = parseInt(parts[0]);
        var month = parseInt(parts[1]);
        var year = parseInt(parts[2]);
        if (isNaN(day) || isNaN(month) || isNaN(year)) {
            return false;
        }
        if (day < 1 || year < 1)
            return false;
        if(month>12||month<1)
            return false;
        if ((month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12) && day > 31)
            return false;
        if ((month == 4 || month == 6 || month == 9 || month == 11 ) && day > 30)
            return false;
        if (month == 2) {
            if (((year % 4) == 0 && (year % 100) != 0) || ((year % 400) == 0 && (year % 100) == 0)) {
                if (day > 29)
                    return false;
            } else {
                if (day > 28)
                    return false;
            }      
        }
        return true;
    }
}

Date.prototype.toISOStringwirft RangeError(zumindest in Chromium und Firefox) auf ungültige Daten. Sie können es als Validierungsmittel verwenden und benötigen es möglicherweise nicht isValidDateals solches (EAFP). Ansonsten ist es:

function isValidDate(d)
{
  try
  {
    d.toISOString();
    return true;
  }
  catch(ex)
  {
    return false;    
  }    
}

Inspiriert von Borgars Ansatz habe ich sichergestellt, dass der Code nicht nur das Datum validiert, sondern auch sicherstellt, dass das Datum ein echtes Datum ist, was bedeutet, dass Daten wie der 31.09.2011 und der 29.02.2011 nicht zulässig sind.

function(dateStr) {
    s = dateStr.split('/');
    d = new Date(+s[2], s[1]-1, +s[0]);
    if (Object.prototype.toString.call(d) === "[object Date]") {
        if (!isNaN(d.getTime()) && d.getDate() == s[0] && 
            d.getMonth() == (s[1] - 1)) {
            return true;
        }
    }
    return "Invalid date!";
}

Ich habe die besten Leistungsergebnisse kombiniert, die ich bei dieser Prüfung gefunden habe, wenn ein bestimmtes Objekt:

• ist eine Datumsinstanz ( Benchmark hier )
• hat ein gültiges Datum ( Benchmark hier )

Das Ergebnis ist folgendes:

function isValidDate(input) {
  if(!(input && input.getTimezoneOffset && input.setUTCFullYear))
    return false;

  var time = input.getTime();
  return time === time;
};

Datumsobjekt zu Zeichenfolge ist einfacher und zuverlässiger, um festzustellen, ob beide Felder ein gültiges Datum sind. zB Wenn Sie dieses "-------" in das Datumseingabefeld eingeben. Einige der oben genannten Antworten funktionieren nicht.

jQuery.validator.addMethod("greaterThan", 

    function(value, element, params) {
        var startDate = new Date($(params).val());
        var endDate = new Date(value);

        if(startDate.toString() === 'Invalid Date' || endDate.toString() === 'Invalid Date') {
            return false;
        } else {
            return endDate > startDate;
        }
    },'Must be greater than {0}.');

Die ausgewählte Antwort ist ausgezeichnet und ich verwende sie auch. Wenn Sie jedoch nach einer Möglichkeit suchen, die Eingabe von Benutzerdaten zu überprüfen, sollten Sie sich darüber im Klaren sein, dass das Date-Objekt sehr hartnäckig ist, wenn es darum geht, scheinbar ungültige Konstruktionsargumente in gültige Argumente umzuwandeln. Der folgende Unit-Test-Code veranschaulicht den Punkt:

QUnit.test( "valid date test", function( assert ) {
  //The following are counter-examples showing how the Date object will 
  //wrangle several 'bad' dates into a valid date anyway
  assert.equal(isValidDate(new Date(1980, 12, 15)), true);
  d = new Date();
  d.setFullYear(1980);
  d.setMonth(1);
  d.setDate(33);
  assert.equal(isValidDate(d), true);
  assert.equal(isValidDate(new Date(1980, 100, 150)), true);
  //If you go to this exterme, then the checker will fail
  assert.equal(isValidDate(new Date("This is junk")), false);
  //This is a valid date string
  assert.equal(isValidDate(new Date("November 17, 1989")), true);
  //but is this?
  assert.equal(isValidDate(new Date("November 35, 1989")), false);  
  //Ha!  It's not.  So, the secret to working with this version of 
  //isValidDate is to pass in dates as text strings... Hooboy
  //alert(d.toString());
});

function isValidDate(strDate) {
    var myDateStr= new Date(strDate);
    if( ! isNaN ( myDateStr.getMonth() ) ) {
       return true;
    }
    return false;
}

Nennen Sie es so

isValidDate(""2015/5/2""); // => true
isValidDate(""2015/5/2a""); // => false

Eine fertige Funktion basierend auf der am besten bewerteten Antwort:

  /**
   * Check if date exists and is valid.
   *
   * @param {String} dateString Date in YYYY-mm-dd format.
   */
  function isValidDate(dateString) {
  var isValid = false;
  var date;

  date =
    new Date(
      dateString);

  if (
    Object.prototype.toString.call(
      date) === "[object Date]") {

    if (isNaN(date.getTime())) {

      // Date is unreal.

    } else {
      // Date is real if month and day match each other in date and string (otherwise may be shifted):
      isValid =
        date.getUTCMonth() + 1 === dateString.split("-")[1] * 1 &&
        date.getUTCDate() === dateString.split("-")[2] * 1;
    }
  } else {
    // It's not a date.
  }

  return isValid;
}

Einfache und elegante Lösung:

const date = new Date(`${year}-${month}-${day} 00:00`)
const isValidDate = (Boolean(+date) && date.getDate() == day)

Quellen:

[1] https://medium.com/@esganzerla/simple-date-validation-with-javascript-caea0f71883c

[2] Falsches Datum in neuem Datum () in JavaScript angezeigt

Ich denke, einiges davon ist ein langer Prozess. Wir können es wie unten gezeigt abkürzen:

 function isValidDate(dateString) {
        debugger;
        var dateStringSplit;
        var formatDate;

        if (dateString.length >= 8 && dateString.length<=10) {
            try {
                dateStringSplit = dateString.split('/');
                var date = new Date();
                date.setYear(parseInt(dateStringSplit[2]), 10);
                date.setMonth(parseInt(dateStringSplit[0], 10) - 1);
                date.setDate(parseInt(dateStringSplit[1], 10));

                if (date.getYear() == parseInt(dateStringSplit[2],10) && date.getMonth()+1 == parseInt(dateStringSplit[0],10) && date.getDate() == parseInt(dateStringSplit[1],10)) {
                    return true;
                }
                else {
                    return false;
                }

            } catch (e) {
                return false;
            }
        }
        return false;
    }

Für int 1-basierte Komponenten eines Datums:

var is_valid_date = function(year, month, day) {
    var d = new Date(year, month - 1, day);
    return d.getFullYear() === year && (d.getMonth() + 1) === month && d.getDate() === day
};

Tests:

    is_valid_date(2013, 02, 28)
&&  is_valid_date(2016, 02, 29)
&& !is_valid_date(2013, 02, 29)
&& !is_valid_date(0000, 00, 00)
&& !is_valid_date(2013, 14, 01)