javascript - एक अपरिभाषित वस्तु संपत्ति का पता लगाना




object undefined (25)

यह जांचने का सबसे अच्छा तरीका क्या है कि जावास्क्रिप्ट में ऑब्जेक्ट प्रॉपर्टी अपरिभाषित है या नहीं?


Answers

मैंने देखा नहीं (उम्मीद है कि मुझे यह याद नहीं आया) कोई भी संपत्ति से पहले वस्तु की जांच कर रहा है। तो, यह सबसे छोटा और सबसे प्रभावी है (हालांकि जरूरी नहीं कि सबसे स्पष्ट):

if (obj && obj.prop) {
  // Do something;
}

यदि obj या obj.prop अपरिभाषित, शून्य, या "झूठी" है, तो अगर कथन कोड ब्लॉक निष्पादित नहीं करेगा। यह आमतौर पर अधिकांश कोड ब्लॉक कथन (जावास्क्रिप्ट में) में वांछित व्यवहार होता है।



उपयोग:

यह जांचने के लिए कि क्या संपत्ति अपरिभाषित है:

if (typeof something === "undefined") {
    alert("undefined");
}

यह जांचने के लिए कि क्या संपत्ति अपरिभाषित नहीं है:

if (typeof something !== "undefined") {
    alert("not undefined");
}

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

var snapshot = …;

if (typeof snaposhot === 'undefined') {
    //         ^
    // misspelled¹ – this will never run, but it won’t throw an error!
}
var foo = …;

if (typeof foo === 'undefned') {
    //                   ^
    // misspelled – this will never run, but it won’t throw an error!
}

तो जब तक आप फीचर डिटेक्शन² नहीं कर रहे हैं, जहां अनिश्चितता है कि कोई दिया गया नाम गुंजाइश में होगा (जैसे typeof module !== 'undefined' की जांच करना typeof module !== 'undefined' को सामान्यजेएस पर्यावरण के लिए विशिष्ट कोड में एक चरण के रूप में) typeof है, typeof एक हानिकारक विकल्प है जब इस्तेमाल किया जाता है एक चर पर, और सही विकल्प सीधे मूल्य की तुलना करना है:

var foo = …;

if (foo === undefined) {
    ⋮
}

इसके बारे में कुछ सामान्य गलत धारणाओं में शामिल हैं:

  • कि एक "अनियमित" चर ( var foo ) या पैरामीटर ( function bar(foo) { … } को पढ़ना, जिसे bar() कहा जाता है) विफल हो जाएगा। यह वास्तव में सत्य नहीं है - स्पष्ट प्रारंभिकता और पैरामीटर के बिना चर जो मान नहीं दिए गए थे हमेशा undefined हो जाते हैं, और हमेशा गुंजाइश में होते हैं।

  • कि undefined ओवरराइट किया जा सकता है। इसके लिए बहुत कुछ है। undefined जावास्क्रिप्ट में कोई कीवर्ड नहीं है। इसके बजाए, यह अपूर्ण परिभाषित मूल्य के साथ वैश्विक वस्तु पर एक संपत्ति है। हालांकि, ईएस 5 के बाद से, यह संपत्ति केवल-पढ़ने और गैर-कॉन्फ़िगर करने योग्य है । कोई आधुनिक ब्राउज़र undefined संपत्ति को बदलने की अनुमति नहीं देगा, और 2017 तक यह लंबे समय तक मामला रहा है। सख्त मोड की कमी undefined व्यवहार को प्रभावित नहीं करती है - यह सिर्फ undefined = 5 जैसे बयान देता है जो फेंकने के बजाए कुछ भी नहीं करता है। चूंकि यह कोई कीवर्ड नहीं है, हालांकि, आप undefined नाम के साथ चर घोषित कर सकते हैं, और उन चरों को बदला जा सकता है, यह एक बार-आम पैटर्न बनाते हैं:

    (function (undefined) {
        // …
    })()
    

    वैश्विक undefined उपयोग करने से अधिक खतरनाक। यदि आपको ईएस 3-संगत होना है, तो void 0 साथ undefined प्रतिस्थापित करें - typeof सहारा न लें। ( void हमेशा एक यूनरी ऑपरेटर रहा है जो किसी भी ऑपरेंड के लिए अपरिभाषित मान का मूल्यांकन करता है।)

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

