Je voudrais faire la différence entre les objets de date valides et invalides dans JS, mais je n'ai pas pu comprendre comment:

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'

Des idées pour écrire une isValidDatefonction?

• Ash est recommandé Date.parsepour l'analyse des chaînes de date, ce qui permet de vérifier si la chaîne de date est valide.
• Ce que je préférerais, si possible, c'est que mon API accepte une instance de Date et puisse vérifier / affirmer si elle est valide ou non. La solution de Borgar le fait, mais je dois la tester sur tous les navigateurs. Je me demande également s'il existe une manière plus élégante.
• Ash m'a fait envisager de ne pas avoir du tout d'acceptation d' Dateinstances par mon API , ce serait plus facile à valider.
• Borgar a suggéré de tester une Dateinstance, puis de tester la Datevaleur de temps de. Si la date n'est pas valide, la valeur d'heure est NaN. J'ai vérifié avec ECMA-262 et ce comportement est dans la norme, c'est exactement ce que je recherche.

Voici comment je le ferais:

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
}

Mise à jour [31/05/2018] : Si vous n'êtes pas concerné par les objets Date d'autres contextes JS (fenêtres externes, cadres ou iframes), cette forme plus simple peut être préférée:

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

Au lieu d'utiliser, new Date()vous devez utiliser:

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

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

Date.parse()renvoie un horodatage, un entier représentant le nombre de millisecondes depuis 01 / Jan / 1970. Il retournera NaNs'il ne peut pas analyser la chaîne de date fournie.

Vous pouvez vérifier la validité d'un Dateobjet dvia

d instanceof Date && isFinite(d)

Pour éviter les problèmes de cross-frame, on pourrait remplacer le instanceofchèque par

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

Un appel à getTime()comme dans la réponse de Borgar est inutile car isNaN()et à la isFinite()fois convertir implicitement nombre.

Ma solution consiste à vérifier simplement si vous obtenez un objet date valide:

la mise en oeuvre

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

Usage

var d = new Date("lol");

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

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

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

réponse la plus courte pour vérifier la date de validité

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

Vous pouvez simplement utiliser moment.js

Voici un exemple:

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

La section de validation de la documentation est assez claire.

Et aussi, les indicateurs d'analyse suivants entraînent une date non valide:

