yyyy - Détection d'une instance de date "date invalide" en JavaScript




javascript datetime format (20)

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 dans la documentation est assez claire.

De plus, les indicateurs d'analyse suivants entraînent une date non valide:

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

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

J'aimerais faire la différence entre les objets de date valides et non valides 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 fonction isValidDate ?

  • Ash a recommandé Date.parse pour 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 fait cela, mais j'ai besoin de le tester sur plusieurs navigateurs. Je me demande aussi s'il y a une manière plus élégante.
  • Ash m'a fait penser que mon API n'acceptait pas les instances de Date , ce serait plus facile à valider.
  • Borgar a suggéré de tester une instance de Date , puis de tester la valeur de l'heure de la Date . Si la date n'est pas valide, la valeur de temps est NaN . J'ai vérifié avec ECMA-262 et ce comportement est dans la norme, ce qui est exactement ce que je cherche.

Au lieu d'utiliser la 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 nombre entier représentant le nombre de millisecondes écoulées depuis le 1er janvier 1970. Il retournera NaN s'il ne peut pas analyser la chaîne de date fournie.


Aucune des solutions ci-dessus a fonctionné pour moi ce qui a fonctionné cependant

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 fait du 02/31/2012 au 03/02/2012 que ce n'est pas valide


Belle solution! Inclus dans ma bibliothèque de fonctions auxiliaires, maintenant il ressemble à 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());
}

Date de l'objet à la 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 "-------" 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}.');

En général je resterais avec n'importe quelle date d'implantation dans la pile du navigateur. Ce qui signifie que vous obtiendrez toujours une date invalide lors de l'appel de toDateString () dans Chrome, Firefox et Safari à la date de cette réponse.

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

Je n'ai pas testé cela dans IE cependant.


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

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

Le résultat est le suivant:

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

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

J'utilise le code suivant pour valider les valeurs pour l'année, le mois et 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 à la section Vérifier la date en javascript


Je pense que c'est un long processus. 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;
    }

La réponse choisie est excellente, et je l'utilise aussi. 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 sur le fait de rendre ce qui peut sembler être des arguments de construction invalides dans les arguments valides. Le code de test unitaire suivant illustre le 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());
});

Ma solution consiste simplement à vérifier si vous avez 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

Pour les projets Angular.js, vous pouvez utiliser:

angular.isDate(myDate);

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

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

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

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
}

vous pouvez convertir votre date et heure en millisecondes getTime()

cette getTime() renvoie un nombre NaN non valide

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

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

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

Et comme @ MiF suggéré de manière courte

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

// check whether date is valid
var t = new Date('2011-07-07T11:20:00.000+00:00x');
valid = !isNaN(t.valueOf());

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




date