javascript जावास्क्रिप्ट में "अमान्य तिथि" दिनांक उदाहरण का पता लगाना




date (24)

मैं वर्ष, महीने और तारीख के मानों को मान्य करने के लिए निम्न कोड का उपयोग करता हूं।

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

विवरण के लिए, जावास्क्रिप्ट में चेक तिथि देखें

मैं जेएस में मान्य और अमान्य दिनांक ऑब्जेक्ट्स के बीच अंतर बताना चाहता हूं, लेकिन यह पता नहीं लगा सकता कि कैसे:

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 साथ जांच की और यह व्यवहार मानक में है, जो वही है जो मैं ढूंढ रहा हूं।

चयनित उत्तर उत्कृष्ट है, और मैं इसका भी उपयोग कर रहा हूं। हालांकि, यदि आप उपयोगकर्ता दिनांक इनपुट को सत्यापित करने के लिए एक तरीका ढूंढ रहे हैं, तो आपको अवगत होना चाहिए कि दिनांक वस्तु वैध बनाने वाले तर्कों को वैध बनाने के बारे में बहुत लगातार है। निम्नलिखित इकाई परीक्षण कोड बिंदु को दर्शाता है:

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

यहां पहले से बहुत जटिल उत्तर हैं, लेकिन एक साधारण रेखा पर्याप्त है (ES5):

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

या यहां तक ​​कि ES6 में:

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

उपर्युक्त समाधानों में से कोई भी मेरे लिए काम नहीं करता था, हालांकि काम क्या था

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

ऊपर दिया गया कोड तब देखेगा जब जेएस 02/31/2012 को 03/02/2012 में बनाता है कि यह मान्य नहीं है


मैंने सबसे अच्छे प्रदर्शन परिणामों को संयुक्त किया जो मैंने पाया कि किसी दिए गए ऑब्जेक्ट को चेक करें या नहीं:

नतीजा निम्न है:

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

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

शीर्ष रेटेड उत्तर के आधार पर एक तैयार फ़ंक्शन:

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

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

मैंने यह फ़ंक्शन लिखा है। इसे एक स्ट्रिंग पैरामीटर पास करें और यह निर्धारित करेगा कि यह वैध दिनांक है या नहीं, इस प्रारूप "dd / MM / yyyy" के आधार पर।

यहाँ एक परीक्षण है

इनपुट: "हाहाहा", आउटपुट: झूठी।

इनपुट: "2 9/2/2000", आउटपुट: सच।

इनपुट: "2 9/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;
    }
}

अच्छा समाधान! सहायक कार्यों की मेरी लाइब्रेरी में शामिल है, अब यह इस तरह दिखता है:

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

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

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

2/31/2012 जैसी तारीख को सत्यापित करने का प्रयास करते समय इनमें से कोई भी जवाब मेरे लिए काम नहीं करता है (सफारी 6.0 में परीक्षण किया गया है), हालांकि, 31 से अधिक तारीख की कोशिश करते समय वे ठीक काम करते हैं।

तो मुझे थोड़ा बल देना पड़ा। मान लीजिए कि प्रारूप mm/dd/yyyy प्रारूप में mm/dd/yyyy । मैं @ ब्रॉक्स जवाब का उपयोग कर रहा हूँ:

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

मेरा समाधान यह जांचने के लिए है कि आपको वैध दिनांक वस्तु मिलती है या नहीं:

कार्यान्वयन

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

आप इस scirpt के साथ txDate.value के वैध प्रारूप की जांच कर सकते हैं। अगर यह गलत प्रारूप में था, तो दिनांक obejct अधिष्ठापित नहीं है और डीटी को वापस लौटाता है।

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

और जैसा कि @ एमआईएफ ने संक्षेप में सुझाव दिया है

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

आम तौर पर मैं ब्राउज़र स्टैक में जो भी तारीख प्रत्यारोपण के साथ रहना चाहता हूं। जिसका अर्थ है कि इस उत्तर की तारीख के अनुसार क्रोम, फ़ायरफ़ॉक्स और सफारी मेंडेट्रिंग () को कॉल करते समय आपको हमेशा "अमान्य तिथि" मिल जाएगी।

if(!Date.prototype.isValidDate){
  Date.prototype.isValidDate = function(){
    return this.toDateString().toLowerCase().lastIndexOf('invalid') == -1;
  };
}

हालांकि मैंने आईई में इसका परीक्षण नहीं किया था।


मुझे वास्तव में क्रिस्टोफ के दृष्टिकोण पसंद आया (लेकिन इसे वोट करने के लिए पर्याप्त प्रतिष्ठा नहीं थी)। मेरे उपयोग के लिए, मुझे पता है कि मेरे पास हमेशा एक डेट ऑब्जेक्ट होगा, इसलिए मैंने अभी तक वैध () विधि के साथ तिथि बढ़ा दी है।

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

अब मैं इसे सिर्फ लिख सकता हूं और यह जांचने से कहीं अधिक वर्णनात्मक है कोड में अनंत ...

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

Angular.js परियोजनाओं के लिए आप इसका उपयोग कर सकते हैं:

angular.isDate(myDate);

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

new Date() का उपयोग करने के बजाय आपको इसका उपयोग करना चाहिए:

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

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

Date.parse() एक टाइमस्टैम्प देता है, एक पूर्णांक 01 / जनवरी / 1 9 70 से मिलीसेकंड की संख्या का प्रतिनिधित्व करता है। यह NaN वापस करेगा यदि यह आपूर्ति की गई दिनांक स्ट्रिंग को पार्स नहीं कर सकता है।


बोर्गार के दृष्टिकोण से प्रेरित मैंने यह सुनिश्चित कर लिया है कि कोड न केवल तारीख को मान्य करता है, बल्कि वास्तव में यह सुनिश्चित करता है कि तिथि वास्तविक तिथि है, जिसका अर्थ है कि 31/09/2011 और 2 9/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!";
}

स्ट्रिंग के लिए दिनांक ऑब्जेक्ट यह पता लगाने के लिए अधिक सरल और विश्वसनीय तरीका है कि दोनों फ़ील्ड वैध दिनांक हैं या नहीं। उदाहरण के लिए यदि आप इस इनपुट इनपुट क्षेत्र में "-------" दर्ज करते हैं। उपर्युक्त उत्तरों में से कुछ काम नहीं करेंगे।

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

यहां बताया गया है कि मैं इसे कैसे करूंगा:

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
}

आप अपनी तिथि और समय को मिलीसेकंड में getTime() कर सकते हैं getTime()

यह getTime() विधि वापसी मान्य नहीं होने पर एक संख्या NaN नहीं है

if(!isNaN(new Date("2012/25/255").getTime()))
  return 'valid date time';
  return 'Not a valid date time';

आप Date ऑब्जेक्ट d की वैधता की जांच कर सकते हैं

d instanceof Date && isFinite(d)

क्रॉस-फ्रेम समस्याओं से बचने के लिए, कोई instanceof साथ चेक को प्रतिस्थापित कर सकता है

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

बोर्गर के जवाब में प्राप्त करने के लिए एक कॉल अनावश्यक है क्योंकि isNaN() और isFinite() दोनों अंतर्निहित रूप से संख्या में परिवर्तित हो जाते हैं।







date