Quel est un moyen simple de vérifier si une valeur est une date valide, n'importe quel format de date connu autorisé.

Par exemple , j'ai les valeurs 10-11-2009, 10/11/2009, 2009-11-10T07:00:00+0000qui devraient tous être reconnus comme des valeurs de date, et les valeurs 200, 10, 350qui ne doivent pas être considérés comme une valeur de date. Quelle est la manière la plus simple de vérifier cela, si cela est même possible? Parce que les horodatages seraient également autorisés.

Cela Date.parse()suffirait?

Voir sa page relative à la documentation MDN .

Mise à jour 2015

C'est une vieille question mais d'autres nouvelles questions comme:

• Comment valider si une chaîne est une date valide en js

être fermé en double de celui-ci, donc je pense qu'il est important d'ajouter de nouvelles informations ici. Je l'écris parce que j'ai eu peur de penser que les gens copient et collent une partie du code affiché ici et l'utilisent en production.

La plupart des réponses ici utilisent soit des expressions régulières complexes qui ne correspondent qu'à certains formats très spécifiques et le font en fait de manière incorrecte (comme la correspondance du 32 janvier sans correspondance avec la date ISO réelle comme annoncé - voir la démo ), soit elles essaient de transmettre quoi que ce soit au Dateconstructeur et souhaite le meilleur.

Utiliser Moment

Comme je l'ai expliqué dans cette réponse, il existe actuellement une bibliothèque disponible pour cela: Moment.js

Il s'agit d'une bibliothèque pour analyser, valider, manipuler et afficher les dates en JavaScript, qui possède une API beaucoup plus riche que les fonctions de gestion de date JavaScript standard.

Il est réduit à 12 Ko / gzippé et fonctionne dans Node.js et d'autres endroits:

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

En utilisant Moment, vous pouvez être très précis sur la vérification des dates valides. Parfois, il est très important d'ajouter quelques indices sur le format que vous attendez. Par exemple, une date telle que 22/06/2015 ressemble à une date valide, sauf si vous utilisez un format JJ / MM / AAAA, auquel cas cette date doit être rejetée comme non valide. Il existe plusieurs façons de dire à Moment à quel format vous vous attendez, par exemple:

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

L' trueargument est là, donc le Moment n'essaiera pas d'analyser l'entrée si elle n'est pas exactement conforme à l'un des formats fournis (ce devrait être un comportement par défaut à mon avis).

Vous pouvez utiliser un format fourni en interne:

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

Et vous pouvez utiliser plusieurs formats en tant que tableau:

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

Voir: DEMO .

Autres bibliothèques

Si vous ne souhaitez pas utiliser Moment.js, il existe également d'autres bibliothèques:

• XDate
• DateJS

Mise à jour 2016

J'ai créé le module immoment qui est comme (un sous-ensemble de) Moment mais sans surprise causé par la mutation d'objets existants (voir la documentation pour plus d'informations).

Mise à jour 2018

Aujourd'hui, je recommande d'utiliser Luxon pour la manipulation de date / heure au lieu de Moment, ce qui (contrairement à Moment) rend tous les objets immuables donc il n'y a pas de mauvaises surprises liées à la mutation implicite des dates.

Plus d'informations

Voir également:

• Gestion des dates et des heures à l'aide de Moment.js par Jay Raj
• Utilisation de dates JavaScript à l'aide de Moment.js par Bradley Holbrook

Une série d'articles de Rob Gravelle sur les bibliothèques d'analyse de dates JavaScript:

• Un tour d'horizon des bibliothèques d'analyse de dates JavaScript populaires: Moment.js
• Un tour d'horizon des bibliothèques JavaScript populaires d'analyse de dates: Datejs
• Un tour d'horizon des bibliothèques d'analyse de dates JavaScript populaires: XDate

Conclusion

Bien sûr, n'importe qui peut essayer de réinventer la roue, écrire une expression régulière (mais veuillez lire ISO 8601 et RFC 3339 avant de le faire) ou appeler des constructeurs intégrés avec des données aléatoires pour analyser les messages d'erreur comme 'Invalid Date'(Êtes-vous sûr que ce message est exactement la même sur toutes les plates-formes? Dans tous les pays? À l'avenir?) ou vous pouvez utiliser une solution testée et utiliser votre temps pour l'améliorer, pas la réinventer. Toutes les bibliothèques répertoriées ici sont des logiciels libres et open source.

Voici comment j'ai résolu ce problème dans une application sur laquelle je travaille en ce moment:

mis à jour sur la base des commentaires de krillgar:

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

new Date(date) === 'Invalid Date'ne fonctionne que dans Firefox et Chrome. IE8 (celui que j'ai sur ma machine à des fins de test) donne NaN.

Comme indiqué dans la réponse acceptée, Date.parse(date)fonctionnera également pour les chiffres. Donc, pour contourner cela, vous pouvez également vérifier qu'il ne s'agit pas d'un nombre (si c'est quelque chose que vous souhaitez confirmer).

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 diriez-vous quelque chose comme ça? Il testera s'il s'agit d'un objet Date ou d'une chaîne de date:

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

Je dois mentionner que cela ne teste pas les chaînes au format ISO, mais avec un peu plus de travail sur RegExp, vous devriez être bon.

Aucune des réponses ici ne permet de vérifier si la date n'est pas valide, comme le 31 février. Cette fonction corrige cela en vérifiant si le mois retourné est équivalent au mois d'origine et en s'assurant qu'une année valide a été présentée.

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

Utilisez l'expression régulière pour le valider.

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

En me référant à tous les commentaires ci-dessus, je suis parvenu à une solution.

Cela fonctionne si le Datepassé est au format ISO ou doit être manipulé pour d'autres formats.

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

Vous pouvez jouer ici sur JSFiddle.

Voici une fonction améliorée qui utilise uniquement Date.parse():

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

Remarque: Date.parse () analysera les nombres: par exemple Date.parse(1), renverra une date. Nous vérifions donc ici si ce sn'est pas un nombre, si c'est une date.

Je ferais ça

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

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

Jouez ici

Voici une version minimaliste.

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

Cette fonction appelable fonctionne parfaitement, renvoie true pour une date valide. Assurez-vous d'appeler en utilisant une date au format ISO (aaaa-mm-jj ou aaaa / mm / jj):

function validateDate(isoDate) {

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

Je sais que c'est une vieille question, mais j'ai fait face au même problème et j'ai vu qu'aucune des réponses ne fonctionnait correctement - en particulier en éliminant les nombres (1 200 345, etc.) des dates, ce qui est la question d'origine. Voici une méthode plutôt peu orthodoxe à laquelle je pourrais penser et elle semble fonctionner. Veuillez indiquer s'il y a des cas où cela échouera.

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

C'est la ligne pour éliminer les chiffres. Ainsi, la fonction entière pourrait ressembler à:

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

est-il correct de vérifier si une fonction liée à la date est disponible pour que l'objet trouve s'il s'agit d'un objet Date ou non?

comme

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

C'est ainsi que je finis par le faire. Cela ne couvrira pas tous les formats. Vous devez vous ajuster en conséquence. Je contrôle le format, donc ça marche pour moi

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, c'est une vieille question, mais j'ai trouvé une autre solution en vérifiant les solutions ici. Pour moi, cela fonctionne pour vérifier si la fonction getTime () est présente dans l'objet date:

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/[email protected]/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>

Une bibliothèque légère est prête pour vous: Day.js

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

Par défaut, ce paramètre est défini sur TRUE. Ainsi, même les chaînes de format incorrect renvoient de bonnes valeurs.

Je l'ai utilisé quelque chose comme ça:

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

Essaye ça:

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