Qual é uma maneira fácil de verificar se um valor é uma data válida, é permitido qualquer formato de data conhecido.

Por exemplo, eu tenho os valores 10-11-2009, 10/11/2009, 2009-11-10T07:00:00+0000que devem todos ser reconhecidos como valores de data e os valores 200, 10, 350, que não deve ser reconhecido como um valor de data. Qual é a maneira mais simples de verificar isso, se isso é possível? Porque os timestamps também seriam permitidos.

Seria Date.parse()suficiente?

Veja sua página relativa à documentação MDN .

Atualização de 2015

É uma pergunta antiga, mas outras perguntas novas, como:

• Como validar se uma string é uma data válida em js

ficar fechado como duplicado deste, então eu acho importante adicionar algumas informações novas aqui. Estou escrevendo porque fiquei com medo de pensar que as pessoas realmente copiam e colam parte do código postado aqui e o usam na produção.

A maioria das respostas aqui quer usar algumas expressões regulares complexas que correspondem formatos só alguns muito específicos e realmente fazê-lo de forma incorrecta (como correspondência janeiro 32, enquanto que não corresponde data ISO real como anunciado - ver demonstração ) ou eles tentam passar nada para aDate construtor e desejo o melhor.

Usando Moment

Como expliquei nesta resposta , atualmente há uma biblioteca disponível para isso: Moment.js

É uma biblioteca para analisar, validar, manipular e exibir datas em JavaScript, que possui uma API muito mais rica que as funções padrão de manipulação de datas em JavaScript.

É 12kB compactado / compactado com gz e funciona no Node.js e em outros locais:

bower install moment --save # bower
npm install moment --save   # npm
Install-Package Moment.js   # NuGet
spm install moment --save   # spm
meteor add momentjs:moment  # meteor

Usando o Moment, você pode ser muito específico sobre a verificação de datas válidas. Às vezes, é muito importante adicionar algumas dicas sobre o formato que você espera. Por exemplo, uma data como 22/06/2015 se parece com uma data válida, a menos que você use um formato DD / MM / AAAA. Nesse caso, essa data deve ser rejeitada como inválida. Existem algumas maneiras de dizer ao Moment qual formato você espera, por exemplo:

moment("06/22/2015", "MM/DD/YYYY", true).isValid(); // true
moment("06/22/2015", "DD/MM/YYYY", true).isValid(); // false

O trueargumento está lá, para que o Moment não tente analisar a entrada se não estiver exatamente de acordo com um dos formatos fornecidos (deve ser um comportamento padrão na minha opinião).

Você pode usar um formato fornecido internamente:

moment("2015-06-22T13:17:21+0000", moment.ISO_8601, true).isValid(); // true

E você pode usar vários formatos como uma matriz:

var formats = [
    moment.ISO_8601,
    "MM/DD/YYYY  :)  HH*mm*ss"
];
moment("2015-06-22T13:17:21+0000", formats, true).isValid(); // true
moment("06/22/2015  :)  13*17*21", formats, true).isValid(); // true
moment("06/22/2015  :(  13*17*21", formats, true).isValid(); // false

Veja: DEMO .

Outras bibliotecas

Se você não deseja usar o Moment.js, também existem outras bibliotecas:

• XDate
• DateJS

Atualização de 2016

Criei o módulo imoment que é como (um subconjunto de) Momento, mas sem surpresas causadas pela mutação de objetos existentes (consulte a documentação para obter mais informações).

Atualização de 2018

Hoje, recomendo usar o Luxon para manipulação de data / hora em vez de Moment, o que (diferentemente do Moment) torna todo objeto imutável, para que não haja surpresas desagradáveis ​​relacionadas à mutação implícita de datas.

Mais informações

Veja também:

• Gerenciando datas e horas usando o Moment.js por Jay Raj
• Trabalhando com datas do JavaScript usando o Moment.js por Bradley Holbrook

Uma série de artigos de Rob Gravelle nas bibliotecas de análise de datas do JavaScript:

• Um resumo das bibliotecas populares de análise de data JavaScript: Moment.js
• Um resumo das bibliotecas populares de análise de data JavaScript: Datejs
• Um resumo das bibliotecas populares de análise de data JavaScript: XDate

Bottom line

É claro que qualquer um pode tentar reinventar a roda, escrever uma expressão regular (mas , na verdade, leia ISO 8601 e RFC 3339 antes de fazê-lo) ou chame construtores de buit-in com dados aleatórios para analisar mensagens de erro como 'Invalid Date'(Tem certeza de que esta mensagem é exatamente o mesmo em todas as plataformas? Em todos os locais? No futuro?) ou você pode usar uma solução testada e usar seu tempo para aprimorá-la, não reinventá-la. Todas as bibliotecas listadas aqui são software livre e de código aberto.

Foi assim que resolvi esse problema em um aplicativo no qual estou trabalhando agora:

atualizado com base nos comentários da krillgar:

var isDate = function(date) {
    return (new Date(date) !== "Invalid Date") && !isNaN(new Date(date));
}

new Date(date) === 'Invalid Date'só funciona no Firefox e Chrome. O IE8 (o que eu tenho na minha máquina para fins de teste) fornece NaN.

Como foi afirmado na resposta aceita, Date.parse(date)também funcionará para números. Portanto, para contornar isso, você também pode verificar se não é um número (se é algo que você deseja confirmar).

var parsedDate = Date.parse(date);

// You want to check again for !isNaN(parsedDate) here because Dates can be converted
// to numbers, but a failed Date parse will not.
if (isNaN(date) && !isNaN(parsedDate)) {
    /* do your work */
}

Que tal algo como isso? Ele testará se é um objeto Date ou uma string de data:

function isDate(value) {
    var dateFormat;
    if (toString.call(value) === '[object Date]') {
        return true;
    }
    if (typeof value.replace === 'function') {
        value.replace(/^\s+|\s+$/gm, '');
    }
    dateFormat = /(^\d{1,4}[\.|\\/|-]\d{1,2}[\.|\\/|-]\d{1,4})(\s*(?:0?[1-9]:[0-5]|1(?=[012])\d:[0-5])\d\s*[ap]m)?$/;
    return dateFormat.test(value);
}

Devo mencionar que isso não testa cadeias de caracteres formatadas em ISO, mas com um pouco mais de trabalho no RegExp você deve ser bom.

Nenhuma das respostas aqui aborda a verificação se a data é inválida, como 31 de fevereiro. Esta função aborda isso verificando se o mês retornado é equivalente ao mês original e certificando-se de que um ano válido foi apresentado.

//expected input dd/mm/yyyy or dd.mm.yyyy or dd-mm-yyyy
function isValidDate(s) {
  var separators = ['\\.', '\\-', '\\/'];
  var bits = s.split(new RegExp(separators.join('|'), 'g'));
  var d = new Date(bits[2], bits[1] - 1, bits[0]);
  return d.getFullYear() == bits[2] && d.getMonth() + 1 == bits[1];
} 

Use Expressão regular para validá-la.

isDate('2018-08-01T18:30:00.000Z');

isDate(_date){
        const _regExp  = new RegExp('^(-?(?:[1-9][0-9]*)?[0-9]{4})-(1[0-2]|0[1-9])-(3[01]|0[1-9]|[12][0-9])T(2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9])(.[0-9]+)?(Z)?$');
        return _regExp.test(_date);
    }

Ao me referir a todos os comentários acima, cheguei a uma solução.

Isso funciona se o Datepassado estiver no formato ISO ou precisar manipular para outros formatos.

var isISO = "2018-08-01T18:30:00.000Z";

if (new Date(isISO) !== "Invalid Date" && !isNaN(new Date(isISO))) {
    if(isISO == new Date(isISO).toISOString()) {
        console.log("Valid date");
    } else {
        console.log("Invalid date");
    }
} else {
    console.log("Invalid date");
}

Você pode jogar aqui no JSFiddle.

Aqui está uma função aprimorada que usa apenas Date.parse():

function isDate(s) {
    if(isNaN(s) && !isNaN(Date.parse(s)))
        return true;
    else return false;
}

Nota: Date.parse () analisará os números: por exemplo Date.parse(1), retornará uma data. Então aqui verificamos se snão é um número, se é uma data.

Eu faria isso

