¿Cómo verificar si un objeto es una fecha?

Tengo un error molesto en una página web:

date.GetMonth () no es una función

Entonces, supongo que estoy haciendo algo mal. La variable dateno es un objeto de tipo Date. ¿Cómo puedo verificar un tipo de datos en Javascript? Intenté agregar un if (date), pero no funciona.

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

Entonces, si quiero escribir código defensivo y evitar que se formatee la fecha (que no es una), ¿cómo hago eso?

¡Gracias!

ACTUALIZACIÓN: No quiero verificar el formato de la fecha, pero quiero estar seguro de que el parámetro pasado al método getFormatedDate()es de tipo Date.

Como alternativa al tipeo de pato a través de

typeof date.getMonth === 'function'

puede usar el instanceofoperador, es decir, pero también devolverá verdadero para fechas no válidas, por ejemplo, new Date('random_string')también es instancia de Fecha

date instanceof Date

Esto fallará si los objetos se pasan a través de los límites del marco.

Una solución para esto es verificar la clase del objeto a través de

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

Puedes usar el siguiente código:

(myvar instanceof Date) // returns true or false

Para verificar si el valor es un tipo válido del objeto JS-date estándar, puede hacer uso de este predicado:

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

1. datecomprueba si el parámetro no era un valor Falsy ( undefined, null, 0, "", etc ..)
2. Object.prototype.toString.call(date)devuelve una representación de cadena nativa del tipo de objeto dado: en nuestro caso "[object Date]". Debido a que date.toString()anula su método principal , necesitamos .callo .applyel método Object.prototypedirectamente desde el cual ...
   • Omite el tipo de objeto definido por el usuario con el mismo nombre de constructor (por ejemplo: "Fecha")
   • Funciona en diferentes contextos JS (por ejemplo, iframes) en contraste coninstanceof o Date.prototype.isPrototypeOf.
3. !isNaN(date)finalmente comprueba si el valor no era un Invalid Date.

La función es getMonth(), no GetMonth().

De todos modos, puede verificar si el objeto tiene una propiedad getMonth haciendo esto. No significa necesariamente que el objeto sea una Fecha, solo cualquier objeto que tenga una propiedad getMonth.

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

Como se indicó anteriormente, probablemente sea más fácil verificar si la función existe antes de usarla. Si realmente te importa que sea un Date, y no solo un objeto con una getMonth()función, prueba esto:

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

Esto creará un clon del valor si es a Date, o creará una fecha no válida. Luego puede verificar si el valor de la nueva fecha no es válido o no.

Para todos los tipos, preparé una función de prototipo de objeto. Puede ser de utilidad para usted

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

Ahora puede verificar cualquier tipo como este:

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

[ Editar marzo de 2013 ] basado en una visión progresiva, este es un mejor método:

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 y Lodash tienen una función llamada .isDate()que parece ser exactamente lo que necesita. Vale la pena mirar sus respectivas implementaciones: Lodash isDate , UnderscoreJs

La mejor manera que encontré es:

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

En lugar de todas las soluciones, puede usar lo siguiente:

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

¡Encontré este truco mejor!

Puede verificar si existe una función específica para el objeto Fecha:

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

También puedes usar forma corta

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

o algo como esto:

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

He estado usando una forma mucho más simple, pero no estoy seguro de si esto solo está disponible en ES6 o no.

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"

Sin embargo, esto no funcionará en nulo o indefinido ya que no tienen constructor.

Esta función volverá truesi es Fecha o falseno:

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

Otra variante más:

Date.prototype.isPrototypeOf(myDateObject)

Un enfoque usando 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 realidad la fecha será de tipo Object. Pero puede verificar si el objeto tiene getMonthmétodo y si es invocable.

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

También podemos validarlo con el siguiente código

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

Inspirada en esta respuesta , esta solución funciona en mi caso (necesitaba verificar si el valor recibido de la API es una fecha o no):

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

De esta manera, si se trata de una cadena aleatoria proveniente de un cliente o de cualquier otro objeto, puede averiguar si es un objeto tipo Fecha.

¿No podrías simplemente usar

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