Javascript 检查字符串是否为日期值

检查值是否为有效日期的简单方法是什么，允许使用任何已知的日期格式

---

例如，我有值

10-11-2009

，

10/11/2009

，

2009-11-10T07:00:00+0000

，它们都应该被识别为日期值，而值

200

，

10

，

350

，它们不应该被识别为日期值。如果可能的话，最简单的检查方法是什么？因为时间戳也是允许的。

Date.parse（）是否足够

---

看看它的亲戚。

像这样的怎么样？它将测试它是日期对象还是日期字符串：

function isDate(value) {
    var dateFormat;
    if (toString.call(value) === '[object Date]') {
        return true;
    }
    if (typeof value.replace === 'function') {
        value.replace(/^\s+|\s+$/gm, '');
    }
    dateFormat = /(^\d{1,4}[\.|\\/|-]\d{1,2}[\.|\\/|-]\d{1,4})(\s*(?:0?[1-9]:[0-5]|1(?=[012])\d:[0-5])\d\s*[ap]m)?$/;
    return dateFormat.test(value);
}

---

我应该提到的是，这并不测试ISO格式的字符串，但如果对RegExp做更多的工作，您应该会很好。

这就是我在目前正在开发的应用程序中解决此问题的方法：

根据krillgar的反馈更新：

var isDate = function(date) {
    return (new Date(date) !== "Invalid Date") && !isNaN(new Date(date));
}

新日期（Date）==“无效日期”

仅适用于Firefox和Chrome。IE8（我机器上用于测试的一个）给出了NaN

正如被接受的答案所述，

Date.parse（Date）

也适用于数字。所以为了避免这个问题，你也可以检查它不是一个数字（如果你想确认的话）

---

这是一个极简主义版本

var isDate = function (date) {
    return!!(function(d){return(d!=='Invalid Date'&&!isNaN(d))})(new Date(date));
}

---

检查对象是否可以使用日期相关函数来确定它是否为日期对象是否可以

像

2015年更新 这是一个老问题，但其他新问题如下：

作为这个的副本关闭，所以我认为在这里添加一些新信息很重要。我之所以写这篇文章，是因为我害怕人们会复制粘贴一些发布在这里的代码，并在生产中使用

这里的大多数答案都使用了一些复杂的正则表达式，这些正则表达式只匹配一些非常特定的格式，但实际上并不正确（例如匹配1月32日，而不匹配公布的实际ISO日期-请参阅）或他们试图将任何内容传递给

日期

构造函数，并希望一切顺利

利用时刻 正如我在中所解释的，目前有一个库可用于：

它是一个用JavaScript解析、验证、操作和显示日期的库，具有比标准JavaScript日期处理函数更丰富的API

它的大小为12kB/gzip，可在Node.js和其他地方使用：

bower install moment --save # bower
npm install moment --save   # npm
Install-Package Moment.js   # NuGet
spm install moment --save   # spm
meteor add momentjs:moment  # meteor

使用Moment可以非常具体地检查有效日期。有时，添加一些关于您期望的格式的线索是非常重要的。例如，日期（如2015年6月22日）看起来像是有效日期，除非您使用的格式为DD/MM/YYYY，在这种情况下，该日期应被视为无效而拒绝。有几种方法可以告诉您所期望的格式，例如：

moment("06/22/2015", "MM/DD/YYYY", true).isValid(); // true
moment("06/22/2015", "DD/MM/YYYY", true).isValid(); // false

true

参数存在，因此如果输入不完全符合所提供的格式之一（我认为这应该是默认行为），则此时不会尝试解析输入

您可以使用内部提供的格式：

moment("2015-06-22T13:17:21+0000", moment.ISO_8601, true).isValid(); // true

您可以将多种格式用作一个数组：

var formats = [
    moment.ISO_8601,
    "MM/DD/YYYY  :)  HH*mm*ss"
];
moment("2015-06-22T13:17:21+0000", formats, true).isValid(); // true
moment("06/22/2015  :)  13*17*21", formats, true).isValid(); // true
moment("06/22/2015  :(  13*17*21", formats, true).isValid(); // false

请参阅：

其他图书馆 如果您不想使用Moment.js，还有其他库：

2016年更新 我创建了一个模块，它类似于瞬间的一个子集，但没有因现有对象的变化而引起的意外（更多信息，请参阅）

2018年更新 今天，我推荐使用for date/time操纵，而不是Moment，这（与Moment不同）使所有对象都不可变，因此不会出现与日期的隐式变异相关的令人不快的意外

更多信息 另见：

• 杰伊·拉吉
• 布拉德利·霍尔布鲁克

Rob Gravelle关于JavaScript日期解析库的一系列文章：

底线 当然，任何人都可以尝试重新发明轮子，编写一个正则表达式（但请在编写之前阅读ISO 8601和RFC 3339），或者使用随机数据调用内置构造函数来解析错误消息，如

“无效日期”

（您确定此消息在所有平台上都是完全相同的吗？在所有地区？将来？或您可以使用经过测试的解决方案并利用您的时间来改进它，而不是重新发明它。这里列出的所有库都是开源的免费软件。

我会这样做

var myDateStr= new Date("2015/5/2");

if( ! isNaN ( myDateStr.getMonth() )) {
    console.log("Valid date");
}
else {
    console.log("Invalid date");
}

---

播放

此处的任何答案都不能用于检查日期是否无效（如2月31日）。此函数通过检查返回的月份是否与原始月份相等并确保提供了有效的年份来解决此问题

