Gostaria de dizer a diferença entre objetos de data válidos e inválidos em JS, mas não consegui descobrir como:

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'

Alguma idéia para escrever uma isValidDatefunção?

• Ash é recomendado Date.parsepara analisar cadeias de datas, o que fornece uma maneira autorizada de verificar se a cadeia de datas é válida.
• O que eu preferiria, se possível, é fazer com que minha API aceite uma instância Date e seja capaz de verificar / afirmar se é válida ou não. A solução da Borgar faz isso, mas preciso testá-la nos navegadores. Também me pergunto se existe uma maneira mais elegante.
• Ash me fez pensar em não ter minha API aceitar Dateinstâncias, isso seria mais fácil de validar.
• Borgar sugeriu testes para uma Dateinstância e, em seguida, testes para o Datevalor de tempo do. Se a data for inválida, o valor da hora é NaN. Eu verifiquei com ECMA-262 e esse comportamento está no padrão, que é exatamente o que estou procurando.

Aqui está como eu faria isso:

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
}

Atualização [31-05-2018] : se você não estiver preocupado com objetos Date de outros contextos JS (janelas, quadros ou iframes externos), este formato mais simples pode ser preferido:

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

Em vez de usar, new Date()você deve usar:

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

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

Date.parse()retorna um registro de data e hora, um número inteiro que representa o número de milissegundos desde 01 / jan / 1970. Ele retornará NaNse não puder analisar a sequência de datas fornecida.

Você pode verificar a validade de um Dateobjeto dvia

d instanceof Date && isFinite(d)

Para evitar problemas de estrutura cruzada, pode-se substituir a instanceofverificação por

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

Uma chamada para getTime()como na resposta de Borgar é desnecessária isNaN()e isFinite()ambas implicitamente se convertem em número.

Minha solução é simplesmente verificar se você obtém um objeto de data válido:

Implementação

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

Uso

var d = new Date("lol");

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

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

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

resposta mais curta para verificar a data válida

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

Você pode simplesmente usar o moment.js

Aqui está um exemplo:

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

A seção de validação na documentação é bastante clara.

E também, os seguintes sinalizadores de análise resultam em uma data inválida:

• overflow: Um estouro de um campo de data, como um 13º mês, um 32º dia do mês (ou um 29 de fevereiro em anos não bissextos), um 367º dia do ano etc. O excesso contém o índice da unidade inválida para combinar #invalidAt (veja abaixo); -1 significa que não há excesso.
• invalidMonth: Um nome de mês inválido, como momento ('março', 'MMMM') ;. Contém a própria sequência de meses inválida ou nula.
• empty: Uma sequência de entrada que não contém nada analisável, como moment ('this is absurdo') ;. Boleano.
• Etc.

Fonte: http://momentjs.com/docs/

Gostaria de mencionar que o widget DateQuicker da interface do usuário do jQuery possui um método utilitário de validador de data muito bom que verifica o formato e a validade (por exemplo, não são permitidas datas em 01/33/2013).

Mesmo se você não quiser usar o widget datepicker em sua página como um elemento da interface do usuário, sempre poderá adicionar sua biblioteca .js à sua página e chamar o método validador, passando o valor que deseja validar para ela. Para tornar a vida ainda mais fácil, é necessária uma string como entrada, não um objeto Data JavaScript.

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

Não está listado como um método, mas está lá - como uma função de utilitário. Pesquise na página por "analisado" e você encontrará:

$ .datepicker.parseDate (formato, valor, configurações) - Extrai uma data de um valor de sequência com um formato especificado.

Exemplo de uso:

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

(Mais informações sobre a especificação de formatos de data podem ser encontradas em http://api.jqueryui.com/datepicker/#utility-parseDate )

No exemplo acima, você não veria a mensagem de alerta, já que '01 / 03/2012 'é uma data válida do calendário no formato especificado. No entanto, se você criou 'stringval' igual a '13/04/04', por exemplo, você receberia a mensagem de alerta, pois o valor '13/04/04' não é válido para o calendário.

Se um valor de string passado for analisado com êxito, o valor de 'testdate' seria um objeto Data Javascript que representa o valor da sequência passada. Caso contrário, seria indefinido.

Eu realmente gostei da abordagem de Christoph (mas não tinha reputação suficiente para votar). Para meu uso, eu sei que sempre terei um objeto Date, então apenas estendi a data com um método válido ().

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

Agora eu posso escrever isso e é muito mais descritivo do que apenas verificar isFinite no código ...

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

você pode verificar o formato válido de txDate.value com este escopo. se estiver em um formato incorreto, a data não será executada e retornará nulo para dt.

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

E como o @ MiF sugeriu de maneira curta

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

Eu uso o código a seguir para validar valores para ano, mês e data.

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

Para detalhes, consulte Verificar data em javascript

Muitas respostas complicadas aqui já, mas uma linha simples é suficiente (ES5):

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

ou mesmo no ES6:

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

Vi algumas respostas que chegaram bem perto desse pequeno trecho.

Maneira JavaScript:

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

Maneira TypeScript:

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

Ótima solução! Incluído na minha biblioteca de funções auxiliares, agora fica assim:

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

Isso só funcionou para mim

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

No entanto, isso não funcionou

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

Para projetos Angular.js, você pode usar:

angular.isDate(myDate);

Nenhuma dessas respostas funcionou para mim (testada no Safari 6.0) ao tentar validar uma data como 31/2/2012, no entanto, elas funcionam bem ao tentar qualquer data maior que 31.

Então eu tive que usar força bruta um pouco. Supondo que a data esteja no formato mm/dd/yyyy. Estou usando a resposta @broox:

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

Nenhuma das soluções acima funcionou para mim, mas o que funcionou é

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

o código acima verá quando JS faz 31/02/2012 em 02/02/2012 que não é válido

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

Eu escrevi essa função. Passe um parâmetro string e ele determinará se é uma data válida ou não com base neste formato "dd / MM / aaaa".

aqui está um teste

entrada: "hahaha", saída: false.

entrada: "29/2/2000", saída: true.

entrada: "29/2/2001", saída: 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.toISOStringlança RangeError(pelo menos no Chromium e Firefox) em datas inválidas. Você pode usá-lo como um meio de validação e pode não ser necessário isValidDate(EAFP). Caso contrário, é:

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

Inspirado pela abordagem de Borgar, assegurei-me de que o código não apenas validasse a data, mas também de que a data fosse real, o que significa que datas como 31/09/2011 e 29/02/2011 não são permitidas.

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

Combinei os melhores resultados de desempenho encontrados em torno dessa verificação se um determinado objeto:

• é uma instância de data ( referência aqui )
• tem uma data válida ( referência aqui )

O resultado é o seguinte:

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

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

O objeto Date para String é uma maneira mais simples e confiável de detectar se os dois campos são data válida. Por exemplo, se você digitar "-------" no campo de entrada da data. Algumas das respostas acima não funcionarão.

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

A resposta selecionada é excelente, e eu estou usando também. No entanto, se você estiver procurando uma maneira de validar a entrada de data do usuário, lembre-se de que o objeto Date é muito persistente ao transformar argumentos de construção inválidos em argumentos válidos. O seguinte código de teste de unidade ilustra o ponto:

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

Chame assim

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

Uma função pronta com base na resposta mais votada:

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

Solução simples e elegante:

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

fontes:

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

[2] Data incorreta mostrada na nova Data () em JavaScript

Eu acho que parte disso é um processo longo. Podemos abreviá-lo, como mostrado abaixo:

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

Para componentes baseados em int 1 de uma data:

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

Testes:

    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)