javascript - हरण - जावास्क्रिप्ट जांचें यदि चर मौजूद है(परिभाषित/प्रारंभिक है)




हिंदी में जावास्क्रिप्ट परिचय (19)

जांचें कि क्या ऑब्जेक्ट hasOwnProperty()

hasOwnProperty() उत्तरों के लिए एक विकल्प, hasOwnProperty() का उपयोग है जो निश्चित रूप से जांचता है कि क्या ऑब्जेक्ट (जेएस में काफी कुछ भी) में एक संपत्ति है यानी एक चर (अन्य चीजों के साथ)।

hasOwnProperty() विधि एक बुलियन दर्शाती है कि क्या ऑब्जेक्ट में निर्दिष्ट संपत्ति है (विरासत में नहीं) संपत्ति।

ऑब्जेक्ट से निकली प्रत्येक वस्तु hasOwnProperty() विधि को प्राप्त करती है। इस विधि का उपयोग यह निर्धारित करने के लिए किया जा सकता है कि किसी ऑब्जेक्ट में उस ऑब्जेक्ट की प्रत्यक्ष संपत्ति के रूप में निर्दिष्ट संपत्ति है; ऑपरेटर के विपरीत, यह विधि ऑब्जेक्ट की प्रोटोटाइप श्रृंखला की जांच नहीं करती है।

// Globally established (therefore) properties of window
var foo = "whatever", // string
    bar = false,      // bool
    baz;              // undefined
// window.qux does not exist

console.log( [
    window.hasOwnProperty( "foo" ),             // true
    window.hasOwnProperty( "bar" ),             // true
    window.hasOwnProperty( "baz" ),             // true
    window.hasOwnProperty( "qux" ),             // false
    { foo: [], bar: 0 }.hasOwnProperty( "bar" ) // true
] );

hasOwnProperty() बारे में क्या बढ़िया है, यह है कि इसे कॉल करने में, हम एक वेरिएबल का उपयोग नहीं करते हैं जो अभी तक अपरिभाषित हो सकता है - निश्चित रूप से पहली जगह में आधा समस्या है।

यद्यपि हमेशा सही या आदर्श समाधान नहीं, कुछ परिस्थितियों में, यह सिर्फ नौकरी है!

एक वैरिएबल शुरू किया गया है या नहीं, यह जांचने की कौन सी विधि बेहतर / सही है? (चर मानते हुए कुछ भी हो सकता है (स्ट्रिंग, int, ऑब्जेक्ट, फ़ंक्शन, आदि))

