javascript - जावास्क्रिप्ट में "अपरिभाषित" की जांच कैसे करें?




undefined (14)

    var x;
    if (x === undefined) {
        alert ("I am declared, but not defined.")
    };
    if (typeof y === "undefined") {
        alert ("I am not even declared.")
    };

    /* One more thing to understand: typeof ==='undefined' also checks 
       for if a variable is declared, but no value is assigned. In other 
       words, the variable is declared, but not defined. */

    // Will repeat above logic of x for typeof === 'undefined'
    if (x === undefined) {
        alert ("I am declared, but not defined.")
    };
    /* So typeof === 'undefined' works for both, but x === undefined 
       only works for a variable which is at least declared. */

    /* Say if I try using typeof === undefined (not in quotes) for 
       a variable which is not even declared, we will get run a 
       time error. */

    if (z === undefined) {
        alert ("I am neither declared nor defined.")
    };
    // I got this error for z ReferenceError: z is not defined 

जावास्क्रिप्ट में एक चर को अपरिभाषित करने का परीक्षण करने का सबसे उचित तरीका क्या है? मैंने कई संभावित तरीकों को देखा है:

if (window.myVariable)

या

if (typeof(myVariable) != "undefined")

या

if (myVariable) //This throws an error if undefined. Should this be in Try/Catch?

मैं व्यक्तिगत रूप से उपयोग करता हूं

myVar === undefined

चेतावनी: कृपया ध्यान दें कि === == पर उपयोग किया जाता है और यह कि मेरा myVar पहले घोषित किया गया है ( परिभाषित नहीं किया गया है )।

मुझे typeof myVar === "undefined" पसंद नहीं है। मुझे लगता है कि यह लंबी हवादार और अनावश्यक है। (मैं कम कोड में भी ऐसा ही कर सकता हूं।)

अब जब लोग इसे पढ़ते हैं तो कुछ लोग दर्द में पड़ जाएंगे, चिल्लाते हुए: "रुको! WAAITTT !!! undefined जा सकता है!"

ठंडा। मैं यह जानता हूँ। फिर फिर, जावास्क्रिप्ट में अधिकांश चर को फिर से परिभाषित किया जा सकता है। क्या आप कभी भी किसी अंतर्निहित पहचानकर्ता का उपयोग नहीं करना चाहिए जिसे फिर से परिभाषित किया जा सकता है?

यदि आप इस नियम का पालन करते हैं, तो आपके लिए अच्छा: आप एक पाखंड नहीं हैं।

बात यह है कि जेएस में बहुत सारे वास्तविक काम करने के लिए, डेवलपर्स को परिभाषित करने योग्य पहचानकर्ताओं पर भरोसा करने की आवश्यकता है कि वे क्या हैं। मैं लोगों को यह नहीं बताता कि मुझे setTimeout उपयोग नहीं करना चाहिए क्योंकि कोई भी कर सकता है

window.setTimeout = function () {
    alert("Got you now!");
};

कच्ची === undefined बोगस का उपयोग न करने के लिए नीचे की रेखा, "इसे फिर से परिभाषित किया जा सकता है" तर्क।

(यदि आप अभी भी undefined होने के बारे में डरते हैं, तो आप अपने कोड बेस में अवांछित लाइब्रेरी कोड को अंधाधुंध क्यों एकीकृत कर रहे हैं? या यहां तक ​​कि सरल: एक लिफ्टिंग टूल।)

इसके अलावा, typeof दृष्टिकोण की तरह, यह तकनीक अविकसित चरों को "पहचान" सकती है:

if (window.someVar === undefined) {
    doSomething();
}

लेकिन इन दोनों तकनीकों को उनके अमूर्तता में रिसाव। मैं आपसे आग्रह करता हूं कि आप इसका इस्तेमाल न करें

if (typeof myVar !== "undefined") {
    doSomething();
}

विचार करें:

var iAmUndefined;

पकड़ने के लिए कि क्या वेरिएबल घोषित किया गया है या नहीं, आपको ऑपरेटर का सहारा लेना पड़ सकता है। (कई मामलों में, आप बस कोड O_o पढ़ सकते हैं)।

if ("myVar" in window) {
    doSomething();
}

लेकिन रुकें! अभी और है! क्या होगा अगर कुछ प्रोटोटाइप श्रृंखला जादू हो रहा है ...? अब ऑपरेटर in भी बेहतर नहीं है। (ठीक है, मैं इस भाग के बारे में कहने के अलावा यहां हूं कि 99% समय के लिए, === undefined (और **** खांसी **** typeof ) ठीक काम करता है। अगर आप वास्तव में परवाह करते हैं, तो आप कर सकते हैं इस विषय के बारे में अपने आप पढ़ें।)


