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දින නූල් විග්‍රහ කිරීම සඳහා අළු නිර්දේශ කර ඇති අතර, එමඟින් දිනය නූල වලංගු දැයි පරීක්ෂා කිරීමට බලයලත් ක්‍රමයක් ලබා දේ.
• මා කැමති නම්, හැකි නම්, මගේ ඒපීඅයි දිනය නිදසුනක් පිළිගෙන එය වලංගු ද නැද්ද යන්න පරීක්ෂා කිරීමට / තහවුරු කිරීමට හැකි වීම. බෝර්ගර්ගේ විසඳුම එය කරයි, නමුත් මට එය බ්‍රව්සර් හරහා පරීක්ෂා කිරීමට අවශ්‍යය. ඊටත් වඩා අලංකාර ක්‍රමයක් තිබේදැයි මම කල්පනා කරමි.
• මගේ API පිළිගැනීමේ Dateඅවස්ථා කිසිසේත් නොතිබීම ගැන Ash ෂ් මට සලකා බැලීය , මෙය වලංගු කිරීම පහසුම වේ.
• බෝර්ගර් යෝජනා කළේ Dateනිදසුනක් සඳහා පරීක්‍ෂා කර , පසුව Dateකාල අගය පරීක්ෂා කිරීමයි . දිනය අවලංගු නම්, කාල අගය වේ NaN. මම ECMA-262 සමඟ පරීක්ෂා කළ අතර මෙම හැසිරීම ප්‍රමිතියෙන් යුක්ත වන අතර එය මා සොයන දේමයි.

මෙන්න මම එය කරන්නේ කෙසේද:

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 සන්දර්භයන්ගෙන් (බාහිර කවුළු, රාමු, හෝ අයිෆ්‍රේම්) දිනය වස්තු ගැන සැලකිලිමත් නොවන්නේ නම්, මෙම සරල ආකෘතිය වඩාත් සුදුසු වේ:

function isValidDate(d) {
  return d instanceof Date && !isNaN(d);
}

භාවිතා කිරීම වෙනුවට new Date()ඔබ භාවිතා කළ යුත්තේ:

var timestamp = Date.parse('foo');

if (isNaN(timestamp) == false) {
  var d = new Date(timestamp);
}

Date.parse()01 / ජනවාරි / 1970 සිට මිලි තත්පර ගණන නියෝජනය කරන පූර්ණ සංඛ්‍යාවක් වන කාලරාමුව නැවත ලබා දෙයි. NaNසැපයූ දින නූල විග්‍රහ කිරීමට නොහැකි නම් එය නැවත පැමිණේ .

ඔබට Dateවස්තුවක වලංගුභාවය පරීක්ෂා කළ dහැකිය

d instanceof Date && isFinite(d)

හරස් රාමු ගැටළු වළක්වා ගැනීම සඳහා යමෙකුට instanceofචෙක්පත ආදේශ කළ හැකිය

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

බෝර්ගර්ගේ පිළිතුරටgetTime() මෙන් ඇමතුමක් අනවශ්‍ය වන අතර දෙකම ව්‍යංගයෙන් අංකයට පරිවර්තනය වේ.isNaN()isFinite()

මගේ විසඳුම වන්නේ ඔබට වලංගු දින වස්තුවක් ලැබේද යන්න පරීක්ෂා කිරීමයි:

ක්‍රියාත්මක කිරීම

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

වලංගු දිනය පරීක්ෂා කිරීමට කෙටිම පිළිතුර

if(!isNaN(date.getTime()))

ඔබට moment.js භාවිතා කළ හැකිය

මෙන්න උදාහරණයක්:

var m = moment('2015-11-32', 'YYYY-MM-DD');
m.isValid(); // false

මෙම වලංගු කොටස ලේඛගතකිරීම දී ඉතා පැහැදිලිය.

තවද, පහත දැක්වෙන විග්‍රහ කිරීමේ ධජ වලංගු නොවන දිනයකට හේතු වේ:

• overflow: 13 වන මාසය, මාසයේ 32 වන දිනය (හෝ පිම්ම නොවන වර්ෂවල පෙබරවාරි 29), වසරේ 367 වන දිනය වැනි දින ක්ෂේත්‍රයක් පිටාර ගැලීම වලංගු නොවන ඒකකයේ දර්ශකය අඩංගු වේ. #invalidAt ගැලපීමට (පහත බලන්න); -1 යනු පිටාර ගැලීමක් නැත.
• invalidMonth: මොහොත වැනි අවලංගු මාසයක නමක් ('මාර්තු', 'එම්.එම්.එම්.එම්');. අවලංගු මාස ​​නූලක් අඩංගු වේ, නැතිනම් ශුන්‍ය වේ.
• empty: මොහොත වැනි '' මෙය විකාරයකි ') වැනි විග්‍රහ කළ හැකි කිසිවක් අඩංගු නොවන ආදාන නූල; බූලියන්.
• ආදිය.

