Zamiast używać new Date() należy użyć:

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

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

Date.parse() zwraca znacznik czasu, liczbę całkowitą reprezentującą liczbę milisekund od 01/Jan / 1970. Zwróci NaN, Jeśli nie przetworzy podanego ciągu daty.

Możesz sprawdzić Ważność Date obiektu d poprzez

d instanceof Date && isFinite(d)

Aby uniknąć problemów z cross-frame, można zastąpić instanceof czekiem

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

Wywołanie getTime() jak wodpowiedź Borgara jest zbędne, ponieważ isNaN() i isFinite() w domyśle przekształcają się w liczbę.

Moim rozwiązaniem jest po prostu sprawdzenie, czy masz poprawny obiekt daty:

Implementacja

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

Użycie

var d = new Date("lol");

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

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

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

Najkrótsza odpowiedź do sprawdzenia poprawnej daty

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

Możesz po prostu użyć chwila.js

Oto przykład:

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

Sekcja walidacji w dokumentacji jest dość jasna.

A także następujące znaczniki parsowania powodują nieprawidłową datę:

• overflow: przepełnienie pola daty, np. 13. miesiąc, 32. dzień miesiąca( lub 29. lutego w latach przestępnych), 367. dzień roku itp. overflow zawiera indeks nieprawidłowej jednostki do dopasowania # invalidAt (patrz niżej); -1 oznacza brak przepełnienia.
• invalidMonth: Nieprawidłowa nazwa miesiąca, np. moment('Marbruary', 'MMMM');. Zawiera sam nieprawidłowy łańcuch miesiąca lub null.
• empty: łańcuch wejściowy, który nie zawiera niczego parsowalnego, np. moment('to jest nonsens');. Boolean.
• itd.

Źródło: http://momentjs.com/docs/

Chciałbym wspomnieć, że widżet jQuery UI DatePicker ma bardzo dobrą metodę narzędzia date validator, która sprawdza format i ważność(np. dozwolone daty 01/33/2013).

Nawet jeśli nie chcesz używać widżetu datepicker na swojej stronie jako elementu interfejsu użytkownika, zawsze możesz go dodać .biblioteka js do twojej strony, a następnie wywołaj metodę walidatora, przekazując do niej wartość, którą chcesz zweryfikować. Aby uczynić życie jeszcze łatwiejszym, przyjmuje ciąg znaków jako wejście, a nie datę JavaScript obiekt.

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

Nie jest wymieniona jako metoda, ale jest tam -- jako funkcja użytkowa. Wyszukaj stronę dla "parsedate" a znajdziesz:

$.datepicker.parseDate ( format, wartość, ustawienia) - wyodrębnia datę z wartości łańcuchowej o określonym formacie.

przykład użycia:

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

(Więcej informacji na temat formatów dat znajduje się na http://api.jqueryui.com/datepicker/#utility-parseDate )

W powyższym przykładzie komunikat alertu nie będzie widoczny, ponieważ "01/03/2012" jest datą ważną w kalendarzu w określonym formacie. Jeśli jednak ustawisz' stringval 'na przykład' 13/04/2013', otrzymasz komunikat alertu, ponieważ wartość '13/04/2013' nie jest ważna w kalendarzu.

Jeśli przekazana wartość łańcuchowa zostanie pomyślnie przetworzona, wartość 'testdate' będzie obiektem Javascript Date reprezentującym passed-in string value. Jeśli nie, to będzie nieokreślone.

Bardzo spodobało mi się podejście Christopha (ale nie miałem wystarczającej reputacji, aby zagłosować). Do mojego użytku wiem, że zawsze będę miał obiekt Date, więc rozszerzyłem datę za pomocą metody valid ().

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

Teraz mogę to po prostu napisać i jest to o wiele bardziej opisowe niż tylko sprawdzanie isFinite w kodzie...

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

Używam poniższego kodu do walidacji wartości dla roku, miesiąca i daty.

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

Szczegółowe informacje można znaleźć w Check date w javascript

Zbyt wiele skomplikowanych odpowiedzi tutaj już, ale prosta linia jest wystarczająca (ES5):

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

Lub nawet w ES6:

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

Możesz sprawdzić poprawny format txDate.wartość z tym scirpt. jeśli był w nieprawidłowym formacie, Data objct nie jest instancją i zwraca null do dt .

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

I jak zasugerował @MiF w skrócie

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

Niezłe rozwiązanie! Zawarte w mojej bibliotece funkcji pomocniczych, teraz wygląda to tak:

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

Dla Kątowych.projekty js, których możesz użyć:

angular.isDate(myDate);

To po prostu działało dla mnie

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

Jednak to nie zadziałało

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

Żadne z powyższych rozwiązań nie zadziałało dla mnie, co jednak zadziałało

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

Powyższy kod zobaczy, kiedy JS zmieni 02/31/2012 na 03/02/2012, że nie jest poprawny

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

Żadna z tych odpowiedzi nie zadziałała dla mnie (testowane w Safari 6.0) podczas próby weryfikacji daty, takiej jak 2/31/2012, jednak działają dobrze, gdy próbuje datę większą niż 31.

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

Napisałem tę funkcję. Przekaż mu parametr string i określi, czy jest to ważna data, czy nie na podstawie tego formatu "dd / MM / RRRR".

Oto test

Input: "hahaha", output: false.

Input: "29/2/2000", output: true.

Input: "29/2/2001", output: 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;
    }
}

Zainspirowany podejściem Borgara upewniłem się, że kod nie tylko waliduje datę, ale w rzeczywistości upewnia się, że data jest prawdziwą datą, co oznacza, że daty takie jak 31/09/2011 i 29/02/2011 nie są dozwolone.

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

Połączyłem najlepsze wyniki wydajności, jakie znalazłem wokół tego sprawdzenia, czy dany obiekt:

• is a date instance (benchmark here)
• has a valid date ( benchmark here )

Wynik jest następujący:

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

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

Date object to string jest prostszym i bardziej niezawodnym sposobem na wykrycie, czy oba pola są poprawne date. np. jeśli w polu wprowadzania daty wpiszesz" - - - - - - -". Niektóre z powyższych odpowiedzi nie będą działać.

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}.');

Możesz przekonwertować datę i godzinę na milisekundy getTime()

This getTime() Method return Not a Number NaN when not valid

if(!isNaN(new Date("2012/25/255").getTime()))
  return 'valid date time';
  return 'Not a valid date time';

Wybrana odpowiedź jest doskonała, a ja również z niej korzystam. Jednakże, jeśli szukasz sposobu na walidację danych wejściowych użytkownika, powinieneś mieć świadomość, że obiekt Date jest bardzo trwały, jeśli chodzi o to, co może wydawać się niepoprawne argumenty konstrukcyjne, na poprawne. Poniższy kod badania jednostkowego ilustruje 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;
}

Nazwij to tak

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

Gotowa funkcja na podstawie najwyżej ocenionej odpowiedzi:

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

Myślę, że to długi proces. Możemy go skrócić, jak pokazano poniżej:

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

Dla składowych int 1 daty:

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

Testy:

    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)

Ogólnie trzymałbym się tej daty, która znajduje się w stosie przeglądarki. Oznacza to, że zawsze otrzymasz "nieprawidłową datę" podczas wywoływania toDateString() w Chrome, Firefox i Safari Od Daty tej odpowiedzi.

if(!Date.prototype.isValidDate){
  Date.prototype.isValidDate = function(){
    return this.toDateString().toLowerCase().lastIndexOf('invalid') == -1;
  };
}

function isValidDate(date) {
  return !! (Object.prototype.toString.call(date) === "[object Date]" && +date);
}