Comment vérifier si un objet est une date?

J'ai un bug ennuyeux sur une page Web:

date.GetMonth () n'est pas une fonction

Donc, je suppose que je fais quelque chose de mal. La variable daten'est pas un objet de type Date. Comment puis-je vérifier un type de données en Javascript? J'ai essayé d'ajouter un if (date), mais cela ne fonctionne pas.

function getFormatedDate(date) {
    if (date) {
       var month = date.GetMonth();
    }
}

Donc, si je veux écrire du code défensif et empêcher la mise en forme de la date (qui n'est pas une), comment faire?

Merci!

MISE À JOUR: Je ne veux pas vérifier le format de la date, mais je veux être sûr que le paramètre passé à la méthode getFormatedDate()est de type Date.

Comme alternative à la saisie de canard via

typeof date.getMonth === 'function'

vous pouvez utiliser l' instanceofopérateur, c.-à-d. mais il retournera vrai aussi pour les dates invalides, par exemple new Date('random_string')est également une instance de Date

date instanceof Date

Cela échouera si les objets passent au-delà des limites du cadre.

Une solution consiste à vérifier la classe de l'objet via

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

Vous pouvez utiliser le code suivant:

(myvar instanceof Date) // returns true or false

Afin de vérifier si la valeur est un type valide de l'objet date JS standard, vous pouvez utiliser ce prédicat:

function isValidDate(date) {
  return date && Object.prototype.toString.call(date) === "[object Date]" && !isNaN(date);
}

1. datevérifie si le paramètre n'a pas été une valeur falsy ( undefined, null, 0, "", etc ..)
2. Object.prototype.toString.call(date)renvoie une représentation sous forme de chaîne native du type d'objet donné - Dans notre cas "[object Date]". Parce que date.toString()remplace sa méthode parente , nous devons .callou .applyla méthode à partir de Object.prototypelaquelle ..
   • Contourne le type d'objet défini par l'utilisateur avec le même nom de constructeur (par exemple: "Date")
   • Fonctionne dans différents contextes JS (par exemple les iframes) contrairement àinstanceof ou Date.prototype.isPrototypeOf.
3. !isNaN(date)vérifie enfin si la valeur n'était pas un Invalid Date.

La fonction n'est getMonth()pas GetMonth().

Quoi qu'il en soit, vous pouvez vérifier si l'objet a une propriété getMonth en procédant ainsi. Cela ne signifie pas nécessairement que l'objet est une date, juste n'importe quel objet qui a une propriété getMonth.

if (date.getMonth) {
    var month = date.getMonth();
}

Comme indiqué ci-dessus, il est probablement plus facile de vérifier simplement si la fonction existe avant de l'utiliser. Si vous vous souciez vraiment que ce soit un Date, et pas seulement un objet avec une getMonth()fonction, essayez ceci:

function isValidDate(value) {
    var dateWrapper = new Date(value);
    return !isNaN(dateWrapper.getDate());
}

Cela créera un clone de la valeur s'il s'agit d'un Date, ou créera une date non valide. Vous pouvez ensuite vérifier si la valeur de la nouvelle date n'est pas valide ou non.

Pour tous les types, j'ai préparé une fonction prototype d'objet. Cela peut vous être utile

Object.prototype.typof = function(chkType){
      var inp        = String(this.constructor),
          customObj  = (inp.split(/\({1}/))[0].replace(/^\n/,'').substr(9),
          regularObj = Object.prototype.toString.apply(this),
          thisType   = regularObj.toLowerCase()
                        .match(new RegExp(customObj.toLowerCase()))
                       ? regularObj : '[object '+customObj+']';
     return chkType
            ? thisType.toLowerCase().match(chkType.toLowerCase()) 
               ? true : false
            : thisType;
}

Vous pouvez maintenant vérifier n'importe quel type comme celui-ci:

var myDate     = new Date().toString(),
    myRealDate = new Date();
if (myRealDate.typof('Date')) { /* do things */ }
alert( myDate.typof() ); //=> String

[ Edit mars 2013 ] basé sur la progression des connaissances, c'est une meilleure méthode:

Object.prototype.is = function() {
        var test = arguments.length ? [].slice.call(arguments) : null
           ,self = this.constructor;
        return test ? !!(test.filter(function(a){return a === self}).length)
               : (this.constructor.name ||
                  (String(self).match ( /^function\s*([^\s(]+)/im)
                    || [0,'ANONYMOUS_CONSTRUCTOR']) [1] );
}
// usage
var Some = function(){ /* ... */}
   ,Other = function(){ /* ... */}
   ,some = new Some;
2..is(String,Function,RegExp);        //=> false
2..is(String,Function,Number,RegExp); //=> true
'hello'.is(String);                   //=> true
'hello'.is();                         //-> String
/[a-z]/i.is();                        //-> RegExp
some.is();                            //=> 'ANONYMOUS_CONSTRUCTOR'
some.is(Other);                       //=> false
some.is(Some);                        //=> true
// note: you can't use this for NaN (NaN === Number)
(+'ab2').is(Number);                 //=> true

UnderscoreJS et Lodash ont une fonction appelée .isDate()qui semble être exactement ce dont vous avez besoin. Cela vaut la peine de regarder leurs implémentations respectives: Lodash isDate , UnderscoreJs

La meilleure façon que j'ai trouvée est:

!isNaN(Date.parse("some date test"))
//
!isNaN(Date.parse("22/05/2001"))  // true
!isNaN(Date.parse("blabla"))  // false

Au lieu de toutes les solutions de contournement, vous pouvez utiliser les éléments suivants:

dateVariable = new Date(date);
if (dateVariable == 'Invalid Date') console.log('Invalid Date!');

J'ai trouvé ce hack meilleur!

Vous pouvez vérifier si une fonction spécifique à l'objet Date existe:

function getFormatedDate(date) {
    if (date.getMonth) {
        var month = date.getMonth();
    }
}

Vous pouvez également utiliser un formulaire court

function getClass(obj) {
  return {}.toString.call(obj).slice(8, -1);
}
alert( getClass(new Date) ); //Date

ou quelque chose comme ça:

(toString.call(date)) == 'Date'

J'utilise une méthode beaucoup plus simple, mais je ne sais pas si cela est uniquement disponible dans ES6 ou non.

let a = {name: "a", age: 1, date: new Date("1/2/2017"), arr: [], obj: {} };
console.log(a.name.constructor.name); // "String"
console.log(a.age.constructor.name);  // "Number"
console.log(a.date.constructor.name); // "Date"
console.log(a.arr.constructor.name);  // "Array"
console.log(a.obj.constructor.name);  // "Object"

Cependant, cela ne fonctionnera pas sur null ou indéfini car ils n'ont pas de constructeur.

Cette fonction retournera truesi c'est Date ou falseautrement:

function isDate(myDate) {
    return myDate.constructor.toString().indexOf("Date") > -1;
} 

Encore une autre variante:

Date.prototype.isPrototypeOf(myDateObject)

Une approche utilisant un try / catch

function getFormatedDate(date = new Date()) {
  try {
    date.toISOString();
  } catch (e) {
    date = new Date();
  }
  return date;
}

console.log(getFormatedDate());
console.log(getFormatedDate('AAAA'));
console.log(getFormatedDate(new Date('AAAA')));
console.log(getFormatedDate(new Date(2018, 2, 10)));

En fait, la date sera de type Object. Mais vous pouvez vérifier si l'objet a une getMonthméthode et s'il est appelable.

function getFormatedDate(date) {
    if (date && date.getMonth && date.getMonth.call) {
       var month = date.getMonth();
    }
}

Nous pouvons également le valider par le code ci-dessous

var a = new Date();
a.constructor === Date
/*
true
*/

Inspirée par cette réponse , cette solution fonctionne dans mon cas (j'avais besoin de vérifier si la valeur reçue de l'API est une date ou non):

!isNaN(Date.parse(new Date(YourVariable)))

De cette façon, s'il s'agit d'une chaîne aléatoire provenant d'un client ou de tout autre objet, vous pouvez savoir s'il s'agit d'un objet de type Date.

Ne pourriez-vous pas simplement utiliser

function getFormatedDate(date) {
    if (date.isValid()) {
       var month = date.GetMonth();
    }
}