इस:

if (typeof foo.bar === 'undefined') {
    ⋮
}

हमेशा इस के बराबर बराबर है:

if (foo.bar === undefined) {
    ⋮
}

और उपरोक्त सलाह को ध्यान में रखते हुए, भ्रमित पाठकों से बचने के लिए कि आप typeof का उपयोग क्यों कर रहे हैं, क्योंकि यह समानता की जांच करने के लिए === का उपयोग करने का सबसे अधिक अर्थ बनाता है, क्योंकि इसे बाद में एक चर के मूल्य की जांच करने के लिए दोबारा प्रतिक्रिया दी जा सकती है, और क्योंकि यह सिर्फ सादा बेहतर दिखता है, आपको हमेशा भी === undefined ³ का उपयोग करना चाहिए

जब ऑब्जेक्ट गुणों की बात आती है तो विचार करने के लिए कुछ और यह है कि क्या आप वास्तव में undefined जांच करना चाहते हैं। किसी दिए गए प्रॉपर्टी का नाम किसी ऑब्जेक्ट पर अनुपस्थित हो सकता है (पढ़ने के दौरान undefined मान का उत्पादन), ऑब्जेक्ट पर मौजूद undefined मूल्य के साथ मौजूद है, ऑब्जेक्ट के प्रोटोटाइप पर मौजूद मान के साथ मौजूद है, या गैर- undefined किसी भी पर मौजूद है मूल्य। Object.prototype.hasOwnProperty.call(obj, 'key') आपको बताएगी कि एक वस्तु किसी ऑब्जेक्ट की प्रोटोटाइप श्रृंखला पर कहीं भी है, और Object.prototype.hasOwnProperty.call(obj, 'key') आपको बताएगी कि यह सीधे ऑब्जेक्ट पर है या नहीं। प्रोटोटाइप के बारे में इस जवाब में मैं स्ट्रिंग-कीड मैप्स के रूप में इस ऑब्जेक्ट में विस्तार से नहीं जाऊंगा, हालांकि, मूल रूप से मूल प्रश्न की संभावित व्याख्याओं के बावजूद अन्य उत्तरों में सभी बुरी सलाह का सामना करना है। अधिक के लिए एमडीएन पर ऑब्जेक्ट प्रोटोटाइप पर पढ़ें!

उदाहरण परिवर्तनीय नाम की असामान्य पसंद? फ़ायरफ़ॉक्स के लिए नोस्क्रिप्ट एक्सटेंशन से यह वास्तविक मृत कोड है।
² यह न मानें कि सामान्य रूप से क्या गुंजाइश है, यह नहीं जानना ठीक है। गतिशील दायरे के दुरुपयोग के कारण बोनस भेद्यता: परियोजना शून्य 1225
³ एक बार फिर एक ईएस 5 + पर्यावरण मानते हैं और यह undefined वैश्विक वस्तु की undefined संपत्ति को संदर्भित करता है। अन्यथा void 0 विकल्प।


यदि तुम करो

if (myvar == undefined )
{ 
    alert('var does not exists or is not initialized');
}

यह विफल हो जाएगा जब परिवर्तनीय myvar मौजूद नहीं है, क्योंकि myvar परिभाषित नहीं है, इसलिए लिपि टूट गई है और परीक्षण का कोई प्रभाव नहीं है।

चूंकि विंडो ऑब्जेक्ट में फ़ंक्शन के बाहर एक वैश्विक दायरा (डिफ़ॉल्ट ऑब्जेक्ट) है, इसलिए विंडो ऑब्जेक्ट में एक घोषणा 'संलग्न' होगी।

उदाहरण के लिए:

var myvar = 'test';

वैश्विक परिवर्तनीय myvar window.myvar या विंडो ['myvar'] जैसा ही है

