Como verificar se um objeto é uma data?

Eu tenho um bug irritante em uma página da web:

date.GetMonth () não é uma função

Então, suponho que estou fazendo algo errado. A variável datenão é um objecto do tipo Date. Como posso verificar um tipo de dados em Javascript? Tentei adicionar um if (date), mas não funciona.

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

Então, se eu quiser escrever um código defensivo e impedir que a data (que não é uma) seja formatada, como faço isso?

Obrigado!

UPDATE: Não quero verificar o formato da data, mas quero ter certeza de que o parâmetro passado para o método getFormatedDate()é do tipo Date.

Como alternativa à digitação por pato via

typeof date.getMonth === 'function'

você pode usar o instanceofoperador, ou seja, mas também retornará true para datas inválidas, por exemplo, new Date('random_string')também é instância de Date

date instanceof Date

Isso falhará se os objetos forem passados ​​através dos limites do quadro.

Uma solução alternativa para isso é verificar a classe do objeto via

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

Você pode usar o seguinte código:

(myvar instanceof Date) // returns true or false

Para verificar se o valor é um tipo válido do objeto JS-date padrão, você pode usar este predicado:

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

1. dateverifica se o parâmetro não foi um valor Falsas ( undefined, null, 0, "", etc ..)
2. Object.prototype.toString.call(date)retorna uma representação de string nativa do tipo de objeto especificado - no nosso caso "[object Date]". Como date.toString()substitui seu método pai , precisamos .callou .applyo método Object.prototypediretamente do qual ..
   • Ignora o tipo de objeto definido pelo usuário com o mesmo nome do construtor (por exemplo: "Data")
   • Funciona em diferentes contextos JS (por exemplo, iframes) em contraste cominstanceof ou Date.prototype.isPrototypeOf.
3. !isNaN(date)finalmente verifica se o valor não era um Invalid Date.

A função é getMonth()não GetMonth().

De qualquer forma, você pode verificar se o objeto tem uma propriedade getMonth fazendo isso. Isso não significa necessariamente que o objeto é uma Data, apenas qualquer objeto que tenha uma propriedade getMonth.

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

Como indicado acima, provavelmente é mais fácil apenas verificar se a função existe antes de usá-la. Se você realmente se importa que seja um Date, e não apenas um objeto com uma getMonth()função, tente o seguinte:

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

Isso criará um clone do valor, se for um Date, ou criará uma data inválida. Você pode então verificar se o valor da nova data é inválido ou não.

Para todos os tipos, criei uma função de protótipo de objeto. Pode ser útil para você

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

Agora você pode verificar qualquer tipo como este:

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

[ Editar março de 2013 ] com base na percepção progressiva, este é um método melhor:

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

O UnderscoreJS e o Lodash têm uma função chamada .isDate()que parece ser exatamente o que você precisa. Vale a pena olhar para as respectivas implementações: Lodash isDate , UnderscoreJs

A melhor maneira que encontrei é:

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

Você pode verificar se existe uma função específica para o objeto Date:

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

Em vez de todas as soluções alternativas, você pode usar o seguinte:

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

Eu achei esse hack melhor!

Além disso, você pode usar o formulário curto

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

ou algo parecido com isto:

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

Estou usando uma maneira muito mais simples, mas não tenho certeza se isso está disponível apenas no ES6 ou não.

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"

No entanto, isso não funcionará em nulo ou indefinido, pois eles não têm construtor.

Esta função retornará truese for Data ou falsenão:

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

Ainda outra variante:

Date.prototype.isPrototypeOf(myDateObject)

Uma abordagem usando uma tentativa / captura

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

Na verdade, a data será do tipo Object. Mas você pode verificar se o objeto tem getMonthmétodo e se é possível chamar.

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

Também podemos validá-lo pelo código abaixo

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

Inspirada nesta resposta , esta solução funciona no meu caso (eu precisava verificar se o valor recebido da API é uma data ou não):

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

Dessa forma, se houver alguma sequência aleatória proveniente de um cliente ou qualquer outro objeto, você poderá descobrir se é um objeto semelhante a uma Data.

Você não poderia simplesmente usar

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