我想告诉JS中有效和无效日期对象之间的区别，但无法弄清楚如何：
var d = new Date("foo");
console.log(d.toString()); // shows 'Invalid Date'
console.log(typeof d); // shows 'object'
console.log(d instanceof Date); // shows 'true'
编写isValidDate函数的任何想法？
Date.parse解析日期字符串，这提供了一种检查日期字符串是否有效的权威方法。Date实例，这最容易验证。Date实例，然后测试Date的时间值。如果日期无效，则时间值为NaN。我检查了ECMA-262，这种行为符合标准，这正是我正在寻找的。
答案 0 :(得分：1063)
我将如何做到这一点：
if (Object.prototype.toString.call(d) === "[object Date]") {
// it is a date
if (isNaN(d.getTime())) { // d.valueOf() could also work
// date is not valid
} else {
// date is valid
}
} else {
// not a date
}
更新[2018-05-31] ：如果您不关心来自其他JS上下文（外部窗口，框架或iframe）的Date对象，可能更喜欢这种更简单的形式：
function isValidDate(d) {
return d instanceof Date && !isNaN(d);
}
答案 1 :(得分：236)
您应该使用：
，而不是使用new Date()
var timestamp = Date.parse('foo');
if (isNaN(timestamp) == false) {
var d = new Date(timestamp);
}
Date.parse()返回一个时间戳，一个整数，表示自01 / Jan / 1970以来的毫秒数。如果它无法解析提供的日期字符串，它将返回NaN。
答案 2 :(得分：98)
您可以通过
检查Date对象d的有效性
d instanceof Date && isFinite(d)
为避免跨框架问题，可以用
替换instanceof支票
Object.prototype.toString.call(d) === '[object Date]'
getTime()中的isNaN()来电是不必要的，因为isFinite()和{{1}}都隐式转换为数字。
答案 3 :(得分：75)
我的解决方案是简单地检查您是否获得了有效的日期对象：
Date.prototype.isValid = function () {
// An invalid date object returns NaN for getTime() and NaN is the only
// object not strictly equal to itself.
return this.getTime() === this.getTime();
};
var d = new Date("lol");
console.log(d.isValid()); // false
d = new Date("2012/09/11");
console.log(d.isValid()); // true
答案 4 :(得分：62)
检查有效日期的最短答案
if(!isNaN(date.getTime()))
答案 5 :(得分：42)
以下是一个例子：
var m = moment('2015-11-32', 'YYYY-MM-DD');
m.isValid(); // false
文档中的validation section非常清楚。
此外，以下解析标志会导致无效日期：
overflow：日期字段溢出，例如第13个月，第32个月（或非闰年2月29日），一年中第367天等。 overflow包含匹配#invalidAt的无效单元的索引（见下文）; -1表示没有溢出。invalidMonth：无效的月份名称，例如片刻（＆＃39; Marbruary＆＃39;，＆＃39; MMMM＆＃39;）;.包含无效的月份字符串本身，否则为null。empty：一个输入字符串，不包含任何可解析的内容，例如片刻（＆＃39;这是无意义的＆＃39;）;.布尔值。答案 6 :(得分：37)
想提一下，jQuery UI DatePicker小部件有一个非常好的日期验证器实用程序方法，用于检查格式和有效性（例如，不允许01/33/2013日期）。
即使您不想将页面上的datepicker小部件用作UI元素，也可以始终将其.js库添加到页面中，然后调用验证器方法，将要验证的值传递给它。为了让生活更轻松，它需要一个字符串作为输入，而不是JavaScript Date对象。
请参阅：http://api.jqueryui.com/datepicker/
它没有被列为一种方法，但它就是 - 作为一种效用函数。在页面中搜索“parsedate”，你会发现：
$。datepicker.parseDate（format，value，settings） - 从具有指定格式的字符串值中提取日期。
示例用法：
var stringval = '01/03/2012';
var testdate;
try {
testdate = $.datepicker.parseDate('mm/dd/yy', stringval);
// Notice 'yy' indicates a 4-digit year value
} catch (e)
{
alert(stringval + ' is not valid. Format must be MM/DD/YYYY ' +
'and the date value must be valid for the calendar.';
}
（更多信息请在http://api.jqueryui.com/datepicker/#utility-parseDate找到日期格式）
在上面的示例中，您不会看到警告消息，因为'01 / 03/2012'是指定格式的日历有效日期。但是，如果您将'stringval'等于'13 / 04/2013'，则会收到警告消息，因为值'13 / 04/2013'不是日历有效的。
如果成功解析了传入的字符串值，则'testdate'的值将是表示传入字符串值的Javascript Date对象。如果没有，那就不确定了。
答案 7 :(得分：22)
我真的很喜欢克里斯托夫的做法（但没有足够的声誉来投票）。 对于我的使用，我知道我将始终有一个Date对象，所以我只使用valid（）方法扩展日期。
Date.prototype.valid = function() {
return isFinite(this);
}
现在我可以写这个，它比仅仅在代码中检查isFinite更具描述性......
d = new Date(userDate);
if (d.valid()) { /* do stuff */ }
答案 8 :(得分：19)
// check whether date is valid
var t = new Date('2011-07-07T11:20:00.000+00:00x');
valid = !isNaN(t.valueOf());
答案 9 :(得分：15)
我使用以下代码验证年，月和日期的值。
function createDate(year, month, _date) {
var d = new Date(year, month, _date);
if (d.getFullYear() != year
|| d.getMonth() != month
|| d.getDate() != _date) {
throw "invalid date";
}
return d;
}
有关详细信息，请参阅Check date in javascript
答案 10 :(得分：13)
这里有太多复杂的答案，但一条简单的线就足够了（ES5）：
valueSeq甚至在ES6中：
Date.prototype.isValid = function (d) { return !isNaN(Date.parse(d)) } ;
答案 11 :(得分：12)
您可以使用此scirpt检查txDate.value的有效格式。如果格式不正确，则Date obejct未实例化，并返回null为dt。
var dt = new Date(txtDate.value)
if (isNaN(dt))
正如@ MiF的简短建议
if(isNaN(new Date(...)))
答案 12 :(得分：9)
对于Angular.js项目，您可以使用：
Coalesce(NullIf(t2.[ParentCode], ''), t1.[Code]) AS [ParentCode]
Coalesce(NullIf([Descr], ''), [Code]) AS [Descr]
答案 13 :(得分：9)
很好的解决方案！包含在我的辅助函数库中，现在看起来像这样：
Object.isDate = function(obj) {
/// <summary>
/// Determines if the passed object is an instance of Date.
/// </summary>
/// <param name="obj">The object to test.</param>
return Object.prototype.toString.call(obj) === '[object Date]';
}
Object.isValidDate = function(obj) {
/// <summary>
/// Determines if the passed object is a Date object, containing an actual date.
/// </summary>
/// <param name="obj">The object to test.</param>
return Object.isDate(obj) && !isNaN(obj.getTime());
}
答案 14 :(得分：7)
这对我有用
new Date('foo') == 'Invalid Date'; //is true
然而这不起作用
new Date('foo') === 'Invalid Date'; //is false
答案 15 :(得分：6)
在尝试验证日期（例如2/31/2012）时，这些答案都不适用于我（在Safari 6.0中测试过），但是，当尝试任何大于31的日期时，它们都能正常工作。
所以我不得不蛮力一点。假设日期的格式为mm/dd/yyyy。我正在使用@broox答案：
Date.prototype.valid = function() {
return isFinite(this);
}
function validStringDate(value){
var d = new Date(value);
return d.valid() && value.split('/')[0] == (d.getMonth()+1);
}
validStringDate("2/29/2012"); // true (leap year)
validStringDate("2/29/2013"); // false
validStringDate("2/30/2012"); // false
答案 16 :(得分：5)
IsValidDate: function(date) {
var regex = /\d{1,2}\/\d{1,2}\/\d{4}/;
if (!regex.test(date)) return false;
var day = Number(date.split("/")[1]);
date = new Date(date);
if (date && date.getDate() != day) return false;
return true;
}
答案 17 :(得分：5)
上述解决方案都没有为我工作但是工作是什么
function validDate (d) {
var date = new Date(d);
var day = ""+date.getDate();
if( day.length == 1)day = "0"+day;
var month = "" +( date.getMonth() + 1);
if( month.length == 1)month = "0"+month;
var year = "" + date.getFullYear();
return ((month + "/" + day + "/" + year) == d);
}
上面的代码将看到JS何时将02/31/2012变为03/02/2012，它无效
答案 18 :(得分：4)
我已经写过这个功能了。传递一个字符串参数，它将根据这种格式确定它是否是一个有效的日期＆＃34; dd / MM / yyyy＆＃34;。
这是一个测试
输入：＆＃34;哈哈哈＆＃34;，输出：false。
输入：＆＃34; 29/2/2000＆＃34 ;,输出：true。
输入：＆＃34; 29/2/1001＆＃34 ;,输出：false。
function isValidDate(str) {
var parts = str.split('/');
if (parts.length < 3)
return false;
else {
var day = parseInt(parts[0]);
var month = parseInt(parts[1]);
var year = parseInt(parts[2]);
if (isNaN(day) || isNaN(month) || isNaN(year)) {
return false;
}
if (day < 1 || year < 1)
return false;
if(month>12||month<1)
return false;
if ((month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12) && day > 31)
return false;
if ((month == 4 || month == 6 || month == 9 || month == 11 ) && day > 30)
return false;
if (month == 2) {
if (((year % 4) == 0 && (year % 100) != 0) || ((year % 400) == 0 && (year % 100) == 0)) {
if (day > 29)
return false;
} else {
if (day > 28)
return false;
}
}
return true;
}
}
答案 19 :(得分：3)
还没有人提到它，所以符号也可以成为一种方式：
Symbol.for(new Date("Peter")) === Symbol.for("Invalid Date") // true
Symbol.for(new Date()) === Symbol.for("Invalid Date") // false
console.log('Symbol.for(new Date("Peter")) === Symbol.for("Invalid Date")', Symbol.for(new Date("Peter")) === Symbol.for("Invalid Date")) // true
console.log('Symbol.for(new Date()) === Symbol.for("Invalid Date")', Symbol.for(new Date()) === Symbol.for("Invalid Date")) // false
答案 20 :(得分：3)
我结合了我发现的最佳性能结果，检查了一个给定的对象：
结果如下：
function isValidDate(input) {
if(!(input && input.getTimezoneOffset && input.setUTCFullYear))
return false;
var time = input.getTime();
return time === time;
};
答案 21 :(得分：3)
受Borgar方法的启发，我确保代码不仅验证了日期，而且实际上确保日期是真实日期，这意味着不允许日期为31/09/2011和29/02/2011。
function(dateStr) {
s = dateStr.split('/');
d = new Date(+s[2], s[1]-1, +s[0]);
if (Object.prototype.toString.call(d) === "[object Date]") {
if (!isNaN(d.getTime()) && d.getDate() == s[0] &&
d.getMonth() == (s[1] - 1)) {
return true;
}
}
return "Invalid date!";
}
答案 22 :(得分：2)
我很少推荐可以不用的库。但考虑到迄今为止的众多答案，似乎值得指出的是流行的库“date-fns”有一个函数 isValid。
答案 23 :(得分：2)
在阅读到目前为止的每个答案后，我将提供最简单的答案。
这里的每个解决方案都提到调用 date.getTime()。但是，这不是必需的，因为从 Date 到 Number 的默认转换是使用 getTime() 值。是的，您的类型检查会抱怨。 :) 而且 OP cleary 知道他们有一个 Date 对象，因此也无需对此进行测试。
要测试无效日期：
isNaN(date)
要测试有效日期：
!isNaN(date)
答案 24 :(得分：2)
基于最高评级答案的就绪功能：
/**
* Check if date exists and is valid.
*
* @param {String} dateString Date in YYYY-mm-dd format.
*/
function isValidDate(dateString) {
var isValid = false;
var date;
date =
new Date(
dateString);
if (
Object.prototype.toString.call(
date) === "[object Date]") {
if (isNaN(date.getTime())) {
// Date is unreal.
} else {
// Date is real if month and day match each other in date and string (otherwise may be shifted):
isValid =
date.getUTCMonth() + 1 === dateString.split("-")[1] * 1 &&
date.getUTCDate() === dateString.split("-")[2] * 1;
}
} else {
// It's not a date.
}
return isValid;
}
答案 25 :(得分：2)
function isValidDate(strDate) {
var myDateStr= new Date(strDate);
if( ! isNaN ( myDateStr.getMonth() ) ) {
return true;
}
return false;
}
像这样称呼
isValidDate(""2015/5/2""); // => true
isValidDate(""2015/5/2a""); // => false
答案 26 :(得分：2)
日期对象到字符串是检测两个字段是否为有效日期的更简单可靠的方法。 例如如果在日期输入字段中输入“-------”。上面的一些答案是行不通的。
jQuery.validator.addMethod("greaterThan",
function(value, element, params) {
var startDate = new Date($(params).val());
var endDate = new Date(value);
if(startDate.toString() === 'Invalid Date' || endDate.toString() === 'Invalid Date') {
return false;
} else {
return endDate > startDate;
}
},'Must be greater than {0}.');
答案 27 :(得分：2)
选择的答案非常好，我也在使用它。但是，如果您正在寻找一种验证用户日期输入的方法，您应该知道Date对象非常持久地将看似无效的构造参数变为有效的构造参数。以下单元测试代码说明了这一点：
QUnit.test( "valid date test", function( assert ) {
//The following are counter-examples showing how the Date object will
//wrangle several 'bad' dates into a valid date anyway
assert.equal(isValidDate(new Date(1980, 12, 15)), true);
d = new Date();
d.setFullYear(1980);
d.setMonth(1);
d.setDate(33);
assert.equal(isValidDate(d), true);
assert.equal(isValidDate(new Date(1980, 100, 150)), true);
//If you go to this exterme, then the checker will fail
assert.equal(isValidDate(new Date("This is junk")), false);
//This is a valid date string
assert.equal(isValidDate(new Date("November 17, 1989")), true);
//but is this?
assert.equal(isValidDate(new Date("November 35, 1989")), false);
//Ha! It's not. So, the secret to working with this version of
//isValidDate is to pass in dates as text strings... Hooboy
//alert(d.toString());
});
答案 28 :(得分：2)
您可以将日期和时间转换为毫秒getTime()
此getTime()方法无效时返回不是数字NaN
if(!isNaN(new Date("2012/25/255").getTime()))
return 'valid date time';
return 'Not a valid date time';
答案 29 :(得分：1)
一般来说，我会坚持使用浏览器堆栈中的日期植入。这意味着，自此回复日期起，在Chrome，Firefox和Safari中调用 toDateString（）时，您将始终获得“无效日期”。
if(!Date.prototype.isValidDate){
Date.prototype.isValidDate = function(){
return this.toDateString().toLowerCase().lastIndexOf('invalid') == -1;
};
}
我没有在IE中测试过这个。
答案 30 :(得分：1)
我认为其中一些是漫长的过程。我们可以缩短它，如下所示：
function isValidDate(dateString) {
debugger;
var dateStringSplit;
var formatDate;
if (dateString.length >= 8 && dateString.length<=10) {
try {
dateStringSplit = dateString.split('/');
var date = new Date();
date.setYear(parseInt(dateStringSplit[2]), 10);
date.setMonth(parseInt(dateStringSplit[0], 10) - 1);
date.setDate(parseInt(dateStringSplit[1], 10));
if (date.getYear() == parseInt(dateStringSplit[2],10) && date.getMonth()+1 == parseInt(dateStringSplit[0],10) && date.getDate() == parseInt(dateStringSplit[1],10)) {
return true;
}
else {
return false;
}
} catch (e) {
return false;
}
}
return false;
}
答案 31 :(得分：1)
在我之前尝试过这么多人之后，为什么我要写第 48 个答案？
用于检查它是否是日期对象，然后是一个有效的日期对象 - 非常简单：
return x instanceof Date && !!x.getDate();
现在解析日期文本：大多数解决方案使用Date.parse()或“new Date()”，两者都有问题。 JavaScript 解析各种各样的格式，并且还依赖于本地化。例如，像“1”和“blah-123”这样的字符串将被解析为有效日期。
然后有使用大量代码的响应，或一英里长的 RegEx，或使用 moment 或其他一些框架 - 所有这些都不是理想的恕我直言对于这么简单的事情。
如果您一直浏览到最后，希望你们中的一些人会喜欢这种验证日期字符串的简单方法。诀窍是使用一个简单的 Regex 来消除不需要的格式，然后如果通过，使用 Date.parse()。失败的解析会导致 NaN，这是“假的”。这 ”！！”将其转换为布尔值“false”。
function isDate(txt) { //this regx matches dates from 01/01/2000 - 12/31/2099
return /^\d?\d\/\d?\d\/20\d\d$/.test(txt) && !!Date.parse(txt);
}TEST THE FUNCTION
<br /><br />
<input id="dt" value = "12/21/2020">
<input type="button" value="validate" id="btnAction" onclick="document.getElementById('rslt').innerText = isDate(document.getElementById('dt').value)">
<br /><br />
Result: <span id="rslt"></span>答案 32 :(得分：1)
也许我迟到了，但我有一个解决方案。
const isInvalidDate = (dateString) => JSON.stringify(new Date(dateString)) === 'null';
const invalidDate = new Date('Hello');
console.log(isInvalidDate(invalidDate)); //true
const validDate = new Date('2021/02/08');
console.log(isInvalidDate(validDate)); //false
答案 33 :(得分：1)
为什么我建议moment.js
这是非常受欢迎的图书馆
简单地解决所有日期和时间，格式，时区问题
易于检查字符串日期是否有效
var date = moment("2016-10-19");
date.isValid()
我们无法通过简单的方法来验证所有案例
失望
如果我输入有效数字，例如89,90,95 上面的answare中有新的Date（），我得到了不好的结果，但是它返回true
const isValidDate = date => {
console.log('input'+date)
var date=new Date(date);
console.log(date)
return !! (Object.prototype.toString.call(date) === "[object Date]" && +date)
//return !isNaN(date.getTime())
}
var test="05/04/2012"
console.log(isValidDate(test))
var test="95"
console.log(isValidDate(test))
var test="89"
console.log(isValidDate(test))
var test="80"
console.log(isValidDate(test))
var test="badstring"
console.log(isValidDate(test))
答案 34 :(得分：1)
返回字符串（新日期（'12 / 12/2002'））===“无效的日期”
答案 35 :(得分：1)
对于日期的基于int 1的组件：
var is_valid_date = function(year, month, day) {
var d = new Date(year, month - 1, day);
return d.getFullYear() === year && (d.getMonth() + 1) === month && d.getDate() === day
};
试验：
is_valid_date(2013, 02, 28)
&& is_valid_date(2016, 02, 29)
&& !is_valid_date(2013, 02, 29)
&& !is_valid_date(0000, 00, 00)
&& !is_valid_date(2013, 14, 01)
答案 36 :(得分：1)
简单而优雅的解决方案：
const date = new Date(`${year}-${month}-${day} 00:00`)
const isValidDate = (Boolean(+date) && date.getDate() == day)
来源：
[1] https://medium.com/@esganzerla/simple-date-validation-with-javascript-caea0f71883c
答案 37 :(得分：1)
我看到了一些非常接近这个小片段的答案。
JavaScript方式：
function isValidDate(dateString){ return new Date(dateString).toString() !== 'Invalid Date'; }
isValidDate(new Date('WTH'));
TypeScript方式：
const isValidDate = dateString => new Date(dateString).toString() !== 'Invalid Date';
isValidDate(new Date('WTH'));
答案 38 :(得分：1)
Date.prototype.toISOString在无效日期抛出RangeError（至少在Chromium和Firefox中）。您可以将其用作验证手段，并且可能不需要这样的isValidDate（EAFP）。否则为：
function isValidDate(d)
{
try
{
d.toISOString();
return true;
}
catch(ex)
{
return false;
}
}
答案 39 :(得分：1)
所以我喜欢@Ask Clarke通过为日期添加try catch块而得到的改进很少，这些日期不能通过var d = new Date（d） -
function checkIfDateNotValid(d) {
try{
var d = new Date(d);
return !(d.getTime() === d.getTime()); //NAN is the only type which is not equal to itself.
}catch (e){
return true;
}
}
答案 40 :(得分：1)
function isValidDate(date) {
return !! (Object.prototype.toString.call(date) === "[object Date]" && +date);
}
答案 41 :(得分：0)
另一种检查日期是否为有效日期对象的方法：
const isValidDate = (date) =>
typeof date === 'object' &&
typeof date.getTime === 'function' &&
!isNaN(date.getTime())
答案 42 :(得分：0)
如果您已经熟悉moment.js的用法，请考虑使用它。它提供了一个isValid（）方法，该方法针对无效日期返回false。
var m = moment("2011-10-10T10:20:90");
m.isValid(); // false
m.invalidAt(); // 5 for seconds
参考：https://github.com/firebase/firebase-android-sdk/issues/604
答案 43 :(得分：0)
相当老的话题...
尝试这样的事情：
if (!('null' === JSON.stringify(new Date('wrong date')))) console.log('correct');
else console.log('wrong');
答案 44 :(得分：0)
如果您使用io-ts，则可以直接使用解码器DateFromISOString。
import { DateFromISOString } from 'io-ts-types/lib/DateFromISOString'
const decoded = DateFromISOString.decode('2020-05-13T09:10:50.957Z')
答案 45 :(得分：0)
纯JavaScript解决方案：
const date = new Date(year, (+month-1), day);
const isValidDate = (Boolean(+date) && date.getDate() == day);
也在works年工作！
贷记https://medium.com/@esganzerla/simple-date-validation-with-javascript-caea0f71883c
答案 46 :(得分：0)
date.parse(valueToBeTested) > 0就是所需要的。有效日期将返回纪元值，无效值将返回NaN，由于甚至不是数字，将无法> 0测试。
这很简单，帮助函数不会保存代码，虽然它可能更具可读性。如果你想要一个：
String.prototype.isDate = function() {
return !Number.isNaN(Date.parse(this));
}
OR
使用：
"StringToTest".isDate();
答案 47 :(得分：0)
var isDate_ = function(input) {
var status = false;
if (!input || input.length <= 0) {
status = false;
} else {
var result = new Date(input);
if (result == 'Invalid Date') {
status = false;
} else {
status = true;
}
}
return status;
}
答案 48 :(得分：0)
Date.valid = function(str){
var d = new Date(str);
return (Object.prototype.toString.call(d) === "[object Date]" && !isNaN(d.getTime()));
}
https://gist.github.com/dustinpoissant/b83750d8671f10c414b346b16e290ecf
答案 49 :(得分：0)
isValidDate的这种风格使用处理闰年的正则表达式：
function isValidDate(value)
{
return /((^(10|12|0?[13578])([/])(3[01]|[12][0-9]|0?[1-9])([/])((1[8-9]\d{2})|([2-9]\d{3}))$)|(^(11|0?[469])([/])(30|[12][0-9]|0?[1-9])([/])((1[8-9]\d{2})|([2-9]\d{3}))$)|(^(0?2)([/])(2[0-8]|1[0-9]|0?[1-9])([/])((1[8-9]\d{2})|([2-9]\d{3}))$)|(^(0?2)([/])(29)([/])([2468][048]00)$)|(^(0?2)([/])(29)([/])([3579][26]00)$)|(^(0?2)([/])(29)([/])([1][89][0][48])$)|(^(0?2)([/])(29)([/])([2-9][0-9][0][48])$)|(^(0?2)([/])(29)([/])([1][89][2468][048])$)|(^(0?2)([/])(29)([/])([2-9][0-9][2468][048])$)|(^(0?2)([/])(29)([/])([1][89][13579][26])$)|(^(0?2)([/])(29)([/])([2-9][0-9][13579][26])$))/.test(value)
}
答案 50 :(得分：0)
此函数验证由字符分隔的数字格式的字符串日期，例如dd / mm / yyyy，mm / dd / yyyy
/*
Param :
1)the date in string data type
2)[optional - string - default is "/"] the date delimiter, most likely "/" or "-"
3)[optional - int - default is 0] the position of the day component when the date string is broken up via the String.split function (into arrays)
4)[optional - int - default is 1] the position of the month component when the date string is broken up via the String.split function (into arrays)
5)[optional - int - default is 2] the position of the year component when the date string is broken up via the String.split function (into arrays)
Return : a javascript date is returned if the params are OK else null
*/
function IsValidDate(strDate, strDelimiter, iDayPosInArray, iMonthPosInArray, iYearPosInArray) {
var strDateArr; //a string array to hold constituents day, month, and year components
var dtDate; //our internal converted date
var iDay, iMonth, iYear;
//sanity check
//no integer checks are performed on day, month, and year tokens as parsing them below will result in NaN if they're invalid
if (null == strDate || typeof strDate != "string")
return null;
//defaults
strDelimiter = strDelimiter || "/";
iDayPosInArray = undefined == iDayPosInArray ? 0 : iDayPosInArray;
iMonthPosInArray = undefined == iMonthPosInArray ? 1 : iMonthPosInArray;
iYearPosInArray = undefined == iYearPosInArray ? 2 : iYearPosInArray;
strDateArr = strDate.split(strDelimiter);
iDay = parseInt(strDateArr[iDayPosInArray],10);
iMonth = parseInt(strDateArr[iMonthPosInArray],10) - 1; // Note: months are 0-based
iYear = parseInt(strDateArr[iYearPosInArray],10);
dtDate = new Date(
iYear,
iMonth, // Note: months are 0-based
iDay);
return (!isNaN(dtDate) && dtDate.getFullYear() == iYear && dtDate.getMonth() == iMonth && dtDate.getDate() == iDay) ? dtDate : null; // Note: months are 0-based
}
示例电话：
var strDate="18-01-1971";
if (null == IsValidDate(strDate)) {
alert("invalid date");
}