var myDateStr= new Date("2015/5/2");

if( ! isNaN ( myDateStr.getMonth() )) {
    console.log("Valid date");
}
else {
    console.log("Invalid date");
}

Jogue aqui

Aqui está uma versão minimalista.

var isDate = function (date) {
    return!!(function(d){return(d!=='Invalid Date'&&!isNaN(d))})(new Date(date));
}

Esta função solicitável funciona perfeitamente, retorna true para data válida. Certifique-se de ligar usando uma data no formato ISO (aaaa-mm-dd ou aaaa / mm / dd):

function validateDate(isoDate) {

    if (isNaN(Date.parse(isoDate))) {
        return false;
    } else {
        if (isoDate != (new Date(isoDate)).toISOString().substr(0,10)) {
            return false;
        }
    }
    return true;
}

Sei que é uma pergunta antiga, mas enfrentei o mesmo problema e vi que nenhuma das respostas funcionava corretamente - eliminando números (1.200.345 etc.) de datas, que é a pergunta original. Aqui está um método pouco ortodoxo em que pude pensar e parece funcionar. Por favor, indique se há casos em que ele falhará.

if(sDate.toString() == parseInt(sDate).toString()) return false;

Esta é a linha para eliminar números. Assim, toda a função pode se parecer com:

function isDate(sDate) {  
  if(sDate.toString() == parseInt(sDate).toString()) return false; 
  var tryDate = new Date(sDate);
  return (tryDate && tryDate.toString() != "NaN" && tryDate != "Invalid Date");  
}

console.log("100", isDate(100));
console.log("234", isDate("234"));
console.log("hello", isDate("hello"));
console.log("25 Feb 2018", isDate("25 Feb 2018"));
console.log("2009-11-10T07:00:00+0000", isDate("2009-11-10T07:00:00+0000"));

é bom verificar se uma função relacionada à data está disponível para o objeto descobrir se é um objeto de data ou não?

gostar

var l = new Date();
var isDate = (l.getDate !== undefined) ? true; false;

É assim que acabo fazendo isso. Isso não cobrirá todos os formatos. Você tem que ajustar em conformidade. Eu tenho controle sobre o formato, então funciona para mim

function isValidDate(s) {
            var dt = "";
            var bits = [];
            if (s && s.length >= 6) {
                if (s.indexOf("/") > -1) {
                    bits = s.split("/");
                }
                else if (s.indexOf("-") > -1) {
                    bits = s.split("-");
                }
                else if (s.indexOf(".") > -1) {
                    bits = s.split(".");
                }
                try {
                    dt = new Date(bits[2], bits[0] - 1, bits[1]);
                } catch (e) {
                    return false;
                }
                return (dt.getMonth() + 1) === parseInt(bits[0]);
            } else {
                return false;
            }
        }

Ok, essa é uma pergunta antiga, mas encontrei outra solução enquanto verifica as soluções aqui. Para mim trabalha para verificar se a função getTime () está presente no objeto de data:

const checkDate = new Date(dateString);

if (typeof checkDate.getTime !== 'function') {
  return;
}

document.getElementById('r1').innerHTML = dayjs('sdsdsd').isValid()

document.getElementById('r2').innerHTML = dayjs('2/6/20').isValid()

<script src="https://unpkg.com/dayjs@1.8.21/dayjs.min.js"></script>

<p>'sdsdsd' is a date: <span id="r1"></span></p>
<p>'2/6/20' is a date: <span id="r2"></span></p>

Uma biblioteca leve está pronta para você: Day.js

SimpleDateFormat sdf = new SimpleDateFormat(dateFromat);
sdf.setLenient(false);

Por padrão, isso é definido como TRUE. Assim, mesmo seqüências de caracteres de formato incorreto retornam bons valores.

Eu usei algo assim:

SimpleDateFormat formatter = new SimpleDateFormat("yyyy/MM/dd");
formatter.setLenient(false);
String value = "1990/13/23"; 

try {
      Date date = formatter.parse(value);
      System.out.println(date);
    }catch (ParseException e) 
  {
    System.out.println("its bad");
  }

Tente o seguinte:

if (var date = new Date(yourDateString)) {
    // if you get here then you have a valid date       
}