Wie überprüfe ich, ob ein Objekt ein Datum ist?

Ich habe einen nervigen Fehler auf einer Webseite:

date.GetMonth () ist keine Funktion

Also nehme ich an, dass ich etwas falsch mache. Die Variable dateist kein Objekt vom Typ Date. Wie kann ich in Javascript nach einem Datentyp suchen? Ich habe versucht, ein hinzuzufügen if (date), aber es funktioniert nicht.

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

Wie mache ich das, wenn ich defensiven Code schreiben und verhindern möchte, dass das Datum (welches nicht eines ist) formatiert wird?

Vielen Dank!

UPDATE: Ich möchte das Format des Datums nicht überprüfen, aber ich möchte sicherstellen, dass der an die Methode übergebene Parameter getFormatedDate()vom Typ ist Date.

Als Alternative zum Ententippen über

typeof date.getMonth === 'function'

Sie können den instanceofOperator verwenden, dh er gibt auch für ungültige Daten true zurück, z. B. new Date('random_string')ist auch eine Instanz von Date

date instanceof Date

Dies schlägt fehl, wenn Objekte über Rahmengrenzen hinweg übergeben werden.

Eine Problemumgehung besteht darin, die Klasse des Objekts über zu überprüfen

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

Sie können den folgenden Code verwenden:

(myvar instanceof Date) // returns true or false

Um zu überprüfen, ob der Wert ein gültiger Typ des Standard-JS-Datumsobjekts ist, können Sie dieses Prädikat verwenden:

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

1. dateüberprüft , ob der Parameter kein war falsy Wert ( undefined, null, 0, "", etc ..)
2. Object.prototype.toString.call(date)Gibt eine native Zeichenfolgendarstellung des angegebenen Objekttyps zurück. In unserem Fall "[object Date]". Da date.toString()die übergeordnete Methode überschrieben wird , müssen wir .calloder .applydie Methode Object.prototypedirekt von welcher ..
   • Umgeht einen benutzerdefinierten Objekttyp mit demselben Konstruktornamen (z. B. "Datum").
   • Funktioniert in verschiedenen JS-Kontexten (z. B. Iframes) im Gegensatz zuinstanceof oder Date.prototype.isPrototypeOf.
3. !isNaN(date)prüft schließlich, ob der Wert nicht ein war Invalid Date.

Die Funktion ist getMonth()nicht GetMonth().

Auf diese Weise können Sie überprüfen, ob das Objekt eine getMonth-Eigenschaft hat. Dies bedeutet nicht unbedingt, dass das Objekt ein Datum ist, sondern nur ein Objekt mit einer getMonth-Eigenschaft.

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

Wie oben angegeben, ist es wahrscheinlich am einfachsten, vor der Verwendung zu überprüfen, ob die Funktion vorhanden ist. Wenn es Ihnen wirklich wichtig ist, dass es sich um Dateein Objekt handelt und nicht nur um ein Objekt mit einer getMonth()Funktion, versuchen Sie Folgendes:

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

Dadurch wird entweder ein Klon des Werts erstellt, falls es sich um einen handelt Date, oder es wird ein ungültiges Datum erstellt. Sie können dann überprüfen, ob der Wert des neuen Datums ungültig ist oder nicht.

Für alle Typen habe ich eine Object-Prototyp-Funktion erstellt. Es kann für Sie von Nutzen sein

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

Jetzt können Sie jeden Typ wie folgt überprüfen :

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

[ März 2013 bearbeiten ] Basierend auf fortschreitenden Erkenntnissen ist dies eine bessere Methode:

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 und Lodash haben eine Funktion namens, .isDate()die genau das zu sein scheint, was Sie brauchen. Es lohnt sich, sich die jeweiligen Implementierungen anzusehen : Lodash isDate , UnderscoreJs

Der beste Weg, den ich gefunden habe, ist:

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

Sie können überprüfen, ob eine für das Date-Objekt spezifische Funktion vorhanden ist:

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

Anstelle aller Problemumgehungen können Sie Folgendes verwenden:

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

Ich fand diesen Hack besser!

Sie können auch eine Kurzform verwenden

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

oder so ähnlich:

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

Ich habe einen viel einfacheren Weg verwendet, bin mir aber nicht sicher, ob dies nur in ES6 verfügbar ist oder nicht.

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"

Dies funktioniert jedoch nicht mit null oder undefiniert, da sie keinen Konstruktor haben.

Diese Funktion wird zurückgegeben, truewenn es sich um ein Datum oder eine falseandere handelt:

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

Noch eine Variante:

Date.prototype.isPrototypeOf(myDateObject)

Ein Ansatz mit einem Versuch / Fang

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

Tatsächlich ist das Datum vom Typ Object. Sie können jedoch überprüfen, ob das Objekt über eine getMonthMethode verfügt und ob es aufrufbar ist.

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

Wir können es auch anhand des folgenden Codes validieren

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

Inspiriert von dieser Antwort funktioniert diese Lösung in meinem Fall (ich musste überprüfen, ob der von der API empfangene Wert ein Datum ist oder nicht):

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

Auf diese Weise können Sie herausfinden, ob es sich um ein datumsähnliches Objekt handelt, wenn es sich um eine zufällige Zeichenfolge handelt, die von einem Client oder einem anderen Objekt stammt.

Könnten Sie nicht einfach verwenden

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