वैश्विक चर मौजूद होने पर परीक्षण करने के लिए त्रुटियों से बचने के लिए, आप बेहतर उपयोग करते हैं:

if(window.myvar == undefined )
{ 
    alert('var does not exists or is not initialized');
}

सवाल यह है कि यदि एक चर वास्तव में मौजूद है, इससे कोई फर्क नहीं पड़ता, इसका मान गलत है। अन्यथा, यह अनिर्धारित चर के साथ वैरिएबल प्रारंभ करने के लिए मूर्ख है, और यह प्रारंभ करने के लिए गलत मूल्य का उपयोग बेहतर है। जब आप जानते हैं कि आपके द्वारा घोषित किए गए सभी चर को झूठी के साथ प्रारंभ किया गया है, तो आप बस इसके प्रकार की जांच कर सकते हैं या इस पर भरोसा कर सकते हैं !window.myvar यह जांचने के लिए कि उसके पास उचित / मान्य मान है या नहीं। तो जब चर को परिभाषित नहीं किया जाता है तब भी !window.myvar myvar = undefined या myvar = false या myvar = 0

जब आप किसी विशिष्ट प्रकार की अपेक्षा करते हैं, तो चर के प्रकार का परीक्षण करें। एक ऐसी स्थिति का परीक्षण करने के लिए जो आप बेहतर करते हैं:

if( !window.myvar || typeof window.myvar != 'string' )
{
    alert('var does not exists or is not type of string');
}

जब पहली और सरल स्थिति सच होती है, तो दुभाषिया अगले परीक्षणों को छोड़ देता है।

चर के आवृत्ति / ऑब्जेक्ट का उपयोग करना हमेशा बेहतर होता है यह जांचने के लिए कि क्या यह वैध मान है या नहीं। यह अधिक स्थिर है और प्रोग्रामिंग का एक बेहतर तरीका है।

(Y)


इस के माध्यम से पढ़ना, मुझे आश्चर्य है कि मैंने यह नहीं देखा। मुझे कई एल्गोरिदम मिले हैं जो इसके लिए काम करेंगे।

कभी परिभाषित नहीं

यदि किसी ऑब्जेक्ट का मान कभी परिभाषित नहीं किया गया था, trueतो इसे वापस करने से रोक दिया जाएगा यदि इसे परिभाषित किया गया है nullया undefined। यह सहायक है यदि आप मान सेट के लिए वापस लौटने के लिए सच होना चाहते हैंundefined

if(obj.prop === void 0) console.log("The value has never been defined");

अपरिभाषित या कभी परिभाषित के रूप में परिभाषित नहीं

यदि आप इसे परिणाम के रूप में trueपरिभाषित मूल्यों के रूप में परिणाम देना चाहते हैं undefined, या कभी परिभाषित नहीं किया है, तो आप बस उपयोग कर सकते हैं=== undefined

if(obj.prop === undefined) console.log("The value is defined as undefined, or never defined");

एक झूठा मूल्य के रूप में परिभाषित, अपरिभाषित, शून्य, या कभी परिभाषित नहीं।

आम तौर पर, लोगों ने मुझे यह पता लगाने के लिए एक एल्गोरिदम के लिए कहा है कि कोई मूल्य या तो गलत है undefined, या null। निम्नलिखित काम करता है।

if(obj.prop == false || obj.prop === null || obj.prop === undefined) {
    console.log("The value is falsy, null, or undefined");
}

"propertyName" in obj //-> true | false

समाधान गलत है। जावास्क्रिप्ट में,

null == undefined

सच हो जाएगा, क्योंकि वे दोनों एक बुलियन के लिए "जाली" हैं और झूठे हैं। सही तरीका जांचना होगा

if (something === undefined)

जो पहचान ऑपरेटर है ...


मुझे यकीन नहीं है कि typeof साथ === का उपयोग करने की उत्पत्ति कहां से आई है, और एक सम्मेलन के रूप में मुझे लगता है कि यह कई पुस्तकालयों में उपयोग किया जाता है, लेकिन टाइपोफ ऑपरेटर एक स्ट्रिंग शाब्दिक देता है, और हम इसे आगे जानते हैं, तो आप क्यों यह भी जांचना चाहते हैं?