මුලාශ්‍රය: http://momentjs.com/docs/

JQuery UI DatePicker widget හි ඉතා හොඳ දිනය වලංගු කිරීමේ උපයෝගීතා ක්‍රමයක් ඇති අතර එය ආකෘතිය සහ වලංගුභාවය පරීක්ෂා කරයි (උදා: 01/33/2013 දින අවසර නැත).

ඔබගේ පිටුවේ ඩේට්පිකර් විජට් යූඅයි අංගයක් ලෙස භාවිතා කිරීමට ඔබට අවශ්‍ය නොවුවද, ඔබට සැමවිටම එහි .js පුස්තකාලය ඔබේ පිටුවට එක් කර වලංගු කිරීමේ ක්‍රමය අමතන්න, ඔබට එය වලංගු කිරීමට අවශ්‍ය අගය පසුකර යන්න. ජීවිතය වඩාත් පහසු කිරීම සඳහා, එය ජාවාස්ක්‍රිප්ට් දිනය වස්තුවක් නොව ආදානය ලෙස නූලක් ගනී.

බලන්න: http://api.jqueryui.com/datepicker/

එය ක්‍රමයක් ලෙස ලැයිස්තුගත කර නැත, නමුත් එය එහි ඇත - උපයෝගිතා ශ්‍රිතයක් ලෙස. "විග්‍රහ කිරීම" සඳහා පිටුව සොයන්න, එවිට ඔබට සොයාගත හැකිය:

d .datepicker.parseDate (ආකෘතිය, වටිනාකම, සැකසුම්) - නිශ්චිත ආකෘතියකින් නූල් අගයකින් දිනයක් උපුටා ගන්න.

උදාහරණ භාවිතය:

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' අගය දින දර්ශනයට වලංගු නොවන බැවින් ඔබට අනතුරු ඇඟවීමේ පණිවිඩය ලැබෙනු ඇත.

සම්මත කළ නූල් අගයක් සාර්ථකව විග්‍රහ කර ඇත්නම්, 'ටෙස්ට් ඩේට්' හි අගය සම්මත සම්මත අගය නියෝජනය කරන ජාවාස්ක්‍රිප්ට් දිනය වස්තුවකි. එසේ නොවේ නම්, එය නිර්වචනය නොකෙරේ.

මම ක්‍රිස්ටෝෆ්ගේ ප්‍රවේශයට ඇත්තෙන්ම කැමතියි (නමුත් එය ඡන්දය ප්‍රකාශ කිරීමට තරම් කීර්තියක් නොතිබුණි). මගේ භාවිතය සඳහා, මම සෑම විටම දින වස්තුවක් ඇති බව මම දනිමි, එබැවින් වලංගු () ක්‍රමයක් සමඟ දිනය දීර් extended කළෙමි.

Date.prototype.valid = function() {
  return isFinite(this);
}

දැන් මට මෙය ලිවිය හැකි අතර එය කේතයේ isFinite පරික්ෂා කිරීමට වඩා විස්තරාත්මක වේ ...

d = new Date(userDate);
if (d.valid()) { /* do stuff */ }

// check whether date is valid
var t = new Date('2011-07-07T11:20:00.000+00:00x');
valid = !isNaN(t.valueOf());

ඔබට මෙම පිටපත සමඟ txDate.value වලංගු ආකෘතිය පරීක්ෂා කළ හැකිය. එය වැරදි ආකෘතියකින් නම් දිනය පරමාර්ථය ක්ෂණිකව සකසා නැති අතර dt වෙත ආපසු හරවන්න.

 var dt = new Date(txtDate.value)
 if (isNaN(dt))

@ මිෆ් යෝජනා කළ පරිදි කෙටියෙන්

 if(isNaN(new Date(...)))

වර්ෂය, මාසය සහ දිනය සඳහා අගයන් වලංගු කිරීම සඳහා මම පහත කේතය භාවිතා කරමි.

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

වැඩි විස්තර සඳහා, javascript හි චෙක් දිනය බලන්න

මෙම කුඩා ස්නිපටයට ආසන්නව පිළිතුරු කිහිපයක් මම දුටුවෙමි.

ජාවාස්ක්‍රිප්ට් ක්‍රමය:

function isValidDate(dateObject){ return new Date(dateObject).toString() !== 'Invalid Date'; }
isValidDate(new Date('WTH'));

ටයිප්ස්ක්‍රිප්ට් ක්‍රමය:

const isValidDate = dateObject => new Date(dateObject ).toString() !== 'Invalid Date';
isValidDate(new Date('WTH'));

දැනටමත් මෙහි සංකීර්ණ පිළිතුරු ඕනෑවටත් වඩා ඇත, නමුත් සරල රේඛාවක් ප්‍රමාණවත් (ES5):

Date.prototype.isValid = function (d) { return !isNaN(Date.parse(d)) } ;

හෝ ES6 හි පවා:

Date.prototype.isValid = d => !isNaN(Date.parse(d));

