tag - undefined javascript error

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

Question

Tengo un error molesto en una página web:

date.GetMonth () no es una función

Entonces, supongo que estoy haciendo algo mal. La date variable no 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 un 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 asegurarme de que el parámetro pasado al método getFormatedDate() sea ​​de tipo Date .

Answer 1

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 una Date , y no solo un objeto con una función getMonth() , prueba esto:

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

Esto creará un clon del valor si es una Date , o creará una fecha no válida. A continuación, puede comprobar si el valor de la nueva fecha no es válido o no.

Answer 2

Como una alternativa a la escritura de pato a través de

typeof date.getMonth === ''function''

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

date instanceof Date

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

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

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

Answer 3

En realidad la fecha será de tipo Object . Pero puede verificar si el objeto tiene el método getMonth y si es llamable.

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

Answer 4

Esta función devolverá true si es fecha o false contrario:

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

Answer 5

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.

Answer 6

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

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

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

Answer 7

La mejor manera que encontré es:

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

Answer 8

No podrías simplemente usar

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

Answer 9

Otra variante más:

Date.prototype.isPrototypeOf(myDateObject)

Answer 10

Para todos los tipos cociné 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 puedes consultar cualquier tipo como este:

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

[ Edición de marzo de 2013 ] según el conocimiento progresivo, este es un método mejor:

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

Answer 11

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. date verifica si el parámetro no era un valor falso ( 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 .call o .apply el método de Object.prototype directamente que ..
   • 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 con instanceof o Date.prototype.isPrototypeOf .
3. !isNaN(date) finalmente verifica si el valor no era una Invalid Date .

Answer 12

Podrías verificar si existe una función específica para el objeto Date:

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

Answer 13

Puede utilizar el siguiente código:

(myvar instanceof Date) // returns true or false

Answer 14

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''

Answer 15

UnderscoreJS y Lodash tienen una función llamada .isDate() que parece ser exactamente lo que necesitas. Vale la pena ver sus respectivas implementaciones: Lodash isDate , UnderscoreJs