Jak sprawdzić, czy obiekt jest datą?

Mam irytujący błąd na stronie:

date.GetMonth () nie jest funkcją

Przypuszczam więc, że robię coś złego. Zmienna datenie jest obiektem typu Date. Jak mogę sprawdzić typ danych w JavaScript? Próbowałem dodać if (date), ale to nie działa.

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

Jeśli więc chcę napisać kod obronny i uniemożliwić sformatowanie daty (która nie jest jedną), jak to zrobić?

Dzięki!

AKTUALIZACJA: Nie chcę sprawdzać formatu daty, ale chcę mieć pewność, że parametr przekazany do metody getFormatedDate()jest typu Date.

Jako alternatywa dla pisania kaczką przez

typeof date.getMonth === 'function'

możesz użyć instanceofoperatora, tzn. Ale zwróci on również prawdę dla niepoprawnych dat, np. new Date('random_string')jest także instancją Date

date instanceof Date

Nie powiedzie się, jeśli obiekty zostaną przekroczone przez granice ramek.

Obejściem tego problemu jest sprawdzenie klasy obiektu za pomocą

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

Możesz użyć następującego kodu:

(myvar instanceof Date) // returns true or false

Aby sprawdzić, czy wartość jest poprawnym typem standardowego obiektu JS-date, możesz użyć tego predykatu:

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

1. datesprawdza czy parametr nie był wartość falsy ( undefined, null, 0, "", itp ..)
2. Object.prototype.toString.call(date)zwraca natywną reprezentację ciągu danego typu obiektu - w naszym przypadku "[object Date]". Ponieważ date.toString()przesłania metodę nadrzędną , musimy .calllub .applymetodę, z Object.prototypektórej bezpośrednio…
   • Pomija zdefiniowany przez użytkownika typ obiektu o tej samej nazwie konstruktora (np. „Data”)
   • Działa w różnych kontekstach JS (np. Iframe) w przeciwieństwie doinstanceof lub Date.prototype.isPrototypeOf.
3. !isNaN(date)w końcu sprawdza, czy wartość nie była Invalid Date.

Ta funkcja to getMonth()nie GetMonth().

W każdym razie możesz sprawdzić, czy obiekt ma właściwość getMonth, wykonując tę ​​czynność. Nie musi to oznaczać, że obiekt jest datą, tylko każdy obiekt, który ma właściwość getMonth.

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

Jak wskazano powyżej, prawdopodobnie najłatwiej jest po prostu sprawdzić, czy funkcja istnieje przed użyciem. Jeśli naprawdę zależy Ci na tym, aby był to obiekt Date, a nie tylko obiekt z getMonth()funkcją, spróbuj tego:

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

Spowoduje to utworzenie klonu wartości, jeśli jest Date, lub utworzenie niepoprawnej daty. Następnie możesz sprawdzić, czy wartość nowej daty jest nieprawidłowa, czy nie.

Dla wszystkich typów przygotowałem funkcję prototypu Object. Może ci się przydać

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

Teraz możesz sprawdzić dowolny typ tego typu:

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

[ Edytuj marzec 2013 ] w oparciu o postęp wglądu jest to lepsza metoda:

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 i Lodash mają wywoływaną funkcję, .isDate()która wydaje się być dokładnie tym, czego potrzebujesz. Warto przyjrzeć się ich implementacjom: Lodash isDate , UnderscoreJs

Najlepszy sposób, jaki znalazłem, to:

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

Możesz sprawdzić, czy istnieje funkcja specyficzna dla obiektu Date:

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

Zamiast wszystkich obejść można użyć następujących opcji:

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

Znalazłem ten hack lepiej!

Możesz także użyć krótkiego formularza

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

lub coś w tym stylu:

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

Korzystałem z dużo prostszego sposobu, ale nie jestem pewien, czy jest to dostępne tylko w ES6, czy nie.

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"

Nie będzie to jednak działać w przypadku wartości NULL lub niezdefiniowanej, ponieważ nie mają one konstruktora.

Ta funkcja zwróci, truejeśli jest to data lub w falseinny sposób:

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

Jeszcze inny wariant:

Date.prototype.isPrototypeOf(myDateObject)

Podejście wykorzystujące 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)));

W rzeczywistości data będzie typu Object. Ale możesz sprawdzić, czy obiekt ma getMonthmetodę i czy można ją wywoływać.

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

Możemy to również sprawdzić za pomocą poniższego kodu

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

Zainspirowane tą odpowiedzią , to rozwiązanie działa w moim przypadku (musiałem sprawdzić, czy wartość otrzymana z API jest datą, czy nie):

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

W ten sposób, jeśli jest to dowolny ciąg losowy pochodzący od klienta lub dowolnego innego obiektu, możesz dowiedzieć się, czy jest to obiekt podobny do daty.

Nie możesz po prostu użyć

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