यदि आप यह जानने में रुचि रखते हैं कि किसी वैरिएबल को इसके मूल्य के बावजूद घोषित किया गया है, तो ऑपरेटर का उपयोग करना सबसे सुरक्षित तरीका है। इस उदाहरण पर विचार करें।

// global scope
var theFu; // theFu has been declared, but its value is undefined
typeof theFu; // "undefined"

लेकिन यह कुछ मामलों के लिए इच्छित परिणाम नहीं हो सकता है, क्योंकि परिवर्तनीय या संपत्ति घोषित की गई थी लेकिन अभी शुरू नहीं हुई थी। अधिक मजबूत जांच के लिए ऑपरेटर का उपयोग करें।

"theFu" in window; // true
"theFoo" in window; // false

यदि आप यह जानने में रुचि रखते हैं कि चर घोषित नहीं किया गया है या मान undefined , तो typeof ऑपरेटर का उपयोग करें।

if (typeof myVar != 'undefined')

typeof ऑपरेटर को एक स्ट्रिंग वापस करने की गारंटी है। undefined खिलाफ सीधी तुलना undefined क्योंकि undefined जा सकता है।

window.undefined = "omg";
"omg" == undefined // true

जैसा कि @ सीएमएस ने बताया, यह ईसीएमएस्क्रिप्ट 5 वां संस्करण में लगाया गया है, और undefined गैर-लिखने योग्य है।

if (window.myVar) में इन झूठी मान भी शामिल होंगे, तो यह बहुत मजबूत नहीं है:

false
0
""
NaN
null
undefined

@ सीएमएस के लिए धन्यवाद कि आपका तीसरा मामला - if (myVariable) दो मामलों में भी एक त्रुटि फेंक सकता है। पहला तब होता है जब चर परिभाषित नहीं किया गया है जो एक ReferenceError त्रुटि फेंकता है।

// abc was never declared.
if (abc) {
    // ReferenceError: abc is not defined
} 

दूसरा मामला तब होता है जब चर परिभाषित किया गया है, लेकिन एक गेटर फ़ंक्शन है जो लागू होने पर त्रुटि उत्पन्न करता है। उदाहरण के लिए,

// or it's a property that can throw an error
Object.defineProperty(window, "myVariable", { 
    get: function() { throw new Error("W00t?"); }, 
    set: undefined 
});
if (myVariable) {
    // Error: W00t?
}

यदि यह अपरिभाषित है, तो यह स्ट्रिंग के बराबर नहीं होगा जिसमें वर्ण "अपरिभाषित" हैं, क्योंकि स्ट्रिंग को अपरिभाषित नहीं किया गया है।

आप चर के प्रकार की जांच कर सकते हैं:

if (typeof(something) != "undefined") ...

कभी-कभी आपको इस प्रकार की जांच भी नहीं करनी पड़ती है। यदि वेरिएबल का मान सेट होने पर गलत पर मूल्यांकन नहीं कर सकता है (उदाहरण के लिए यदि यह एक फ़ंक्शन है), तो आप चर को केवल evalue कर सकते हैं। उदाहरण:

if (something) {
  something(param);
}

मैं इसे फ़ंक्शन पैरामीटर के रूप में उपयोग करता हूं और फ़ंक्शन निष्पादन पर इसे बाहर करता हूं जिस तरह से मुझे "असली" अपरिभाषित मिलता है। यद्यपि यह आपको अपने कोड को फ़ंक्शन के अंदर रखने की आवश्यकता है। मुझे jQuery स्रोत पढ़ने के दौरान यह मिला।

undefined = 2;

(function (undefined) {
   console.log(undefined); // prints out undefined
   // and for comparison:
   if (undeclaredvar === undefined) console.log("it works!")
})()

बेशक आप typeof उपयोग कर सकते हैं। लेकिन मेरा पूरा कोड आमतौर पर किसी भी फ़ंक्शन के अंदर होता है, इसलिए इस विधि का उपयोग करने से शायद मुझे यहां कुछ बाइट बचाए जा सकते हैं।


typeof का उपयोग करना मेरी वरीयता है। यह तब काम करेगा जब परिवर्तनीय को कभी भी घोषित नहीं किया गया है, if == या === ऑपरेटरों के साथ किसी भी तुलना के विपरीत या if प्रयोग कर दबाव डालें। ( undefined , null विपरीत, ईसीएमएस्क्रिप्ट 3 वातावरण में भी परिभाषित किया जा सकता है, जो इसे तुलना के लिए अविश्वसनीय बनाता है, हालांकि लगभग सभी आम वातावरण अब ईसीएमएस्क्रिप्ट 5 या उससे ऊपर के अनुरूप हैं)।