//expected input dd/mm/yyyy or dd.mm.yyyy or dd-mm-yyyy
function isValidDate(s) {
  var separators = ['\\.', '\\-', '\\/'];
  var bits = s.split(new RegExp(separators.join('|'), 'g'));
  var d = new Date(bits[2], bits[1] - 1, bits[0]);
  return d.getFullYear() == bits[2] && d.getMonth() + 1 == bits[1];
} 

默认情况下，该值设置为TRUE。因此，即使格式错误的字符串也会返回正确的值

我用过类似这样的方法：

SimpleDateFormat formatter = new SimpleDateFormat("yyyy/MM/dd");
formatter.setLenient(false);
String value = "1990/13/23"; 

try {
      Date date = formatter.parse(value);
      System.out.println(date);
    }catch (ParseException e) 
  {
    System.out.println("its bad");
  }

---

我就是这样做的。这不会涵盖所有格式。 你必须进行相应的调整。我可以控制格式，所以它适合我

function isValidDate(s) {
            var dt = "";
            var bits = [];
            if (s && s.length >= 6) {
                if (s.indexOf("/") > -1) {
                    bits = s.split("/");
                }
                else if (s.indexOf("-") > -1) {
                    bits = s.split("-");
                }
                else if (s.indexOf(".") > -1) {
                    bits = s.split(".");
                }
                try {
                    dt = new Date(bits[2], bits[0] - 1, bits[1]);
                } catch (e) {
                    return false;
                }
                return (dt.getMonth() + 1) === parseInt(bits[0]);
            } else {
                return false;
            }
        }

---

此可调用函数工作正常，对于有效日期返回true。 确保使用ISO格式的日期（yyyy-mm-dd或yyyy/mm/dd）进行调用：

---

我知道这是一个老问题，但我遇到了同样的问题，并看到没有一个答案能正常工作-特别是从日期中剔除数字（1200345等），这是最初的问题。这里有一个我可以想到的相当非正统的方法，它似乎有效。请指出是否有失败的情况

if(sDate.toString() == parseInt(sDate).toString()) return false;

这是删除数字的行。因此，整个函数可能如下所示：

函数isDate（sDate）{
if（sDate.toString（）==parseInt（sDate.toString（））返回false；
var tryDate=新日期（sDate）；
return（tryDate&&tryDate.toString（）！=“NaN”&&tryDate！=“无效日期”）；
}
控制台日志（“100”，isDate（100））；
控制台日志（“234”，isDate（“234”）；
log（“你好”，我
SimpleDateFormat formatter = new SimpleDateFormat("yyyy/MM/dd");
formatter.setLenient(false);
String value = "1990/13/23"; 

try {
      Date date = formatter.parse(value);
      System.out.println(date);
    }catch (ParseException e) 
  {
    System.out.println("its bad");
  }

function isValidDate(s) {
            var dt = "";
            var bits = [];
            if (s && s.length >= 6) {
                if (s.indexOf("/") > -1) {
                    bits = s.split("/");
                }
                else if (s.indexOf("-") > -1) {
                    bits = s.split("-");
                }
                else if (s.indexOf(".") > -1) {
                    bits = s.split(".");
                }
                try {
                    dt = new Date(bits[2], bits[0] - 1, bits[1]);
                } catch (e) {
                    return false;
                }
                return (dt.getMonth() + 1) === parseInt(bits[0]);
            } else {
                return false;
            }
        }

function validateDate(isoDate) {

    if (isNaN(Date.parse(isoDate))) {
        return false;
    } else {
        if (isoDate != (new Date(isoDate)).toISOString().substr(0,10)) {
            return false;
        }
    }
    return true;
}

if(sDate.toString() == parseInt(sDate).toString()) return false;

var isISO = "2018-08-01T18:30:00.000Z";

if (new Date(isISO) !== "Invalid Date" && !isNaN(new Date(isISO))) {
    if(isISO == new Date(isISO).toISOString()) {
        console.log("Valid date");
    } else {
        console.log("Invalid date");
    }
} else {
    console.log("Invalid date");
}

isDate('2018-08-01T18:30:00.000Z');

isDate(_date){
        const _regExp  = new RegExp('^(-?(?:[1-9][0-9]*)?[0-9]{4})-(1[0-2]|0[1-9])-(3[01]|0[1-9]|[12][0-9])T(2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9])(.[0-9]+)?(Z)?$');
        return _regExp.test(_date);
    }

const checkDate = new Date(dateString);

if (typeof checkDate.getTime !== 'function') {
  return;
}

function isDate(s) {
    if(isNaN(s) && !isNaN(Date.parse(s)))
        return true;
    else return false;
}

function isDate(dateStr) {
  return !isNaN(new Date(dateStr).getDate());
}

/**
 * Verify if a string is a date
 * @param {string} sDate - string that should be formatted m/d/yyyy or mm/dd/yyyy
 * @return {boolean} whether string is a valid date
 */
function isValidDate(sDate) {
  let newDate = new Date(sDate);
  console.log(sDate + " date conversion: " + newDate);
  let isDate = (!isNaN(newDate.getTime()));
  console.log(sDate + " is a date: " + isDate);
  if (isDate) {
    let firstSlash = sDate.indexOf("/");
    let secondSlash = sDate.indexOf("/",firstSlash+1);
    let originalDateString = parseInt(sDate.slice(0,firstSlash),10) + "/" + parseInt(sDate.slice(firstSlash+1,secondSlash),10) + "/" + parseInt(sDate.slice(secondSlash+1),10);
    let newDateString = (newDate.getMonth()+1) + "/" + (newDate.getDate()) + "/" + (newDate.getFullYear());
    isDate = (originalDateString == newDateString);
    console.log(originalDateString + " matches " + newDateString + ": " + isDate);
  }
  return isDate;
}