Come verificare se un oggetto è una data?

Ho un fastidioso bug in una pagina web:

date.GetMonth () non è una funzione

Quindi, suppongo che sto facendo qualcosa di sbagliato. La variabile datenon è un oggetto di tipo Date. Come posso verificare un tipo di dati in Javascript? Ho provato ad aggiungere un if (date), ma non funziona.

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

Quindi, se voglio scrivere un codice difensivo e impedire la formattazione della data (che non è una), come posso farlo?

Grazie!

AGGIORNAMENTO: Non voglio controllare il formato della data, ma voglio essere sicuro che il parametro passato al metodo getFormatedDate()sia di tipo Date.

In alternativa all'anatra digitando via

typeof date.getMonth === 'function'

puoi usare l' instanceofoperatore, ad es. Ma tornerà vero anche per date non valide, ad es. new Date('random_string')è anche un'istanza di Date

date instanceof Date

Ciò fallirà se gli oggetti passano attraverso i confini del frame.

Una soluzione per questo è controllare la classe dell'oggetto tramite

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

Puoi usare il seguente codice:

(myvar instanceof Date) // returns true or false

Per verificare se il valore è un tipo valido dell'oggetto standard JS-date, è possibile utilizzare questo predicato:

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

1. datecontrolla se il parametro non è stato un valore di falsy ( undefined, null, 0, "", ecc ..)
2. Object.prototype.toString.call(date)restituisce una rappresentazione di stringa nativa del tipo di oggetto specificato - Nel nostro caso "[object Date]". Perché date.toString()sovrascrive il suo metodo genitore , dobbiamo .callo .applyil metodo Object.prototypedirettamente dal quale
   • Bypassa il tipo di oggetto definito dall'utente con lo stesso nome costruttore (ad es. "Data")
   • Funziona in contesti JS diversi (ad es. Iframe) in contrasto coninstanceof o Date.prototype.isPrototypeOf.
3. !isNaN(date)controlla infine se il valore non era un Invalid Date.

La funzione è getMonth()no GetMonth().

Ad ogni modo, puoi verificare se l'oggetto ha una proprietà getMonth in questo modo. Non significa necessariamente che l'oggetto sia una Data, ma qualsiasi oggetto che abbia una proprietà getMonth.

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

Come indicato sopra, è probabilmente più semplice verificare se la funzione esiste prima di usarla. Se ti interessa davvero che sia un Date, e non solo un oggetto con una getMonth()funzione, prova questo:

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

Questo creerà un clone del valore se è un Date, o creerà una data non valida. È quindi possibile verificare se il valore della nuova data non è valido o meno.

Per tutti i tipi ho elaborato una funzione prototipo Object. Potrebbe esserti 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;
}

Ora puoi controllare qualsiasi tipo come questo:

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

[ Modifica marzo 2013 ] sulla base delle informazioni avanzate, questo è un metodo migliore:

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 e Lodash hanno una funzione chiamata .isDate()che sembra essere esattamente ciò di cui hai bisogno. Vale la pena guardare le rispettive implementazioni: Lodash isDate , UnderscoreJs

Il modo migliore che ho trovato è:

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

Invece di tutte le soluzioni alternative è possibile utilizzare quanto segue:

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

Ho trovato questo trucco migliore!

È possibile verificare l'esistenza di una funzione specifica per l'oggetto Date:

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

Inoltre puoi usare la forma abbreviata

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

o qualcosa del genere:

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

Ho usato un modo molto più semplice ma non sono sicuro che questo sia disponibile solo in ES6 o meno.

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"

Tuttavia, questo non funzionerà su null o indefinito poiché non hanno un costruttore.

Questa funzione verrà restituita truese è Data o in falsealtro modo:

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

Ancora un'altra variante:

Date.prototype.isPrototypeOf(myDateObject)

Un approccio che utilizza un tentativo / cattura

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

In realtà la data sarà di tipo Object. Ma puoi verificare se l'oggetto ha un getMonthmetodo e se è richiamabile.

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

Possiamo anche convalidarlo con il seguente codice

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

Ispirata da questa risposta , questa soluzione funziona nel mio caso (avevo bisogno di verificare se il valore ricevuto dall'API è una data o meno):

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

In questo modo, se si tratta di una stringa casuale proveniente da un client o di qualsiasi altro oggetto, è possibile scoprire se si tratta di un oggetto simile a una data.

Non potresti semplicemente usare

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