if (elem) { // or !elem

या

if (typeof(elem) !== 'undefined') {

या

if (elem != null) {

एक चर मौजूद है या नहीं

परीक्षण के लिए यह एक सुंदर बुलेटप्रूफ समाधान है यदि एक चर मौजूद है और प्रारंभ किया गया है:

var setOrNot = typeof variable !== typeof undefined;

किसी निश्चित चर को प्रारंभ नहीं किया गया है, तो इसे डिफ़ॉल्ट रूप से सेट करने के लिए टर्नरी ऑपरेटर के साथ संयोजन में उपयोग किया जाता है:

var dark = typeof darkColor !== typeof undefined ? darkColor : "black";

Encapsulation के साथ समस्याएं

दुर्भाग्यवश, आप किसी फ़ंक्शन में बस अपनी जांच को समाहित नहीं कर सकते हैं।

आप ऐसा कुछ करने के बारे में सोच सकते हैं:

function isset(variable) {
    return typeof variable !== typeof undefined;
}

हालांकि, अगर आप कॉल कर रहे हैं तो यह एक संदर्भ त्रुटि उत्पन्न करेगा। isset(foo) और variable foo को परिभाषित नहीं किया गया है, क्योंकि आप एक गैर-मौजूदा चर के साथ फ़ंक्शन में पास नहीं कर सकते हैं:

Uncaught ReferenceError: foo परिभाषित नहीं किया गया है

परीक्षण करना कि फ़ंक्शन पैरामीटर अपरिभाषित हैं या नहीं

जबकि हमारे isset फ़ंक्शन का परीक्षण यह नहीं किया जा सकता है कि एक चर मौजूद है या नहीं (कारणों के बारे में बताए गए कारणों के लिए), यह हमें यह जांचने की अनुमति देता है कि फ़ंक्शन के पैरामीटर अपरिभाषित हैं या नहीं:

var a = '5';

var test = function(x, y) {
    console.log(isset(x));
    console.log(isset(y));
};

test(a);

// OUTPUT :
// ------------
// TRUE
// FALSE

भले ही y लिए कोई मान फ़ंक्शन test साथ पास नहीं किया गया हो, फिर भी हमारे isset फ़ंक्शन इस संदर्भ में पूरी तरह से काम करता है, क्योंकि y फ़ंक्शन test में एक undefined मान के रूप में जाना जाता है।


अधिकांश मामलों में आप उपयोग करेंगे:

elem != null

एक साधारण if (elem) विपरीत, यह 0 , false , NaN और '' अनुमति देता है, लेकिन null या undefined को अस्वीकार करता है, जिससे यह तर्क की उपस्थिति या किसी ऑब्जेक्ट की संपत्ति के लिए एक अच्छा, सामान्य परीक्षण होता है।

अन्य चेक गलत नहीं हैं, उनके पास अलग-अलग उपयोग हैं:

  • if (elem) : यदि elem को ऑब्जेक्ट होने की गारंटी दी जाती है, या false , 0 , आदि को "डिफ़ॉल्ट" मान माना जाता है (इसलिए undefined या null बराबर) माना जाता है।

  • typeof elem == 'undefined' उन मामलों में उपयोग किया जा सकता है जहां एक निर्दिष्ट null का एक अनियमित चर या संपत्ति के लिए एक अलग अर्थ है।

    • यह एकमात्र जांच है जो गलती नहीं घोषित करेगी अगर elem घोषित नहीं किया गया है (यानी कोई var कथन नहीं, window संपत्ति नहीं, या फ़ंक्शन तर्क नहीं)। यह मेरी राय में, बल्कि खतरनाक है क्योंकि यह टाइपो को अनजान द्वारा पर्ची करने की अनुमति देता है। इससे बचने के लिए, नीचे दी गई विधि देखें।

undefined खिलाफ सख्त तुलना भी उपयोगी है:

if (elem === undefined) ...

हालांकि, क्योंकि वैश्विक undefined किसी अन्य मूल्य के साथ ओवरराइड किया जा सकता है, इसका उपयोग करने से पहले मौजूदा दायरे में undefined चर को घोषित करना सबसे अच्छा है:

var undefined; // really undefined
if (elem === undefined) ...

या:

(function (undefined) {
    if (elem === undefined) ...
})();

इस विधि का एक माध्यमिक लाभ यह है कि जेएस मिनीफायर undefined वैरिएबल को एक ही वर्ण में कम कर सकते हैं, जिससे आप हर बार कुछ बाइट्स बचा सकते हैं।


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


var _undefined;
var _null = null;

alert(_undefined); 
alert(_null); 
alert(_undefined == _null);
alert(_undefined === _null);


आप typeof ऑपरेटर चाहते हैं। विशेष रूप से:

if (typeof variable !== 'undefined') {
    // the variable is defined
}

आप typeof ऑपरेटर का उपयोग कर सकते हैं।

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

var dataSet;

alert("Variable dataSet is : " + typeof dataSet);

उपरोक्त कोड स्निपेट आउटपुट को वापस कर देगा

परिवर्तनीय डेटासेट है: अपरिभाषित।


एक साधारण के बारे में क्या:

if(!!variable){
  //the variable is defined
}

कई मामलों में, उपयोग कर रहे हैं:

if (elem) { // or !elem

आपके लिए नौकरी करेगा! ... यह इन मामलों के मामलों की जांच करेगा:

  1. अपरिभाषित : यदि मान परिभाषित नहीं किया गया है और यह undefined
  2. शून्य : यदि यह शून्य है, उदाहरण के लिए यदि कोई DOM तत्व मौजूद नहीं है ...
  3. खाली स्ट्रिंग : ''
  4. 0 : संख्या शून्य
  5. NaN : एक संख्या नहीं
  6. असत्य

तो यह सभी मामलों को बंद कर देगा, लेकिन हमेशा अजीब मामले होते हैं जिन्हें हम भी कवर करना चाहते हैं, उदाहरण के लिए रिक्त स्थान वाली स्ट्रिंग, जैसे कि ' ' , इसे जावास्क्रिप्ट में परिभाषित किया जाएगा क्योंकि इसमें अंदर की जगह है स्ट्रिंग ... उदाहरण के लिए इस मामले में आप ट्रिम () का उपयोग करके एक और चेक जोड़ते हैं, जैसे:

if(elem) {

if(typeof elem === 'string' && elem.trim()) {
///

साथ ही, ये चेक केवल मानों के लिए हैं , क्योंकि वस्तुओं और सरणी जावास्क्रिप्ट में अलग-अलग काम करते हैं, खाली सरणी [] और खाली वस्तु {} हमेशा सत्य होती है

मैं जवाब के त्वरित संक्षेप दिखाने के लिए नीचे दी गई छवि बना देता हूं:


थोड़ा और अधिक कार्यात्मक और उपयोग करने में आसान:

function exist(obj)
{
    return (typeof obj !== 'undefined');
}

यदि मौजूद है तो फ़ंक्शन सत्य वापस आ जाएगा, अन्यथा मौजूद नहीं है तो गलत है।


नल जावास्क्रिप्ट में एक मान है और typeof null रिटर्न "object"

इसलिए, स्वीकृत उत्तर काम नहीं करेगा यदि आप शून्य मान पास करते हैं। यदि आप शून्य मान पास करते हैं, तो आपको शून्य मानों के लिए अतिरिक्त चेक जोड़ने की आवश्यकता है:

if ((typeof variable !== "undefined") && (variable !== null))  
{
   // the variable is defined and not null
}

बहस में योगदान करने के लिए, यदि मुझे पता है कि चर एक स्ट्रिंग या ऑब्जेक्ट होना चाहिए, तो मैं हमेशा पसंद करता हूं if (!variable) , तो जांच कर रहा है कि यह गलत है या नहीं। यह अधिक स्वच्छ कोड ला सकता है ताकि, उदाहरण के लिए:

if (typeof data !== "undefined" && typeof data.url === "undefined") {
    var message = 'Error receiving response';
    if (typeof data.error !== "undefined") {
        message = data.error;
    } else if (typeof data.message !== "undefined") {
        message = data.message;
    }
    alert(message); 
}

.. को कम किया जा सकता है:

if (data && !data.url) {
  var message = data.error || data.message || 'Error receiving response';
  alert(message)
} 


मेरी वरीयता typeof(elem) != 'undefined' && elem != null

हालांकि आप चुनते हैं, इस तरह के फ़ंक्शन में चेक डालने पर विचार करें

function existy (x) {
    return typeof (x) != 'undefined' && x != null;
}

यदि आपको नहीं पता कि वेरिएबल घोषित किया गया है तो typeof (x) != 'undefined' && x != null;

जहां आप जानते हैं कि चर घोषित किया गया है लेकिन अस्तित्व में नहीं हो सकता है, तो आप इसका उपयोग कर सकते हैं

existy(elem) && doSomething(elem);

वे चर जो आप जांच रहे हैं कभी-कभी घोंसला वाली संपत्ति हो सकती है। आप प्रोप का उपयोग कर सकते हैं || {} प्रश्न में संपत्ति की लाइन जांच अस्तित्व को नीचे जाने के लिए:

var exists = ((((existy(myObj).prop1||{}).prop2||{}).prop3||{})[1]||{}).prop4;

प्रत्येक संपत्ति का उपयोग करने के बाद (... '|| {}')। अगलाप्रॉप ताकि एक लापता संपत्ति कोई त्रुटि नहीं फेंक दे।

या आप अस्तित्व में उपयोग कर सकते हैं जैसे existy(o) && existy(op) && existy(opq) && doSomething(opq)


मैं वस्तु के आधार पर दो अलग-अलग तरीकों का उपयोग करता हूं।

if( !variable ){
  // variable is either
  // 1. '';
  // 2. 0;
  // 3. undefined;
  // 4. null;
  // 5. false;
}

कभी-कभी मैं खाली स्ट्रिंग को झूठी के रूप में मूल्यांकन नहीं करना चाहता, इसलिए मैं इस मामले का उपयोग करता हूं

function invalid( item ){
  return (item === undefined || item === null);
}

if( invalid( variable )){
  // only here if null or undefined;
}

यदि आपको विपरीत की आवश्यकता है, तो पहले उदाहरण में! वैरिएबल बन जाता है !! चर, और अमान्य फ़ंक्शन === बन गया! = और फ़ंक्शन नामों को अविश्वसनीय रूप में परिवर्तित नहीं किया जाता है।


यदि आप कुछ करने के लिए परिभाषित ब्लॉक चाहते हैं तो इसका उपयोग करें

if (typeof variable !== 'undefined') {
    // the variable is defined
}

यदि आप कुछ करने के लिए अपरिभाषित ब्लॉक चाहते हैं या चर निर्दिष्ट या परिभाषित करना चाहते हैं तो इसका उपयोग करें

if (typeof variable === 'undefined') {
    // the variable is undefined
}

यह जांचने के लिए कि कोई चर घोषित / सेट किया गया है, मैंने यह गंदे चाल की है।

मुझे एक समारोह में कोड निकालने का तरीका नहीं मिला है, यहां तक ​​कि eval साथ भी।

"use strict";

// var someVar;

var declared;
try {
  someVar;
  declared = true;
} catch(e) {
  declared = false;
}

if (declared) {
  console.log("someVar is declared; now has the value: " + someVar);
} else {
  console.log("someVar is not declared");
}

यह निर्भर करता है कि क्या आप केवल यह देखते हैं कि चर परिभाषित किया गया है या यदि आप चाहते हैं कि यह एक सार्थक मूल्य हो।

यह जांचना कि क्या प्रकार अपरिभाषित है, जांच करेगा कि क्या चर अभी तक परिभाषित किया गया है या नहीं।

=== null या !== null केवल तभी जांच करेगा कि चर का मान बिल्कुल null

== null या != null जांच करेगा कि मान undefined या null या नहीं।

if(value) जांच करेगा कि चर undefined , null , 0 , या खाली स्ट्रिंग है या नहीं।


ये उत्तर (फ्रेड गैंड समाधान से अलग) सभी या तो गलत या अपूर्ण हैं।

मान लीजिए मुझे अपने variableName; आवश्यकता variableName; एक undefined मूल्य ले जाने के लिए, और इसलिए इसे var variableName; जैसे तरीके से घोषित किया गया है var variableName; जिसका अर्थ है कि यह पहले ही शुरू हो चुका है ; - मैं कैसे जांचूं कि यह पहले से घोषित है या नहीं?

या इससे भी बेहतर - मैं तुरंत कैसे जांच करूं कि "Book1.chapter22.paragraph37" एक कॉल के साथ मौजूद है, लेकिन संदर्भ त्रुटि नहीं बढ़ती है?

हम इसे सबसे शक्तिशाली JasvaScript ऑपरेटर, ऑपरेटर में उपयोग करके करते हैं .:

"[variable||property]" in [context||root] 
>> true||false

AJAX peaking लोकप्रियता के समय में मैंने एक विधि (बाद में नामित) isNS () लिखा है जो यह निर्धारित करने में सक्षम है कि नामस्थान मौजूद है जैसे "Book1.chapter22.paragraph37" और बहुत कुछ।

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


सबसे मजबूत 'यह परिभाषित किया गया है' चेक टाइपफ के साथ है

if (typeof elem === 'undefined')

यदि आप एक डिफॉल्ट असाइन करने के लिए एक परिभाषित चर की जांच कर रहे हैं, तो एक लाइनर को पढ़ने में आसान के लिए आप अक्सर ऐसा कर सकते हैं:

elem = elem || defaultElem;

यह अक्सर उपयोग करने के लिए ठीक है, देखें: जावास्क्रिप्ट में डिफ़ॉल्ट मान सेट करने के लिए बेवकूफ तरीका

टाइपफ कीवर्ड का उपयोग करके यह एक लाइनर भी है:

elem = (typeof elem === 'undefined') ? defaultElem : elem;

if (typeof console != "undefined") {    
   ...
}

या और अच्छा

if ((typeof console == "object") && (typeof console.profile == "function")) {    
   console.profile(f.constructor);    
}

सभी ब्राउज़रों में काम करता है






undefined