if (typeof someUndeclaredVariable == "undefined") {
    // Works
}

if (someUndeclaredVariable === undefined) { 
    // Throws an error
}

undefined की जांच करने के बारे में मुझे सबसे विश्वसनीय तरीका void 0 का उपयोग करना void 0

यह नए और पुराने ब्राउज़र के साथ संगत है, समान रूप से, और कुछ मामलों में window.undefined तरह ओवरराइट नहीं किया जा सकता है।

if( myVar === void 0){
    //yup it's undefined
}

Google क्रोम में, निम्न typeof परीक्षण से निम्न इतनी तेज तेज थी:

if (abc === void 0) {
    // Undefined
}

अंतर नगण्य था। हालांकि, यह कोड अधिक संक्षेप में है, और किसी नज़र में स्पष्ट है जो जानता है कि void 0 का क्या मतलब है। नोट, हालांकि, abc अभी भी घोषित किया जाना चाहिए।

undefined खिलाफ तुलना की तुलना में दोनों typeof और void काफी तेजी से थे। मैंने क्रोम डेवलपर कंसोल में निम्न परीक्षण प्रारूप का उपयोग किया:

var abc;
start = +new Date();
for (var i = 0; i < 10000000; i++) {
    if (TEST) {
        void 1;
    }
}
end = +new Date();
end - start;

परिणाम निम्नवत थे:

Test: | abc === undefined      abc === void 0      typeof abc == 'undefined'
------+---------------------------------------------------------------------
x10M  |     13678 ms               9854 ms                 9888 ms
  x1  |    1367.8 ns              985.4 ns                988.8 ns

ध्यान दें कि पहली पंक्ति मिली सेकंड में है, जबकि दूसरी पंक्ति नैनो सेकंड में है। 3.4 नैनोसेकंड का अंतर कुछ भी नहीं है। समय बाद के परीक्षणों में काफी सुसंगत थे।


विभिन्न उत्तरों के परिणामों को चित्रित करने वाले कुछ परिदृश्य: http://jsfiddle.net/drzaus/UVjM4/

(ध्यान दें कि परीक्षणों के लिए var का उपयोग एक स्कॉप्ड रैपर में एक अंतर बनाता है)

संदर्भ के लिए कोड:

(function(undefined) {
    var definedButNotInitialized;
    definedAndInitialized = 3;
    someObject = {
        firstProp: "1"
        , secondProp: false
        // , undefinedProp not defined
    }
    // var notDefined;

    var tests = [
        'definedButNotInitialized in window',
        'definedAndInitialized in window',
        'someObject.firstProp in window',
        'someObject.secondProp in window',
        'someObject.undefinedProp in window',
        'notDefined in window',

        '"definedButNotInitialized" in window',
        '"definedAndInitialized" in window',
        '"someObject.firstProp" in window',
        '"someObject.secondProp" in window',
        '"someObject.undefinedProp" in window',
        '"notDefined" in window',

        'typeof definedButNotInitialized == "undefined"',
        'typeof definedButNotInitialized === typeof undefined',
        'definedButNotInitialized === undefined',
        '! definedButNotInitialized',
        '!! definedButNotInitialized',

        'typeof definedAndInitialized == "undefined"',
        'typeof definedAndInitialized === typeof undefined',
        'definedAndInitialized === undefined',
        '! definedAndInitialized',
        '!! definedAndInitialized',

        'typeof someObject.firstProp == "undefined"',
        'typeof someObject.firstProp === typeof undefined',
        'someObject.firstProp === undefined',
        '! someObject.firstProp',
        '!! someObject.firstProp',

        'typeof someObject.secondProp == "undefined"',
        'typeof someObject.secondProp === typeof undefined',
        'someObject.secondProp === undefined',
        '! someObject.secondProp',
        '!! someObject.secondProp',

        'typeof someObject.undefinedProp == "undefined"',
        'typeof someObject.undefinedProp === typeof undefined',
        'someObject.undefinedProp === undefined',
        '! someObject.undefinedProp',
        '!! someObject.undefinedProp',

        'typeof notDefined == "undefined"',
        'typeof notDefined === typeof undefined',
        'notDefined === undefined',
        '! notDefined',
        '!! notDefined'
    ];

    var output = document.getElementById('results');
    var result = '';
    for(var t in tests) {
        if( !tests.hasOwnProperty(t) ) continue; // bleh

        try {
            result = eval(tests[t]);
        } catch(ex) {
            result = 'Exception--' + ex;
        }
        console.log(tests[t], result);
        output.innerHTML += "\n" + tests[t] + ": " + result;
    }
})();