• overflow: Un débordement d'un champ de date, tel qu'un 13e mois, un 32e jour du mois (ou le 29 février les années non bissextiles), un 367e jour de l'année, etc. le débordement contient l'index de l'unité non valide pour correspondre à #invalidAt (voir ci-dessous); -1 signifie pas de débordement.
• invalidMonth: Un nom de mois non valide, tel que moment ('Marbruary', 'MMMM') ;. Contient la chaîne de mois non valide elle-même, ou bien null.
• empty: Une chaîne d'entrée qui ne contient rien d'analysable, comme moment ('c'est absurde') ;. Booléen.
• Etc.

Source: http://momentjs.com/docs/

Je voudrais mentionner que le widget jQuery UI DatePicker a une très bonne méthode utilitaire de validation de date qui vérifie le format et la validité (par exemple, aucune date 01/33/2013 n'est autorisée).

Même si vous ne souhaitez pas utiliser le widget datepicker sur votre page en tant qu'élément d'interface utilisateur, vous pouvez toujours ajouter sa bibliothèque .js à votre page, puis appeler la méthode validator, en lui transmettant la valeur que vous souhaitez valider. Pour rendre la vie encore plus facile, il faut une chaîne en entrée, pas un objet Date JavaScript.

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

Ce n'est pas répertorié comme méthode, mais il est là - comme fonction d'utilité. Recherchez la page "parsedate" et vous trouverez:

$ .datepicker.parseDate (format, valeur, paramètres) - Extraire une date d'une valeur de chaîne avec un format spécifié.

Exemple d'utilisation:

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

(Plus d'informations sur la spécification des formats de date se trouvent sur http://api.jqueryui.com/datepicker/#utility-parseDate )

Dans l'exemple ci-dessus, vous ne verriez pas le message d'alerte car '01 / 03/2012 'est une date valide dans le calendrier au format spécifié. Cependant, si vous avez rendu 'stringval' égal à '13 / 04/2013 ', par exemple, vous obtiendrez le message d'alerte, car la valeur '13 / 04/2013' n'est pas valide pour le calendrier.

Si une valeur de chaîne transmise est correctement analysée, la valeur de 'testdate' serait un objet Javascript Date représentant la valeur de chaîne transmise. Sinon, ce ne serait pas défini.

J'ai vraiment aimé l'approche de Christoph (mais je n'avais pas assez de réputation pour voter). Pour mon usage, je sais que j'aurai toujours un objet Date, donc je viens de prolonger la date avec une méthode valid ().

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

Maintenant, je peux simplement écrire ceci et c'est beaucoup plus descriptif que de simplement vérifier isFinite dans le 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());

vous pouvez vérifier le format valide de txDate.value avec ce scirpt. s'il était dans un format incorrect, la date n'est pas instanciée et renvoie null à dt.

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

Et comme l'a suggéré @ MiF en bref

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

J'utilise le code suivant pour valider les valeurs de l'année, du mois et de la date.

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

Pour plus de détails, reportez-vous à Vérifier la date en javascript

Trop de réponses compliquées ici déjà, mais une simple ligne suffit (ES5):

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

ou même dans ES6:

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

J'ai vu des réponses très proches de ce petit extrait.

Manière JavaScript:

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

Manière TypeScript:

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

Bonne solution! Inclus dans ma bibliothèque de fonctions auxiliaires, il ressemble maintenant à ceci:

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

Cela a juste fonctionné pour moi

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

Mais cela n'a pas fonctionné

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

Pour les projets Angular.js, vous pouvez utiliser:

angular.isDate(myDate);

Aucune de ces réponses n'a fonctionné pour moi (testée dans Safari 6.0) lorsque vous essayez de valider une date telle que le 31/02/2012, cependant, elles fonctionnent correctement lorsque vous essayez une date supérieure à 31.

J'ai donc dû faire un peu de force brute. En supposant que la date est au format mm/dd/yyyy. J'utilise @broox answer:

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

Aucune des solutions ci-dessus n'a fonctionné pour moi.

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

le code ci-dessus verra quand JS fera le 31/02/2012 au 03/02/2012 que ce n'est pas valide

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

J'ai écrit cette fonction. Passez-lui un paramètre de chaîne et il déterminera s'il s'agit d'une date valide ou non basée sur ce format "jj / MM / aaaa".

voici un test

entrée: "hahaha", sortie: false.

entrée: "29/2/2000", sortie: vrai.

entrée: "29/2/2001", sortie: 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.toISOStringjette RangeError(au moins dans Chromium et Firefox) à des dates invalides. Vous pouvez l'utiliser comme moyen de validation et ne pas avoir besoin en isValidDatetant que tel (EAFP). Sinon c'est:

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

Inspiré par l'approche de Borgar, je me suis assuré que le code non seulement valide la date, mais s'assure en fait que la date est une date réelle, ce qui signifie que des dates comme 31/09/2011 et 29/02/2011 ne sont pas autorisées.

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

J'ai combiné les meilleurs résultats de performance que j'ai trouvés autour de cette vérification si un objet donné:

• est une instance de Date ( référence ici )
• a une date valide ( référence ici )

Le résultat est le suivant:

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

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

L'objet date à chaîne est un moyen plus simple et plus fiable de détecter si les deux champs sont une date valide. Par exemple, si vous entrez ce "-------" dans le champ de saisie de la date. Certaines des réponses ci-dessus ne fonctionneront pas.

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

La réponse choisie est excellente et je l'utilise également. Cependant, si vous cherchez un moyen de valider la saisie de la date de l'utilisateur, vous devez savoir que l'objet Date est très persistant pour transformer ce qui peut sembler être des arguments de construction non valides en arguments valides. Le code de test unitaire suivant illustre ce point:

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

Appelez ça comme ça

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

Une fonction prête basée sur la réponse la mieux notée:

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

Solution simple et élégante:

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

sources:

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

[2] Date incorrecte affichée dans la nouvelle date () en JavaScript

Je pense qu'une partie de ce processus est long. Nous pouvons le raccourcir comme indiqué ci-dessous:

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

Pour les composants basés sur int 1 d'une date:

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)