Question

我在网页上有一个恼人的错误：

date.GetMonth（）不是函数

所以，我想我做错了什么。变量date不是Date类型的对象。 如何在Javascript中检查数据类型？我尝试添加if (date)，但它不起作用。

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

所以，如果我想编写防御性代码并防止格式化日期（不是一个），我该怎么做？

谢谢！

更新：我不想检查日期的格式，但我想确保传递给方法getFormatedDate()的参数的类型为Date }。

Answer 1

通过

替代鸭子打字

typeof date.getMonth === 'function'

您可以使用instanceof运算符，即对于无效日期也会返回true，例如new Date('random_string')也是日期的实例

date instanceof Date

如果对象跨帧边界传递，则会失败。

解决这个问题的方法是通过

检查对象的类

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

Answer 2

您可以使用以下代码：

(myvar instanceof Date) // returns true or false

Answer 3

为了检查值是否是标准JS-date对象的有效类型，您可以使用此谓词：

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

date检查参数是否不是falsy value（undefined，null，0，""等。）< / LI>
Object.prototype.toString.call(date)返回给定对象类型的native string representation - 在我们的案例"[object Date]"中。由于date.toString() overrides its parent method，我们需要Object.prototype或.call直接来自!isNaN(date)的方法。
- 使用相同的构造函数名称绕过用户定义的对象类型（例如：＆＃34; Date＆＃34;）
- 适用于.apply或contrast to instanceof中不同的JS上下文（例如iframe）。
Invalid Date最后检查该值是否不是a = tf.convert_to_tensor([[1.0, 1.0, 1.0], [1.0, 2.0, 1.0], [1.0, 1.0, 1.0]], dtype=tf.float32)。

Answer 4

该功能为getMonth()，而不是GetMonth()。

无论如何，您可以通过执行此操作来检查对象是否具有getMonth属性。它并不一定意味着对象是Date，只是具有getMonth属性的任何对象。

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

Answer 5

如上所述，在使用之前检查函数是否存在可能是最简单的。如果您真的关心它是Date，而不仅仅是具有getMonth()功能的对象，请尝试以下方法：

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

如果值为Date，则会创建值的克隆，或创建无效日期。然后，您可以检查新日期的值是否无效。

Answer 6

对于所有类型我都编写了一个Object原型函数。它可能对您有用

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

现在您可以检查任何类型：

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

[ 2013年3月编辑]根据进展情况，这是一种更好的方法：

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 7

UnderscoreJS 和 Lodash 有一个名为.isDate()的功能，它看起来正是您所需要的。值得一看的是各自的实施：Lodash isDate，UnderscoreJs

Answer 8

我发现的最好方法是：

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

Answer 9

您可以检查特定于Date对象的函数是否存在：

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

Answer 10

您可以使用以下方法代替所有变通方法：

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

我发现这种黑客更好！

Answer 11

您也可以使用简短形式

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

或类似的东西：

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

Answer 12

我一直在使用更简单的方法但不确定这是否仅在ES6中可用。

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"

但是，由于它们没有构造函数，因此无法在null或undefined上工作。

Answer 13

这是一种非常简单的方法，在现有答案中不会遇到很多极端情况。

// Invalid Date.getTime() will produce NaN
if (date instanceof Date && date.getTime()) {
    console.log("is date!");
}

它不会与数字之类的其他对象一起触发，请确保该值实际上是Date（而不是看起来像一个的对象），并且避免使用Invalid Dates。

Answer 14

如果日期为true，则此函数将返回false：

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

Answer 15

使用以下方法，您甚至可以检查日期编号为“无效日期”

if(!!date.getDate()){
    console.log('date is valid')
}

Answer 16

我在 React 钩子方面遇到了一些问题，其中 Date 会稍后进入/延迟加载，然后初始状态不能为 null，它不会通过 ts 检查，但显然一个空的 Object 可以解决问题！ :)

const [birthDate, setBirthDate] = React.useState({})

<input
  value={birthDate instanceof Date ? birthDate.toISOString() : ''}
  name="birthDay"
/>

Answer 17

如果您使用的是Typescript，则可以使用Date类型进行检查：

const formatDate( date: Date ) => {}

Answer 18

受https://docs.jboss.org/hibernate/orm/5.4/userguide/html_single/Hibernate_User_Guide.html#hql的启发，此解决方案适用于我的情况（我需要检查从API接收的值是否是日期）：

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

这样，如果它是来自客户端或任何其他对象的随机字符串，则可以找出它是否是类似Date的对象。

Answer 19

我们还可以通过以下代码对其进行验证

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

Answer 20

使用try / catch的方法

curveSize = 24

Answer 21

另一种变体：

Date.prototype.isPrototypeOf(myDateObject)

Answer 22

实际上日期的类型为Object。但您可以检查对象是否具有getMonth方法以及是否可以调用。

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

Answer 23

你不能使用

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

如何检查对象是否为日期？

23 个答案: