javascript - परिवर्तनीय=== अपरिभाषित बनाम टाइपो चर=== "अपरिभाषित"



jquery undefined (5)

JQuery कोर स्टाइल दिशानिर्देश यह जांचने के लिए दो अलग-अलग तरीकों का सुझाव देते हैं कि एक चर परिभाषित किया गया है या नहीं।

  • वैश्विक चर: typeof variable === "undefined"
  • स्थानीय चर: variable === undefined
  • गुण: object.prop === undefined

JQuery वैश्विक चर के लिए एक दृष्टिकोण का उपयोग क्यों करता है और दूसरा स्थानीय और गुणों के लिए?


अविकसित चर के लिए, typeof foo स्ट्रिंग अक्षर "undefined" वापस कर देगा, जबकि पहचान जांच foo === undefined त्रुटि "foo परिभाषित नहीं है" को ट्रिगर करेगा।

स्थानीय चर के लिए (जिसे आप कहीं भी घोषित कर रहे हैं), ऐसी कोई त्रुटि नहीं होगी, इसलिए पहचान जांच।


क्योंकि undefined हमेशा घोषित नहीं किया जाता है, लेकिन jQuery अपने मुख्य समारोह में undefined घोषित करता है। इसलिए वे आंतरिक रूप से सुरक्षित undefined मान का उपयोग करते हैं, लेकिन बाहर, वे typeof शैली का उपयोग सुरक्षित होने के लिए करते हैं।


मैं हर जगह typeof foo === "undefined" का उपयोग करना चाहता हूं। वह कभी गलत नहीं हो सकता है।

मैं कल्पना करता हूं कि jQuery दो अलग-अलग तरीकों की सिफारिश क्यों करता है कि वे अपने स्वयं के undefined चर को उस फ़ंक्शन के भीतर परिभाषित करते हैं जिसमें jQuery कोड रहता है, इसलिए उस कार्य के भीतर undefined बाहरी से छेड़छाड़ से सुरक्षित है। मैं यह भी कल्पना करूंगा कि किसी ने कहीं दो अलग-अलग दृष्टिकोणों को बेंचमार्क किया है और पता चला है कि foo === undefined तेज़ है और इसलिए यह तय करने का तरीका है। [अद्यतन: टिप्पणियों में उल्लेख के अनुसार, undefined साथ तुलना भी थोड़ी कम है, जो एक विचार हो सकती है।] हालांकि, व्यावहारिक परिस्थितियों में लाभ पूरी तरह से महत्वहीन होगा: यह जांच कभी भी किसी प्रकार की बाधा नहीं होगी, और जो आप खो देते हैं वह महत्वपूर्ण है: तुलना के लिए मेजबान ऑब्जेक्ट की किसी संपत्ति का मूल्यांकन करना एक त्रुटि फेंक सकता है जबकि एक typeof जांच कभी नहीं होगी।

उदाहरण के लिए, एक्सई में पार्सिंग एक्सएमएल के लिए निम्नलिखित का उपयोग किया जाता है:

var x = new ActiveXObject("Microsoft.XMLDOM");

यह जांचने के लिए कि क्या इसमें loadXML विधि सुरक्षित है या नहीं:

typeof x.loadXML === "undefined"; // Returns false

दूसरी ओर:

x.loadXML === undefined; // Throws an error

अद्यतन करें

typeof चेक का एक अन्य लाभ जो मैं उल्लेख करना भूल गया था वह यह था कि यह अविकसित चर के साथ भी काम करता है, जो foo === undefined चेक नहीं करता है, और वास्तव में एक ReferenceError त्रुटि को फेंकता है। मुझे याद दिलाने के लिए @LinusKleen के लिए धन्यवाद। उदाहरण के लिए:

typeof someUndeclaredVariable; // "undefined"
someUndeclaredVariable === undefined; // throws a ReferenceError

निचली पंक्ति: हमेशा typeof चेक का उपयोग करें।


स्थानीय चर के लिए, स्थानीय localVar === undefined साथ जांच करना काम करेगा क्योंकि उन्हें स्थानीय दायरे में कहीं भी परिभाषित किया जाना चाहिए या उन्हें स्थानीय नहीं माना जाएगा।

उन चर के लिए जो स्थानीय नहीं हैं और कहीं भी परिभाषित नहीं हैं, चेक कुछ करें someVar === undefined अपवाद फेंक देगा: someVar === undefined संदर्भ someVar === undefined : जे परिभाषित नहीं है

यहां कुछ कोड दिया गया है जो मैं ऊपर बता रहा हूं कि मैं क्या कह रहा हूं। आगे स्पष्टता के लिए कृपया इनलाइन टिप्पणियों पर ध्यान दें

function f (x) {
    if (x === undefined) console.log('x is undefined [x === undefined].');
    else console.log('x is not undefined [x === undefined.]');

    if (typeof(x) === 'undefined') console.log('x is undefined [typeof(x) === \'undefined\'].');
    else console.log('x is not undefined [typeof(x) === \'undefined\'].');

    // This will throw exception because what the hell is j? It is nowhere to be found.
    try
    {
        if (j === undefined) console.log('j is undefined [j === undefined].');
        else console.log('j is not undefined [j === undefined].');
    }
    catch(e){console.log('Error!!! Cannot use [j === undefined] because j is nowhere to be found in our source code.');}

    // However this will not throw exception
    if (typeof j === 'undefined') console.log('j is undefined (typeof(x) === \'undefined\'). We can use this check even though j is nowhere to be found in our source code and it will not throw.');
    else console.log('j is not undefined [typeof(x) === \'undefined\'].');
};

अगर हम उपरोक्त कोड को इस तरह कहते हैं:

f();

आउटपुट यह होगा:

x is undefined [x === undefined].
x is undefined [typeof(x) === 'undefined'].
Error!!! Cannot use [j === undefined] because j is nowhere to be found in our source code.
j is undefined (typeof(x) === 'undefined'). We can use this check even though j is nowhere to be found in our source code and it will not throw.

अगर हम उपरोक्त कोड को इस तरह कहते हैं (वास्तव में किसी भी मूल्य के साथ):

f(null); 
f(1);

आउटपुट होगा:

x is not undefined [x === undefined].
x is not undefined [typeof(x) === 'undefined'].
Error!!! Cannot use [j === undefined] because j is nowhere to be found in our source code.
j is undefined (typeof(x) === 'undefined'). We can use this check even though j is nowhere to be found in our source code and it will not throw.

जब आप इस तरह की जांच करते हैं: typeof x === 'undefined' , तो आप अनिवार्य रूप से यह पूछ रहे हैं: कृपया जांचें कि क्या वेरिएबल x मौजूद है (स्रोत परिभाषित किया गया है) कहीं भी स्रोत कोड में है। (ज्यादा या कम)। यदि आप सी # या जावा जानते हैं, तो इस प्रकार की जांच कभी नहीं की जाती है क्योंकि यदि यह अस्तित्व में नहीं है, तो यह संकलित नहीं होगा।

<== मुझे परेशान करें ==>






undefined