හොඳ විසඳුමක්! මගේ සහායක කාර්යයන් පිළිබඳ පුස්තකාලයට ඇතුළත් කර ඇති අතර දැන් එය මේ ආකාරයට පෙනේ:

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

මෙය මට වැඩ කළා

new Date('foo') == 'Invalid Date'; //is true

කෙසේ වෙතත් මෙය ක්‍රියාත්මක වූයේ නැත

new Date('foo') === 'Invalid Date'; //is false

Angular.js ව්‍යාපෘති සඳහා ඔබට භාවිතා කළ හැකිය:

angular.isDate(myDate);

2/31/2012 වැනි දිනයක් වලංගු කිරීමට උත්සාහ කරන විට මෙම පිළිතුරු කිසිවක් මා වෙනුවෙන් ක්‍රියාත්මක නොවීය (සෆාරි 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

කෙසේ වෙතත් ඉහත සඳහන් විසඳුම් කිසිවක් මා වෙනුවෙන් වැඩ කළේ නැත

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 බවට පත් කළ විට එය වලංගු නොවන බව පෙනෙනු ඇත

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

බෝර්ගර්ගේ ප්‍රවේශය මගින් දේවානුභාවයෙන් මම කේතය දිනය වලංගු කිරීම පමණක් නොව, දිනය නියම දිනයක් බව සහතික කර ඇත්තෙමි, එයින් අදහස් වන්නේ 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!";
}

මම මෙම ශ්‍රිතය ලියා ඇත. එය නූල් පරාමිතියක් පසුකර යන්න, එය "dd / MM / yyyy" යන ආකෘතිය මත පදනම්ව එය වලංගු දිනයක්ද නැද්ද යන්න තීරණය කරයි.

මෙන්න පරීක්ෂණයකි

ආදානය: "හහාහා", ප්‍රතිදානය: අසත්‍යය.

ආදානය: "29/2/2000", ප්‍රතිදානය: සත්‍ය.

ආදානය: "29/2/2001", ප්‍රතිදානය: අසත්‍යය.

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

Date.prototype.toISOStringRangeErrorඅවලංගු දිනවලදී විසි කිරීම (අවම වශයෙන් ක්‍රෝමියම් සහ ෆයර්ෆොක්ස් වලින්). ඔබට එය වලංගු කිරීමේ මාධ්‍යයක් ලෙස භාවිතා කළ හැකි අතර isValidDate(EAFP) අවශ්‍ය නොවනු ඇත. එසේ නොමැති නම්:

function isValidDate(d)
{
  try
  {
    d.toISOString();
    return true;
  }
  catch(ex)
  {
    return false;    
  }    
}

දී ඇති වස්තුවක් නම්, එම චෙක්පත වටා මා සොයාගත් හොඳම කාර්ය සාධන ප්‍රති results ල මම ඒකාබද්ධ කළෙමි:

• දිනය නිදසුනකි ( මෙහි මිණුම් ලකුණ )
• වලංගු දිනයක් ඇත ( මෙහි මිණුම් ලකුණ )

ප්රති result ලය පහත දැක්වේ:

function isValidDate(input) {
  if(!(input && input.getTimezoneOffset && input.setUTCFullYear))
    return false;

  var time = input.getTime();
  return time === time;
};

ක්ෂේත්ර දෙකම වලංගු දිනයක් දැයි සොයා ගැනීමට දිනය වස්තුවට වඩා සරල හා විශ්වාසදායක ක්රමයකි. උදා: ඔබ මෙය "-------" දිනය ආදාන ක්ෂේත්‍රයට ඇතුළත් කළහොත්. ඉහත පිළිතුරු සමහරක් ක්‍රියා නොකරනු ඇත.

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}.');

දිනයක 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)

තෝරාගත් පිළිතුර විශිෂ්ටයි, මම එයද භාවිතා කරමි. කෙසේ වෙතත්, ඔබ පරිශීලක දිනය ආදානය වලංගු කිරීමට ක්‍රමයක් සොයන්නේ නම්, වලංගු නොවන ඉදිකිරීම් තර්ක ලෙස පෙනෙන දේ වලංගු ඒවා බවට පත් කිරීම සඳහා දිනය වස්තුව ඉතා ස්ථීර බව ඔබ දැන සිටිය යුතුය. පහත දැක්වෙන ඒකක පරීක්ෂණ කේතය මඟින් කාරණය පැහැදිලි කරයි:

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

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

ඉහළ ශ්‍රේණිගත කළ පිළිතුර මත පදනම් වූ සූදානම් ශ්‍රිතයක්:

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

සරල හා අලංකාර විසඳුම:

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

[2] ජාවාස්ක්‍රිප්ට් හි නව දිනය () හි වැරදි දිනය පෙන්වා ඇත

කිසිවෙකු තවම එය සඳහන් කර නැත, එබැවින් සංකේත ද යා යුතු මාර්ගයක් වනු ඇත:

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

දැනුවත් වන්න: https://caniuse.com/#search=Symbol