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




date (20)

आप बस moment.js उपयोग कर सकते हैं

यहाँ एक उदाहरण है:

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

दस्तावेज़ीकरण में सत्यापन अनुभाग काफी स्पष्ट है।

और साथ ही, निम्नलिखित पार्सिंग झंडे का परिणाम अमान्य तिथि में होता है:

  • overflow : 13 वें महीने के दिनांक क्षेत्र का एक ओवरफ़्लो, महीने का 32 वां दिन (या गैर-लीप वर्षों पर फरवरी का 2 9वां), वर्ष का 367 वां दिन, ओवरफ़्लो में अमान्य की अनुक्रमणिका होती है #invalidAt से मिलान करने के लिए इकाई (नीचे देखें); -1 का मतलब कोई अतिप्रवाह नहीं है।
  • अवैध माह: एक अमान्य महीना नाम, जैसे पल ('फरवरी', 'एमएमएमएम'); अमान्य महीने स्ट्रिंग स्वयं, या फिर शून्य शामिल है।
  • empty : एक इनपुट स्ट्रिंग जिसमें कुछ भी नहीं है, जैसे पल ('यह बकवास है'); बूलियन।
  • आदि।

स्रोत: http://momentjs.com/docs/

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

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

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

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

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

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

d instanceof Date && isFinite(d)

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

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

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


आप इस 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;
  };
}

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


किसी दिनांक के 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(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;
    }

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

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

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

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

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

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

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


मैंने यह फ़ंक्शन लिखा है। इसे एक स्ट्रिंग पैरामीटर पास करें और यह निर्धारित करेगा कि यह वैध दिनांक है या नहीं, इस प्रारूप "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;
    }
}

यह उल्लेख करना चाहते हैं कि jQuery UI DatePicker विजेट की एक बहुत अच्छी तिथि सत्यापनकर्ता उपयोगिता विधि है जो प्रारूप और वैधता के लिए जांचती है (उदाहरण के लिए, 01/33/2013 दिनांकों की अनुमति नहीं है)।

भले ही आप यूआई तत्व के रूप में अपने पेज पर डेटपिकर विजेट का उपयोग नहीं करना चाहते हैं, फिर भी आप अपने पेज पर अपनी .js लाइब्रेरी जोड़ सकते हैं और उसके बाद वैल्यूएटर विधि को कॉल कर सकते हैं, जिस वैल्यू को आप इसमें मान्य करना चाहते हैं उसे पास कर सकते हैं। जीवन को और भी आसान बनाने के लिए, यह एक स्ट्रिंग लेता है इनपुट के रूप में, जावास्क्रिप्ट दिनांक ऑब्जेक्ट नहीं।

देखें: http://api.jqueryui.com/datepicker/

यह एक विधि के रूप में सूचीबद्ध नहीं है, लेकिन यह वहाँ है - एक उपयोगिता समारोह के रूप में। "पार्सडेट" के लिए पृष्ठ खोजें और आपको मिलेगा:

$ .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 'के बाद से अलर्ट संदेश दिखाई नहीं देगा, निर्दिष्ट प्रारूप में कैलेंडर-वैध दिनांक है। हालांकि अगर आपने '13 / 04/2013 'के बराबर' स्ट्रिंगवल 'बनाया है, उदाहरण के लिए, आपको चेतावनी संदेश मिलेगा, क्योंकि '13 / 04/2013' मान कैलेंडर-मान्य नहीं है।

यदि पास-इन स्ट्रिंग मान सफलतापूर्वक पार्स किया गया है, तो 'testdate' का मान एक जावास्क्रिप्ट दिनांक ऑब्जेक्ट होगा जो पास-इन स्ट्रिंग मान का प्रतिनिधित्व करता है। यदि नहीं, तो यह अनिर्धारित होगा।


यह सिर्फ मेरे लिए काम किया

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

हालांकि यह काम नहीं किया

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

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

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
}

वैध तिथि की जांच करने के लिए सबसे कम जवाब

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

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

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

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

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

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

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


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

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





date