और परिणाम:

definedButNotInitialized in window: true
definedAndInitialized in window: false
someObject.firstProp in window: false
someObject.secondProp in window: false
someObject.undefinedProp in window: true
notDefined in window: Exception--ReferenceError: notDefined is not defined
"definedButNotInitialized" in window: false
"definedAndInitialized" in window: true
"someObject.firstProp" in window: false
"someObject.secondProp" in window: false
"someObject.undefinedProp" in window: false
"notDefined" in window: false
typeof definedButNotInitialized == "undefined": true
typeof definedButNotInitialized === typeof undefined: true
definedButNotInitialized === undefined: true
! definedButNotInitialized: true
!! definedButNotInitialized: false
typeof definedAndInitialized == "undefined": false
typeof definedAndInitialized === typeof undefined: false
definedAndInitialized === undefined: false
! definedAndInitialized: false
!! definedAndInitialized: true
typeof someObject.firstProp == "undefined": false
typeof someObject.firstProp === typeof undefined: false
someObject.firstProp === undefined: false
! someObject.firstProp: false
!! someObject.firstProp: true
typeof someObject.secondProp == "undefined": false
typeof someObject.secondProp === typeof undefined: false
someObject.secondProp === undefined: false
! someObject.secondProp: true
!! someObject.secondProp: false
typeof someObject.undefinedProp == "undefined": true
typeof someObject.undefinedProp === typeof undefined: true
someObject.undefinedProp === undefined: true
! someObject.undefinedProp: true
!! someObject.undefinedProp: false
typeof notDefined == "undefined": true
typeof notDefined === typeof undefined: true
notDefined === undefined: Exception--ReferenceError: notDefined is not defined
! notDefined: Exception--ReferenceError: notDefined is not defined
!! notDefined: Exception--ReferenceError: notDefined is not defined

@ थॉमस एडिंग उत्तर के विपरीत:

अगर मैं अपने कोड में myVar घोषित करना भूल जाता हूं, तो मुझे अपना myVar is not defined

आइए एक वास्तविक उदाहरण लें:

मेरे पास एक परिवर्तनीय नाम है, लेकिन मुझे यकीन नहीं है कि यह कहीं घोषित किया गया है या नहीं।

फिर @ अनुराग का जवाब मदद करेगा:

var myVariableToCheck = 'myVar';
if (window[myVariableToCheck] === undefined)
    console.log("Not declared or declared, but undefined.");

// Or you can check it directly 
if (window['myVar'] === undefined) 
    console.log("Not declared or declared, but undefined.");

चूंकि अन्य उत्तरों में से कोई भी मेरी मदद नहीं करता है, इसलिए मैं ऐसा करने का सुझाव देता हूं। यह इंटरनेट एक्सप्लोरर 8 में मेरे लिए काम किया:

if (typeof variable_name.value === 'undefined') {
    // variable_name is undefined
}

व्यक्तिगत रूप से, मैं हमेशा निम्नलिखित का उपयोग करता हूं:

var x;
if( x === undefined) {
    //Do something here
}
else {
   //Do something else here
}

खिड़की .undefined संपत्ति सभी आधुनिक ब्राउज़रों (जावास्क्रिप्ट 1.8.5 या बाद में) में गैर लिखने योग्य है। मोज़िला के दस्तावेज़ से: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined , मुझे यह दिखाई देता है: typeof () का उपयोग करने का एक कारण यह है कि अगर कोई त्रुटि नहीं आती है चर परिभाषित नहीं किया गया है।

मैं उपयोग करने का दृष्टिकोण पसंद करते हैं

x === undefined 

क्योंकि यह पहले से घोषित नहीं किया गया है, तो चुपचाप गुजरने / असफल होने के बजाय यह मेरे चेहरे में विफल रहता है और उड़ाता है। यह मुझे चेतावनी देता है कि एक्स घोषित नहीं किया गया है। मेरा मानना ​​है कि जावास्क्रिप्ट में इस्तेमाल किए गए सभी चर घोषित किए जाने चाहिए।


आपको typeof का उपयोग करने की आवश्यकता है।

if (typeof something != "undefined") {
    // ...
}

function isArray(value) {
    if (value) {
        if (typeof value === 'object') {
            return (Object.prototype.toString.call(value) == '[object Array]')
        }
    }
    return false;
}

var ar = ["ff","tt"]
alert(isArray(ar))






javascript undefined