typeof x;                      // some string literal "string", "object", "undefined"
if (typeof x === "string") {   // === is redundant because we already know typeof returns a string literal
if (typeof x == "string") {    // sufficient

undefinedपरिवर्तनीय की सुरक्षा के लिए मैं आपको कुछ ऐसा दिखाना चाहता हूं जिसका उपयोग मैं कर रहा हूं :

Object.defineProperty(window, 'undefined', {});

यह किसी भी window.undefinedवैरिएबल के आधार पर कोड को नष्ट करने के लिए मूल्य को बदलने के लिए मना करता है । यदि उपयोग कर रहा है "use strict", तो इसके मूल्य को बदलने की कोशिश करने वाली कुछ भी त्रुटि में समाप्त हो जाएगी, अन्यथा इसे चुपचाप अनदेखा कर दिया जाएगा।


यदि आप कोणीय का उपयोग कर रहे हैं:

angular.isUndefined(obj)
angular.isUndefined(obj.prop)

Underscore.js:

_.isUndefined(obj) 
_.isUndefined(obj.prop) 

सभी जवाब अपूर्ण हैं। यह जानने का सही तरीका है कि एक संपत्ति 'अपरिभाषित के रूप में परिभाषित' है:

var hasUndefinedProperty = function hasUndefinedProperty(obj, prop){
  return ((prop in obj) && (typeof obj[prop] == 'undefined')) ;
} ;

उदाहरण:

var a = { b : 1, e : null } ;
a.c = a.d ;

hasUndefinedProperty(a, 'b') ; // false : b is defined as 1
hasUndefinedProperty(a, 'c') ; // true : c is defined as undefined
hasUndefinedProperty(a, 'd') ; // false : d is undefined
hasUndefinedProperty(a, 'e') ; // false : e is defined as null

// And now...
delete a.c ;
hasUndefinedProperty(a, 'c') ; // false : c is undefined

बहुत बुरा है कि यह सही जवाब गलत उत्तरों में दफनाया गया है> _ <

तो, जो भी पास करता है, मैं आपको मुफ्त में अपरिभाषित करूंगा !!

var undefined ; undefined ; // undefined
({}).a ;                    // undefined
[].a ;                      // undefined
''.a ;                      // undefined
(function(){}()) ;          // undefined
void(0) ;                   // undefined
eval() ;                    // undefined
1..a ;                      // undefined
/a/.a ;                     // undefined
(true).a ;                  // undefined

उपयोग:

if (typeof something === "undefined") {
    alert("something is undefined");
}

यदि कोई ऑब्जेक्ट वैरिएबल जिसमें कुछ गुण हैं तो आप इस तरह की चीज़ का उपयोग कर सकते हैं:

if (typeof my_obj.someproperties === "undefined"){
    console.log('the property is not available...'); // print into console
}

' अगर (window.x) {} ' त्रुटि सुरक्षित है

सबसे अधिक संभावना है कि आप चाहते हैं if (window.x) । यह चेक सुरक्षित है भले ही एक्स घोषित नहीं किया गया हो ( var x; ) - ब्राउज़र कोई त्रुटि नहीं फेंकता है।

उदाहरण: मैं जानना चाहता हूं कि मेरा ब्राउज़र इतिहास API का समर्थन करता है या नहीं

if (window.history) {
    history.call_some_function();
}

यह कैसे काम करता है:

खिड़की एक ऐसी वस्तु है जो सभी वैश्विक चर को अपने सदस्यों के रूप में रखती है, और गैर-मौजूदा सदस्य तक पहुंचने का प्रयास करना कानूनी है। यदि एक्स घोषित नहीं किया गया है या सेट नहीं किया गया है तो अपरिभाषितwindow.x रिटर्न । अपरिभाषित झूठ की ओर जाता है जब () इसका मूल्यांकन करता है।


जावास्क्रिप्ट में बस कुछ भी परिभाषित नहीं किया गया है, अपरिभाषित है , इससे कोई फर्क नहीं पड़ता कि यह ऑब्जेक्ट / ऐरे के अंदर या केवल एक साधारण चर के रूप में है ...

जावास्क्रिप्ट है typeofजो एक अपरिभाषित चर का पता लगाने में बहुत आसान बनाता है।

बस जांचें कि क्या typeof whatever === 'undefined'यह एक बुलियन लौटाएगा।

इस तरह isUndefined()AngularJs v.1x में प्रसिद्ध फ़ंक्शन लिखा गया है:

function isUndefined(value) {return typeof value === 'undefined';} 

इसलिए जब आप देखते हैं कि फ़ंक्शन एक मान प्राप्त करता है, यदि वह मान परिभाषित किया गया है, तो यह वापस आ जाएगा false, अन्यथा अपरिभाषित मानों के लिए, वापसी करें true

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

var  = {};
.javascipt = 'javascript';
var today;
var self = this;
var num = 8;
var list = [1, 2, 3, 4, 5];
var y = null;

और हम उन्हें नीचे की जांच करते हैं, आप उनके सामने परिणामों को एक टिप्पणी के रूप में देख सकते हैं:

isUndefined(); //false
isUndefined(.javascipt); //false
isUndefined(today); //true
isUndefined(self); //false
isUndefined(num); //false
isUndefined(list); //false
isUndefined(y); //false
isUndefined(.java); //true
isUndefined(.php); //true
isUndefined( && .css); //true

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

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

यदि आप किसी ऑब्जेक्ट पर कोई संपत्ति जांचते हैं और ऑब्जेक्ट मौजूद नहीं है, तो कोई त्रुटि फेंक देगी और पूरे एप्लिकेशन को चालू कर देगा।

isUndefined(x.css);
VM808:2 Uncaught ReferenceError: x is not defined(…)

इतना आसान है कि आप नीचे दिए गए कथन के अंदर लपेट सकते हैं:

if(typeof x !== 'undefined') {
  //do something
}

जो कोणीय 1.x में परिभाषित किया गया है बराबर है ...

function isDefined(value) {return typeof value !== 'undefined';}

अंडरस्कोर जैसे अन्य जावास्क्रिप्ट ढांचे में समान परिभाषा जांच है, लेकिन typeofअगर आप पहले से ही किसी भी ढांचे का उपयोग नहीं कर रहे हैं तो मैं आपको सलाह देता हूं ।

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

सख्त समानता और अपरिभाषित
आप यह निर्धारित करने के लिए अपरिपक्व और सख्त समानता और असमानता ऑपरेटरों का उपयोग कर सकते हैं कि एक चर के पास मूल्य है या नहीं। निम्नलिखित कोड में, चर x को परिभाषित नहीं किया गया है, और यदि कथन कथन का मूल्यांकन करता है।

var x;
if (x === undefined) {
   // these statements execute
}
else {
   // these statements do not execute
}

नोट: मानक समानता ऑपरेटर की बजाय सख्त समानता ऑपरेटर का उपयोग यहां किया जाना चाहिए, क्योंकि x == अपरिभाषित यह भी जांचता है कि x शून्य है, जबकि सख्त समानता नहीं है। शून्य अपरिभाषित के बराबर नहीं है। विवरण के लिए तुलना ऑपरेटर देखें।

टाइपफ़ो ऑपरेटर और अपरिभाषित
वैकल्पिक रूप से, टाइपफ़ का उपयोग किया जा सकता है:

var x;
if (typeof x === 'undefined') {
   // these statements execute
}

टाइपफ का उपयोग करने का एक कारण यह है कि यदि चर घोषित नहीं किया गया है तो यह कोई त्रुटि नहीं फेंकता है।

// x has not been declared before
if (typeof x === 'undefined') { // evaluates to true without errors
   // these statements execute
}

if (x === undefined) { // throws a ReferenceError

}

हालांकि, इस तरह की तकनीक से बचा जाना चाहिए। जावास्क्रिप्ट एक स्थाई रूप से स्कॉम्ड भाषा है, इसलिए यह जानकर कि एक चर घोषित किया गया है, यह देखकर पढ़ा जा सकता है कि इसे एक संलग्न संदर्भ में घोषित किया गया है या नहीं। वैश्विक अपवाद ही एकमात्र अपवाद है, लेकिन वैश्विक दायरा वैश्विक वस्तु से जुड़ा हुआ है, इसलिए वैश्विक संदर्भ में एक चर के अस्तित्व की जांच करना वैश्विक वस्तु पर संपत्ति के अस्तित्व की जांच करके किया जा सकता है (ऑपरेटर का उपयोग करके, उदाहरण के लिए)।

शून्य ऑपरेटर और अपरिभाषित

शून्य ऑपरेटर तीसरा विकल्प है।

var x;
if (x === void 0) {
   // these statements execute
}

// y has not been declared before
if (y === void 0) {
   // throws a ReferenceError (in contrast to `typeof`)
}

अधिक> here


इसका क्या अर्थ है: "अपरिभाषित वस्तु संपत्ति" ?

असल में इसका मतलब दो अलग-अलग चीजें हो सकता है! सबसे पहले, इसका अर्थ उस संपत्ति का हो सकता है जिसे ऑब्जेक्ट में कभी परिभाषित नहीं किया गया है और दूसरा, इसका अर्थ उस संपत्ति का हो सकता है जिसमें एक अनिर्धारित मूल्य है । आइए इस कोड को देखें:

var o = { a: undefined }

क्या oa अनिर्धारित है? हाँ! इसका मूल्य अपरिभाषित है। क्या ob अनिर्धारित है? ज़रूर! कोई संपत्ति 'बी' बिल्कुल नहीं है! ठीक है, अब देखें कि दोनों स्थितियों में अलग-अलग दृष्टिकोण कैसे व्यवहार करते हैं:

typeof o.a == 'undefined' // true
typeof o.b == 'undefined' // true
o.a === undefined // true
o.b === undefined // true
'a' in o // true
'b' in o // false

हम स्पष्ट रूप से देख सकते हैं कि typeof obj.prop == 'undefined' और obj.prop === undefined समकक्ष हैं, और वे उन अलग-अलग स्थितियों में अंतर नहीं करते हैं। और 'prop' in obj स्थिति का पता लगा सकता है जब एक संपत्ति को बिल्कुल परिभाषित नहीं किया गया है और संपत्ति मूल्य पर ध्यान नहीं देता है जिसे अपरिभाषित किया जा सकता है।

इसलिए क्या करना है?

1) आप जानना चाहते हैं कि किसी संपत्ति को पहले या दूसरे अर्थ (सबसे सामान्य स्थिति) द्वारा अपरिभाषित किया गया है या नहीं।

obj.prop === undefined // IMHO, see "final fight" below

2) आप सिर्फ यह जानना चाहते हैं कि ऑब्जेक्ट में कुछ संपत्ति है और इसके मूल्य की परवाह नहीं है।

'prop' in obj

टिप्पणियाँ:

  • आप एक ही समय में एक वस्तु और उसकी संपत्ति की जांच नहीं कर सकते हैं। उदाहरण के लिए, यह xa === undefined या इस typeof xa == 'undefined' ReferenceError: x is not defined typeof xa == 'undefined' बढ़ाता है ReferenceError: x is not defined यदि x परिभाषित नहीं किया गया है।
  • वैरिएबल undefined एक वैश्विक चर है (इसलिए वास्तव में यह window.undefined में window.undefined है। इसे ईसीएमएस्क्रिप्ट 1 संस्करण के बाद से समर्थित किया गया है और ईसीएमएस्क्रिप्ट 5 के बाद से इसे केवल पढ़ा जाता है । तो आधुनिक ब्राउज़रों में इसे सत्य के रूप में फिर से परिभाषित नहीं किया जा सकता है क्योंकि कई लेखक हमें डराने के लिए प्यार करते हैं, लेकिन यह अभी भी पुराने ब्राउज़र के लिए सच है।

अंतिम लड़ाई: obj.prop === undefined बनाम typeof obj.prop == 'undefined'

obj.prop === undefined के obj.prop === undefined :

  • यह थोड़ा छोटा है और थोड़ा सुंदर दिखता है
  • यदि आपने गलत वर्तनी को गलत तरीके से गलत किया है तो जावास्क्रिप्ट इंजन आपको एक त्रुटि देगा

Obj.prop obj.prop === undefined के obj.prop === undefined :

  • पुराने ब्राउज़र में undefined ओवरराइड किया जा सकता है

typeof obj.prop == 'undefined' :

  • यह वास्तव में सार्वभौमिक है! यह नए और पुराने ब्राउज़र में काम करता है।

टाइप करने के typeof obj.prop == 'undefined' :

  • 'undefned' ( गलत वर्तनी ) यहां केवल एक स्ट्रिंग स्थिर है, इसलिए जावास्क्रिप्ट इंजन आपकी मदद नहीं कर सकता है अगर आपने इसे गलत तरीके से गलत तरीके से किया है।

अद्यतन (सर्वर-साइड जावास्क्रिप्ट के लिए):

Node.js वैश्विक चर के रूप में undefined वैश्विक चर का समर्थन करता है (इसे 'वैश्विक' उपसर्ग के बिना भी उपयोग किया जा सकता है)। मैं सर्वर-साइड जावास्क्रिप्ट के अन्य कार्यान्वयन के बारे में नहीं जानता।


function isUnset(inp) {
  return (typeof inp === 'undefined')
}

परिवर्तनीय सेट होने पर गलत लौटाता है, और यदि अनिर्धारित है तो सत्य।

फिर उपयोग करें:

if (isUnset(var)) {
  // initialize variable here
}

जावास्क्रिप्ट में शून्य है और अपरिभाषित है । उनके पास अलग-अलग अर्थ हैं।

  • अपरिभाषित मतलब है कि परिवर्तनीय मान परिभाषित नहीं किया गया है; यह ज्ञात नहीं है कि मूल्य क्या है।
  • शून्य का अर्थ है कि परिवर्तनीय मान परिभाषित किया गया है और शून्य पर सेट है (कोई मूल्य नहीं है)।

Marijn Haverbeke कहते हैं, अपनी मुफ्त, ऑनलाइन पुस्तक " Eloquent जावास्क्रिप्ट " (जोर मेरा):

एक समान मूल्य भी है, शून्य, जिसका अर्थ है 'यह मान परिभाषित किया गया है, लेकिन इसका कोई मूल्य नहीं है'। अपरिभाषित और शून्य के बीच अर्थ में अंतर ज्यादातर अकादमिक है, और आमतौर पर बहुत दिलचस्प नहीं है। व्यावहारिक कार्यक्रमों में, यह जांचना अक्सर आवश्यक होता है कि कुछ 'मूल्य है'। इन मामलों में, अभिव्यक्ति कुछ == अपरिभाषित किया जा सकता है, क्योंकि, हालांकि वे बिल्कुल वही मान नहीं हैं, नल == अपरिभाषित सत्य उत्पन्न करेगा।

तो, मुझे लगता है कि कुछ अपरिभाषित किया गया था या नहीं, यह जांचने का सबसे अच्छा तरीका होगा:

if (something == undefined)

उम्मीद है की यह मदद करेगा!

संपादित करें: आपके संपादन के जवाब में, ऑब्जेक्ट गुणों को वैसे ही काम करना चाहिए।

var person = {
    name: "John",
    age: 28,
    sex: "male"
};

alert(person.name); // "John"
alert(person.fakeVariable); // undefined

एक परिभाषित प्रॉपर्टी को एक नए वैरिएबल को असाइन करने का एक अच्छा और सुरुचिपूर्ण तरीका है, यदि इसे परिभाषित किया गया है या इसे डिफ़ॉल्ट मान असाइन किया गया है, तो यह फ़ॉलबैक के रूप में अपरिवर्तित है।

var a = obj.prop || defaultValue;

यह उपयुक्त है यदि आपके पास कोई फ़ंक्शन है, जो अतिरिक्त कॉन्फ़िगरेशन प्रॉपर्टी प्राप्त करता है:

var yourFunction = function(config){

   this.config = config || {};
   this.yourConfigValue = config.yourConfigValue || 1;
   console.log(this.yourConfigValue);

}

अब निष्पादित

yourFunction({yourConfigValue:2});
//=> 2

yourFunction();
//=> 1

yourFunction({otherProperty:5});
//=> 1

मुझे आश्चर्य है कि मैंने अभी तक यह सुझाव नहीं देखा है, लेकिन परीक्षण के मुकाबले यह और भी विशिष्टता प्राप्त करता है typeof। का प्रयोग करें Object.getOwnPropertyDescriptor()अगर आप जानना आवश्यक है कि एक वस्तु संपत्ति के साथ प्रारंभ किया गया था की जरूरत है undefinedया अगर यह कभी नहीं प्रारंभ किया गया था:

// to test someObject.someProperty
var descriptor = Object.getOwnPropertyDescriptor(someObject, 'someProperty');

if (typeof descriptor === 'undefined') {
  // was never initialized
} else if (typeof descriptor.value === 'undefined') {
  if (descriptor.get || descriptor.set) {
    // is an accessor property, defined via getter and setter
  } else {
    // is initialized with `undefined`
  }
} else {
  // is initialized with some other value
}

इसके अलावा एक ही चीज कम लिखी जा सकती है:

if (!variable){
    //do it if variable is Undefined
}

या

if (variable){
    //do it if variable is Defined
}

void 0Terseness के साथ तुलना करें ।

if (foo !== void 0)

यह वर्बोज़ के रूप में नहीं है if (typeof foo !== 'undefined')


टिप्पणियों के माध्यम से जाना, उन लोगों के लिए जो दोनों को जांचना चाहते हैं, यह अनिर्धारित है या इसका मूल्य शून्य है:

//Just in JavaScript
var s; // Undefined
if (typeof s == "undefined" || s === null){
    alert('either it is undefined or value is null')
}

यदि आप jQuery लाइब्रेरी का उपयोग कर रहे हैं तो jQuery.isEmptyObject()दोनों मामलों के लिए पर्याप्त होगा,

var s; // Undefined
jQuery.isEmptyObject(s); // Will return true;

s = null; // Defined as null
jQuery.isEmptyObject(s); // Will return true;

//Usage
if (jQuery.isEmptyObject(s)) {
    alert('Either variable:s is undefined or its value is null');
} else {
     alert('variable:s has value ' + s);
}

s = 'something'; // Defined with some value
jQuery.isEmptyObject(s); // Will return false;

संबंधित प्रश्न से मेरा answer क्रॉसपोस्टिंग जावास्क्रिप्ट में "अपरिभाषित" की जांच कैसे करें?

इस प्रश्न के लिए विशिष्ट, someObject.<whatever> साथ टेस्ट केस देखें someObject.<whatever>

विभिन्न उत्तरों के परिणामों को चित्रित करने वाले कुछ परिदृश्य: 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

ECMAScript 7 array.includes(value) प्रस्तुत array.includes(value)

इसका इस्तेमाल इस तरह किया जा सकता है:

[1, 2, 3].includes(2); // true
[1, 2, 3].includes(4); // false

यह fromIndex वैकल्पिक दूसरा तर्क भी स्वीकार करता है:

[1, 2, 3].includes(3, 3); // false
[1, 2, 3].includes(3, -1); // true

SameValueZero विपरीत, जो सख्त समानता तुलना का उपयोग करता है, includes समान SameValueZero समानता एल्गोरिदम का उपयोग करके तुलना includes है। इसका मतलब है कि आप यह पता लगा सकते हैं कि किसी सरणी में NaN शामिल है या नहीं:

[1, 2, NaN].includes(NaN); // true

indexOf विपरीत, includes लापता सूचकांक भी नहीं छोड़े गए हैं:

new Array(5).includes(undefined); // true

वर्तमान में यह अभी भी एक मसौदा है लेकिन इसे सभी ब्राउज़रों पर काम करने के लिए polyfill किया जा सकता है।







javascript object undefined