क्या जावास्क्रिप्ट में अशक्त, अपरिभाषित या रिक्त चर की जांच करने के लिए एक मानक कार्य है?

Question

क्या एक सार्वभौमिक जावास्क्रिप्ट फ़ंक्शन है जो यह जांचता है कि एक चर का मूल्य है और यह सुनिश्चित करता है कि यह नहीं है undefinedया नहीं null? मुझे यह कोड मिल गया है, लेकिन मुझे यकीन नहीं है कि यह सभी मामलों को कवर करता है:

function isEmpty(val){
    return (val === undefined || val == null || val.length <= 0) ? true : false;
}

Comments

के संभावित डुप्लिकेट आप जावास्क्रिप्ट में कोई रिक्त स्ट्रिंग के लिए जांच कैसे करूं?

— डोर हाई आर्क

प्रोटिप, कभी नहीं (truthy statement) ? true : false;। बस करो (truthy statement);।

— डेविड बैकुम

@GeorgeJempty एक डुबकी नहीं है, क्योंकि दूसरा जवाब विशेष रूप से तार के बारे में पूछता है , जबकि यह एक चर के बारे में पूछता है ।

— मैडब्रेक्स

इस प्रश्न का कोई भी सही उत्तर पूरी तरह से इस बात पर निर्भर करता है कि आप "रिक्त" कैसे परिभाषित करते हैं।

— मैडब्रेक्स

@ जय यह आपके कोड के निष्पादन के रूप में दूर कुछ भी चोट नहीं करता है। यह केवल अत्यधिक क्रिया है। आप यह नहीं कहेंगे, "क्या आप भूखे हैं क्या यह सच है?" आप सिर्फ "क्या आप भूखे हैं" इसलिए कोड में केवल if (hungry) …इसके बजाय कहें if (hungry === true) …। इस तरह से सभी कोडिंग चीजों की तरह, यह सिर्फ स्वाद की बात है। ओपी द्वारा प्रदान किए गए उदाहरण के लिए अधिक विशिष्ट वह और भी अधिक मौखिक रूप से कह रहा है, "यदि यह सच है, तो सच है, यदि नहीं तो गलत है" लेकिन अगर यह सच है, तो यह पहले से ही सच है। और, यदि यह गलत है, तो यह पहले से ही गलत है। यह कहने के लिए समान है "यदि आप भूखे हैं तो आप हैं, और यदि नहीं तो आप नहीं हैं।"

— डेविड बाउकम

Answer 1

आप बस यह जांच सकते हैं कि चर का truthyमान है या नहीं। इसका मत

if( value ) {
}

मूल्यांकन करेगा trueकि valueक्या नहीं है :

• शून्य
• अपरिभाषित
• NaN
• खाली स्ट्रिंग ("")
• 0
• असत्य

उपरोक्त सूची falsyECMA- / जावास्क्रिप्ट में सभी संभावित मूल्यों का प्रतिनिधित्व करती है । यह में खोजें विनिर्देश पर ToBooleanअनुभाग।

इसके अलावा, यदि आप नहीं जानते कि एक चर मौजूद है (इसका मतलब है, अगर यह घोषित किया गया था ) तो आपको typeofऑपरेटर से जांच करनी चाहिए । उदाहरण के लिए

if( typeof foo !== 'undefined' ) {
    // foo could get resolved and it's defined
}

यदि आप यह सुनिश्चित कर सकते हैं कि एक चर को कम से कम घोषित किया गया है, तो आपको सीधे जांच करनी चाहिए कि क्या इसका truthyऊपर जैसा मूल्य है।

आगे पढ़ें: http://typeofnan.blogspot.com/2011/01/typeof-is-fast.html

Comments

क्या होगा अगर मूल्य एक झूठी बूलियन है जो इरादा था। कभी-कभी आप एक डिफ़ॉल्ट मान देना चाहते हैं यदि कोई मूल्य नहीं है, जो काम नहीं करेगा यदि झूठे बूलियन में पारित किया गया था।

— TruMan1

@ TruMan1: ऐसे मामले में (जहां आपका तर्क सत्यापन तय करता है) आपको जाना होगा if( value || value === false )। समान सभी मिथ्या मूल्यों के लिए जाता है , हमें उन लोगों के लिए स्पष्ट रूप से मान्य करने की आवश्यकता है।

— jAndy

सिवाय अगर मान एक सरणी है। की व्याख्या truthyभ्रामक हो सकती है। उस मामले में हमें value.length != 0एक गैर-खाली सरणी के लिए जाँच करनी चाहिए ।

— उपयोगकर्ता

बस यह जोड़ना चाहते हैं कि यदि आपको लगता है कि ifनिर्माण कृत्रिम रूप से बहुत भारी है, तो आप टर्नरी ऑपरेटर का उपयोग कर सकते हैं, जैसे var result = undefined ? "truthy" : "falsy":। या यदि आपने अभी एक बूलियन मान के लिए मजबूर करने के लिए चाहते हैं, का उपयोग !!ऑपरेटर, जैसे !!1 // true, !!null // false।

— KFL

यह भी ध्यान दें कि यह उन तारों की जांच नहीं करेगा जिनमें केवल व्हाट्सएप अक्षर हैं।

— क्रिस्टोफ रूसो

Answer 2

यह मानने के लिए क्रिया विधि है कि मान अपरिभाषित है या अशक्त है:

return value === undefined || value === null;

आप ==ऑपरेटर का उपयोग भी कर सकते हैं लेकिन यह सभी नियमों को जानने की उम्मीद करता है :

return value == null; // also returns true if value is undefined

Comments

केवल के लिए जाँच nullया undefinedऐसा किया जा सकता है if (value == null):। उस ==ऑपरेटर का ध्यान रखें जो सहवास करता है। यदि आप इस तरह की जाँच करते हैं if (value === null || value === undefined), तो आप भूल गए / पता नहीं कैसे जावास्क्रिप्ट coerces है। webreflection.blogspot.nl/2010/10/…

— क्रिस्टियान

@ChristiaanWesterbeek: अपनी बात है कि के arg == nullरूप में एक ही परिणाम पैदा करता है arg === undefined || arg === null। हालांकि, मैं बाद के उदाहरण को अधिक पठनीय मानता हूं।

— सलमान ए

arg == nullमेरे अनुभव में बहुत आम है।

— ब्रायन डाउनिंग

return value === (void 0)परीक्षण की तुलना में अधिक सुरक्षित है, undefinedजो कि दु: खद रूप से दायरे में एक वैध चर हो सकता है।

— x0n

@ शर्की एक ऐसे चर के बीच अंतर है जो अपरिभाषित है और एक अघोषित चर है: lucybain.com/blog/2014/null-undefined-undeclared

— क्रिश्चियन

Answer 3

function isEmpty(value){
  return (value == null || value.length === 0);
}

इसके लिए सही लौटेगा

undefined  // Because undefined == null

null

[]

""

और एक फ़ंक्शन के lengthघोषित होने के बाद से शून्य तर्क कार्य करता है।

बाद की श्रेणी को समाप्त करने के लिए, आप केवल रिक्त तारों की जांच कर सकते हैं

function isEmpty(value){
  return (value == null || value === '');
}

Comments

undefined == nullलेकिनundefined !== null

— इयान बोयड

@IanBoyd ऐसा इसलिए है क्योंकि आप == से === की तुलना कर रहे हैं। इसका मतलब यह है कि अपरिभाषित == अशक्त (सत्य) अपरिभाषित! = अशक्त (असत्य) अपरिभाषित === अशक्त (असत्य) अपरिभाषित! == अशक्त (सत्य) मददगार बनने और लोगों को आगे बढ़ाने के लिए थोड़ी और जानकारी देना बेहतर होगा। सही दिशा में। moz doc on the अंतर डेवलपर।

— कोरी यंग

Answer 4

यह सबसे सुरक्षित जाँच है और मैंने इसे यहाँ बिल्कुल वैसा ही नहीं देखा है:

if (typeof value !== 'undefined' && value) {
    //deal with value'
};

यह उन मामलों को कवर करेगा जहां मूल्य को कभी भी परिभाषित नहीं किया गया था, और इनमें से कोई भी:

• शून्य
• अपरिभाषित (अपरिभाषित का मान उस पैरामीटर के समान नहीं है जिसे कभी परिभाषित नहीं किया गया था)
• 0
• "" (खाली स्ट्रिंग)
• असत्य
• NaN

_{संपादित: सख्त समानता ((==) में बदल गया क्योंकि यह अब तक का आदर्श है;)}

Comments

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

— जे। सेव

आपकी टिप्पणी के लिए Thanx स्टीव। वह सामान्य नियम ही ठीक है। मैं बस ppl के लिए यह समझने की उम्मीद करता हूं कि वे एक या दूसरे का उपयोग क्यों करते हैं। हर तरह से आप ppl दिखते हैं, आपको "हमेशा हमेशा सख्त उपयोग करें" के बारे में प्रचार करने में खुशी होगी - जैसे यह जावास्क्रिप्ट में सबसे महत्वपूर्ण बात है। मैंने बहुत सारे मामलों को देखा है जैसे अगर (वैल! = Null) जो जाहिर तौर पर अवांछित परिणाम की ओर ले जाता है। यह कहना ठीक है कि जब संदेह में हो - सख्त का उपयोग करें, लेकिन संदेह में नहीं होना बेहतर है।

— गुया

मुझे लगता है कि यहाँ बिंदु यह है कि हम उम्मीद करते हैं कि typeofऑपरेटर एक स्ट्रिंग लौटाएगा ताकि सख्त समानता की जांच का उपयोग तकनीकी रूप से अधिक सटीक, अधिक विशिष्ट और तेज हो। तो वास्तव में, ढीली तुलना का उपयोग करने का कोई कारण नहीं है, न कि दूसरे तरीके से। इसके अलावा val !== nullकई मामलों में पूरी तरह से वैध है - मैं यह सब समय है। मैं आपके गैर-अनुरूपता तर्क से सहमत हूं, लेकिन मुझे लगता है कि इसे बनाने के लिए यह एक खराब उदाहरण है। आपको ट्रोल करने की कोशिश नहीं की जा रही है।

— ब्रायन डाउनिंग

आपकी टिप्पणी ब्रायन के लिए धन्यवाद, आप वैल का उपयोग करते हैं! == अशक्त क्योंकि आपको पता है कि आप क्या कर रहे हैं। एक शुरुआत करने के लिए जब घाटी झूठा है एक वापसी करना चाहते हैं जाएगा। लेकिन, वैल कभी अशक्त नहीं होगा यह अपरिभाषित होगा। यदि केवल उन्होंने "हमेशा हमेशा सख्त उपयोग करने" की सलाह को नहीं सुना, तो उनके पास कम कीड़े होंगे। मैंने देखा है कि यह उत्पादन कोड में होता है। टाइपोफ़ हमेशा एक स्ट्रिंग लौटाता है और गति भिन्नता बेमानी होगी। तो, उपरोक्त मामले में सख्त उपयोग करने का एकमात्र तर्क संगति है। मैंने कहा है "सख्त समानता की कोई आवश्यकता नहीं है"। इसका मतलब यह नहीं है कि आप अपने कोड को अधिक सुसंगत बनाना चाहते हैं या नहीं कर सकते हैं।

— गुय्या

Answer 5

आपको निम्न फ़ंक्शन उपयोगी मिल सकता है:

function typeOf(obj) {
  return {}.toString.call(obj).split(' ')[1].slice(0, -1).toLowerCase();
}

या ईएस 7 (टिप्पणी में और सुधार करें)

function typeOf(obj) {
  const { toString } = Object.prototype;
  const stringified = obj::toString();
  const type = stringified.split(' ')[1].slice(0, -1);

  return type.toLowerCase();
}

परिणाम:

typeOf(); //undefined
typeOf(null); //null
typeOf(NaN); //number
typeOf(5); //number
typeOf({}); //object
typeOf([]); //array
typeOf(''); //string
typeOf(function () {}); //function
typeOf(/a/) //regexp
typeOf(new Date()) //date
typeOf(new WeakMap()) //weakmap
typeOf(new Map()) //map

"ध्यान दें कि बाइंड ऑपरेटर (: :) ES2016 (ES7) का हिस्सा नहीं है और न ही बाद में ECMAScript मानक का कोई भी बाद का संस्करण है। यह वर्तमान में भाषा के लिए पेश किए जाने के लिए एक चरण 0 (स्ट्रोमैन) का प्रस्ताव है।" - साइमन केजेलबर्ग लेखक शाही तपस्या प्राप्त करने के लिए इस खूबसूरत प्रस्ताव के लिए अपना समर्थन जोड़ना चाहता है।

Comments

+1 यह 'regexp' , 'array' और 'function' प्रकार की वस्तु को जानने में सहायक है

— यश

@ विक्स, ES7 संस्करण क्यों बेहतर है?

— गुल्लीझार

यह समान कार्यक्षमता का उपयोग करने के अधिक पठनीय तरीकों के साथ प्रयोग नहीं कर रहा है: विनाशकारी असाइनमेंट, बाइंड ऑपरेटर।

— विक्स

ध्यान दें कि बाइंड ऑपरेटर ( ::) ES2016 (ES7) का हिस्सा नहीं है और न ही बाद में ECMAScript मानक का कोई भी संस्करण। यह वर्तमान में भाषा के लिए पेश किए जाने के लिए एक चरण 0 (स्ट्रोमैन) का प्रस्ताव है।

— साइमन केजेलबर्ग

Answer 6

सबसे अच्छी रेटिंग वाला पहला उत्तर गलत है। यदि मान अपरिभाषित है, तो यह आधुनिक ब्राउज़रों में अपवाद फेंक देगा। आपको उपयोग करना होगा:

if (typeof(value) !== "undefined" && value)

या

if (typeof value  !== "undefined" && value)

Comments

eee ... मुझे लगता है कि यह गलत है जैसे कि (मान) पर्याप्त है (खाली वस्तुओं / सरणियों को छोड़कर)। यदि मान 'अपरिभाषित' है तो '' यदि विश्वास नहीं पास होगा।

— Oskar Szura

यह उन चरों को भ्रमित करता है जिन्हें परिभाषित नहीं किया गया है (जो मूल्यांकन पर एक सन्दर्भ को फेंकते हैं), जो undefinedमान के साथ चर के लिए अलग हैं ।

— कांतास 94 हेवी

मुझे यहाँ वही त्रुटि मिली। if (x), if (! x), if (!! x) सभी त्रुटि को फेंक देगा यदि x अपरिभाषित है।

— शाश

if(value === 0) gameOver(); ;)

— मैडब्रेक्स

इस उत्तर क्योंकि यह झूठी लौटाता है जब भी गलत है valueशून्य है, जो है नहीं क्या सेशन के लिए लग रही है।

— मैडब्रेक्स

Answer 7

यह स्थिति जाँच

if (!!foo) {
    //foo is defined
}

आपको जो चाहिए वह यह है।

Comments

मुझे लगता है कि यह सिर्फ एक स्निपेट है। लेकिन ifपहले से ही एक झूठी जांच करता है, जो यह सिर्फ एक बूलियन में परिवर्तित करता है। क्या यह किसी भी मामले को पकड़ता है जो एक सामान्य if(foo)नहीं पकड़ पाता है?

— दान वैन हुलस्ट

यह सही है जब आपको कुछ इनलाइन की आवश्यकता होती है, उदाहरण के लिए मुझे एक प्रतिक्रिया विशेषता की आवश्यकता होती है (जिसे सक्रिय कहा जाता है) यह सच है जब एक स्ट्रिंग खाली नहीं होती है - अगर एक बयान ओवरक्लिल होगा तो मैं बस उपयोग कर सकता हूंactive={!!foo}

— बेन कोला मैन्सले

Answer 8

! के लिए जाँच रिक्त स्ट्रिंग ( ""), अशक्त,, अपरिभाषित झूठे और संख्या 0 और NaN। कहते हैं, अगर एक स्ट्रिंग खाली है var name = ""तो console.log(!name)वापस लौटता है true।

function isEmpty(val){
  return !val;
}

इस समारोह सच वापस आ जाएगी अगर वैल है खाली, शून्य, अपरिभाषित, झूठे, संख्या 0 या NaN ।

या

अपने समस्या डोमेन के अनुसार आप बस की तरह !valया का उपयोग कर सकते हैं !!val।

Comments

यह वास्तव में यह नहीं कहता है कि चर खाली है, क्योंकि गलत और 0 मान्य मान हो सकते हैं और खाली मान नहीं बन सकते हैं। एक आइसोमेट्टी फंक्शन होने का मूल्य यह सुनिश्चित करना होगा कि आप उन मूल्यों की उम्मीद करते हैं जो खाली रिटर्न सही हैं। मेरी राय में अशक्त, अपरिभाषित, NaN, और एक रिक्त स्ट्रिंग वे मान हैं जो खाली समझ में आते हैं।

— कोरी यंग

isEmpty(val)यदि आप बस कर सकते हैं तो उपयोग क्यों करें !val?

— एलन लिनाटोक

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

— आरिफ

Answer 9

एक समाधान मुझे बहुत पसंद है:

चलो परिभाषित करते हैं कि एक रिक्त चर है null, या undefined, या यदि इसकी लंबाई है, तो यह शून्य है, या यदि यह एक वस्तु है, तो इसकी कोई कुंजी नहीं है:

function isEmpty (value) {
  return (
    // null or undefined
    (value == null) ||

    // has length and it's zero
    (value.hasOwnProperty('length') && value.length === 0) ||

    // is an Object and has no keys
    (value.constructor === Object && Object.keys(value).length === 0)
  )
}

यह दिखाता है:

• सच: undefined , null, "", [],{}
• झूठी: true , false, 1, 0, -1, "foo", [1, 2, 3],{ foo: 1 }

Answer 10

आप इसे थोड़ा अति कर रहे हैं। यह जाँचने के लिए कि क्या किसी चर को मान नहीं दिया गया है, आपको केवल अपरिभाषित और अशक्त होने की जाँच करनी होगी।

function isEmpty(value){
    return (typeof value === "undefined" || value === null);
}

यह मान लिया गया है 0, ""और ऑब्जेक्ट (यहां तक ​​कि खाली वस्तु और सरणी) मान्य "मान" हैं।

Answer 11

यदि आप सादे जावास्क्रिप्ट को पसंद करते हैं तो यह कोशिश करें:

  /**
   * Checks if `value` is empty. Arrays, strings, or `arguments` objects with a
   * length of `0` and objects with no own enumerable properties are considered
   * "empty".
   *
   * @static
   * @memberOf _
   * @category Objects
   * @param {Array|Object|string} value The value to inspect.
   * @returns {boolean} Returns `true` if the `value` is empty, else `false`.
   * @example
   *
   * _.isEmpty([1, 2, 3]);
   * // => false
   *
   * _.isEmpty([]);
   * // => true
   *
   * _.isEmpty({});
   * // => true
   *
   * _.isEmpty('');
   * // => true
   */

function isEmpty(value) {
    if (!value) {
      return true;
    }
    if (isArray(value) || isString(value)) {
      return !value.length;
    }
    for (var key in value) {
      if (hasOwnProperty.call(value, key)) {
        return false;
      }
    }
    return true;
  }

अन्यथा, यदि आप पहले से ही अंडरस्कोर या लॉश का उपयोग कर रहे हैं, तो प्रयास करें:

_.isEmpty(value)

Comments

अपने कोड की कोशिश की है। मुझे कंसोल में एक त्रुटि संदेश मिलता है जो कहता है: "बिना संदर्भ त्रुटि: आइर्रे () परिभाषित नहीं है"। अन्यथा, यह बहुत अच्छा होगा अगर यह काम करे।

— crmprogdev

कम से कम दर्ज करने के मामले में, _.isNilवह फ़ंक्शन है जिसे आप खोज रहे हैं, नहीं _.isEmpty। isNil प्रलेखन , isEmpty प्रलेखन

— Snixtor

यह विफल होगा अगर मूल्य बूलियन है और मूल्य सच है।

— कल्याणबाक

सादे जावास्क्रिप्ट में isArrayया isStringकार्य नहीं है window।

— GFoley83

@ GFoley83 - आपने मुझे पकड़ लिया! मेरे पास विंडोज का उपयोग न करने के मेरे कारण हैं। मैं वास्तव में अध्याय में विषय को कवर करता हूं जो सॉफ्टवेयर भाषाओं के इतिहास और प्रगति के बारे में बात करता है। अधिक प्रासंगिक जानकारी संभवतः मेरी पुस्तक में सीखे गए मोनोडिक एरर हैंडलिंग पर चर्चा / कोड का प्रदर्शन करेगी, जानें कार्यात्मक प्रोग्रामिंग गो में। चीयर्स!

— l3x

Answer 12

यहाँ मेरा है - यदि मूल्य शून्य है, अपरिभाषित है, आदि या रिक्त है (यानी केवल रिक्त स्थान हैं) यह सच है:

function stringIsEmpty(value) {

    return value ? value.trim().length == 0 : true;

}

Comments

मैंने यहां कई तरीकों पर एक परीक्षण किया। अपरिभाषित के लिए एक चेक के साथ, आपका फ़ंक्शन शानदार काम करता है। तो मैं अगर (टाइपो वैल्यू! == 'अपरिभाषित' &&! IsEmpty (मान)) का उपयोग करता हूं या, यदि आप वास्तव में खाली की जांच करना चाहते हैं, तो आप उपयोग कर सकते हैं यदि (टाइपो वैल्यू === 'अपरिभाषित') ||Empty2 (मान) || )। यह अशक्त के लिए काम करेगा; अपरिभाषित; 0; ""; ""; झूठी

— रेशनलब्रेट

Answer 13

return val || 'Handle empty variable'

एक बहुत अच्छा और साफ तरीका है जो इसे बहुत सारे स्थानों पर संभालता है, इसका उपयोग चर को असाइन करने के लिए भी किया जा सकता है

const res = val || 'default value'

Comments

स्थानों का एक बहुत नहीं बल्कि जब डिफ़ॉल्ट है trueऔर आप की आपूर्ति या एक वापस करने के लिए कोशिश कर रहे हैं valके false।

— मोलमोबी

@ मॉल्मोबी एक बहुत ही विशिष्ट बढ़त का मामला है, लेकिन यहां तक ​​कि आसानी से नियंत्रित किया जाता हैconst res = falsyValue ? true : falsyValue

— cubefox

Answer 14

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

if (foo) {}
function (bar) {}(foo)

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

यदि आप परीक्षण करना चाहते हैं कि क्या एक चर घोषित किया गया है तो आप उपयोग कर सकते हैं

typeof foo != "undefined"

यदि आप परीक्षण करना चाहते हैं कि क्या फू घोषित किया गया है और इसका एक मूल्य है जिसका आप उपयोग कर सकते हैं

if (typeof foo != "undefined" && foo) {
    //code here
}

Answer 15

डिफ़ॉल्ट मान की जाँच करने के लिए

function typeOfVar (obj) {
      return {}.toString.call(obj).split(' ')[1].slice(0, -1).toLowerCase();
}
function isVariableHaveDefaltVal(variable) {
    if ( typeof(variable) === 'string' ) {  // number, boolean, string, object 
        console.log(' Any data Between single/double Quotes is treated as String ');        
        return (variable.trim().length === 0) ? true : false;
    }else if ( typeof(variable) === 'boolean' ) {
      console.log('boolean value with default value \'false\'');
        return (variable === false) ? true : false;
    }else if ( typeof(variable) === 'undefined' ) {
        console.log('EX: var a; variable is created, but has the default value of undefined.'); 
        return true;
    }else if ( typeof(variable) === 'number' ) { 
        console.log('number : '+variable);
        return (variable === 0 ) ? true : false;
    }else if ( typeof(variable) === 'object' ) {
   //   -----Object-----
        if (typeOfVar(variable) === 'array' && variable.length === 0) {
            console.log('\t Object Array with length = ' + [].length); // Object.keys(variable)
            return true;
        }else if (typeOfVar(variable) === 'string' && variable.length === 0 ) {
            console.log('\t Object String with length = ' + variable.length);
            return true;
        }else if (typeOfVar(variable) === 'boolean' ) {
            console.log('\t Object Boolean = ' + variable);
            return (variable === false) ? true : false;
        }else if (typeOfVar(variable) === 'number' ) {
            console.log('\t Object Number = ' + variable);
            return (variable === 0 ) ? true : false;
        }else if (typeOfVar(variable) === 'regexp' && variable.source.trim().length === 0 ) {
       console.log('\t Object Regular Expression : ');
        return true;
        }else if (variable === null) {
       console.log('\t Object null value');
        return true;
        }
    }
    return false;
}
var str = "A Basket For Every Occasion";
str = str.replace(/\s/g, "-");
//The "g" flag in the regex will cause all spaces to get replaced.

परिणाम देखें:

isVariableHaveDefaltVal(' '); // string          
isVariableHaveDefaltVal(false); // boolean       
var a;           
isVariableHaveDefaltVal(a);               
isVariableHaveDefaltVal(0); // number             
isVariableHaveDefaltVal(parseInt('')); // NAN isNAN(' '); - true         
isVariableHaveDefaltVal(null);              
isVariableHaveDefaltVal([]);               
isVariableHaveDefaltVal(/ /);              
isVariableHaveDefaltVal(new Object(''));               
isVariableHaveDefaltVal(new Object(false));            
isVariableHaveDefaltVal(new Object(0)); 
typeOfVar( function() {} );

मैंने किस प्रकार की वस्तु की जांच के लिए @Vix फंक्शन () का उपयोग किया।

instansof का उपयोग कर «

var prototypes_or_Literals = function (obj) {
    switch (typeof(obj)) {
        // object prototypes
        case 'object':
            if (obj instanceof Array)
                return '[object Array]';
            else if (obj instanceof Date)
                return '[object Date]';
            else if (obj instanceof RegExp)
                return '[object regexp]';
            else if (obj instanceof String)
                return '[object String]';
            else if (obj instanceof Number)
                return '[object Number]';

            else
                return 'object';
        // object literals
        default:
            return typeof(obj);
    }   
};
output test «
prototypes_or_Literals( '' ) // "string"
prototypes_or_Literals( new String('') ) // "[object String]"
Object.prototype.toString.call("foo bar") //"[object String]"        

Comments

तुलना संचालक जाँच == [डाटा]। === [डेटा, ऑब्जेक्ट का प्रकार] जेएस नंबर हमेशा अंतरराष्ट्रीय IEEE 754 मानक का पालन करते हुए, डबल सटीक फ़्लोटिंग पॉइंट नंबर के रूप में संग्रहीत किया जाता है। // Number Type [int, float literals ] var int = 77; var float = 77.7; console.log( int.toFixed(10) + '\t' + float.toFixed(10) ); // Object Type var number = new Number( 77 ); if( int != float ) console.log('Data Not Equal'); if( int == number && int !== number ) console.log('Data is Equal & Types vary');

— यश

Answer 16

function isEmpty(obj) {
    if (typeof obj == 'number') return false;
    else if (typeof obj == 'string') return obj.length == 0;
    else if (Array.isArray(obj)) return obj.length == 0;
    else if (typeof obj == 'object') return obj == null || Object.keys(obj).length == 0;
    else if (typeof obj == 'boolean') return false;
    else return !obj;
}

व्हॉट्सएप स्ट्रिंग्स को संभालने के लिए ट्रिम के साथ ES6 में:

const isEmpty = value => {
    if (typeof value === 'number') return false
    else if (typeof value === 'string') return value.trim().length === 0
    else if (Array.isArray(value)) return value.length === 0
    else if (typeof value === 'object') return value == null || Object.keys(value).length === 0
    else if (typeof value === 'boolean') return false
    else return !value
}

Comments

महान समारोह, धन्यवाद! हर प्रकार के मूल्य को संभालता है - अन्य सभी समाधानों में संख्याओं को छोड़ दिया जाता है!

— फेबियन वॉन एलर्ट्स

@FabianvonEllerts कृपया किसी और के उत्तर में अतिरिक्त कोड को संपादित करने का प्रयास न करें। इसे अपने उत्तर के रूप में पोस्ट करें, उत्तर के तहत एक टिप्पणी के रूप में, या एक टिप्पणी में अनुरोध करें कि वे स्वयं उत्तर को अपडेट करें।

— टायलरएच

Answer 17

यह उपयोगी हो सकता है।

सरणी में सभी मान दर्शाते हैं कि आप क्या चाहते हैं (अशक्त, अपरिभाषित या अन्य चीजें) और आप खोज करते हैं कि आप इसमें क्या चाहते हैं।

var variablesWhatILookFor = [null, undefined, ''];
variablesWhatILookFor.indexOf(document.DocumentNumberLabel) > -1

Comments

क्या आप कृपया समझा सकते हैं। वहाँ क्या चल रहा है

— जोशकिब

सरणी में कुछ चर होते हैं जिन्हें आपने खाली माना है।

— ddagsan

@JoshKisb सरणी में सभी मान दर्शाते हैं कि आप क्या होना चाहते हैं (अशक्त, अपरिभाषित या अन्य चीजें) और आप खोजते हैं कि आप इसमें क्या चाहते हैं।

— ddagsan

@ddagsan जबकि जोशकिस्ब आपके उत्तर की सराहना कर सकते हैं, आपको अपना स्पष्टीकरण टिप्पणियों के बजाय अपने उत्तर में देना चाहिए

— निक

Answer 18

आप उपयोग कर रहे हैं TypeScriptऔर करते हैं के लिए खाते में नहीं करना चाहता "मूल्यों होते हैं false" तो यह आपके लिए समाधान है:

प्रथम: import { isNullOrUndefined } from 'util';

फिर: isNullOrUndefined(this.yourVariableName)

कृपया ध्यान दें: जैसा कि नीचे उल्लेख किया गया है कि अब पदावनत किया गया है, value === undefined || value === nullइसके बजाय उपयोग करें । रेफरी ।

Comments

मैंने सोचा था कि यह अच्छा था, इसलिए मैंने शुरू में अनवीट किया था, लेकिन यह एक नोड है। जेएस की बात यह है कि इसे हटा दिया गया है। टाइप परिभाषा फ़ाइल कहती है:/** @deprecated since v4.0.0 - use "value === null || value === undefined" instead. */

— atomictom

@atomictom मैंने सोचा कि यह एक typescriptबात है। क्या आप इसके प्रलेखन का लिंक प्रदान कर सकते हैं?

— ब्लैकबर्ड

यहाँ: nodejs.org/api/util.html#util_util_isnullorundefined_object । इसके अलावा: "मुझे लगा कि यह अच्छा था इसलिए मैंने शुरू में उत्थान किया " जो पढ़ना चाहिए :)

— atomictom

इस तरह से एक उपयोगी सरल चीज़ को क्यों चित्रित किया जाएगा? geeeeees।

— टिकटॉक

Answer 19

Vacuousness

मैं किसी ऐसे फ़ंक्शन को परिभाषित करने या उसका उपयोग करने की कोशिश करने की अनुशंसा नहीं करता हूं जो गणना करता है कि क्या पूरी दुनिया में कोई भी मूल्य खाली है। "खाली" होने का वास्तव में क्या मतलब है? अगर मेरे पास है let human = { name: 'bob', stomach: 'empty' }, तो मुझे isEmpty(human)लौट जाना चाहिए true? अगर मेरे पास है let reg = new RegExp('');, तो मुझे isEmpty(reg)लौट जाना चाहिए true? किस बारे में isEmpty([ null, null, null, null ])- इस सूची में केवल शून्यता है, तो क्या सूची ही खाली है? मैं जावास्क्रिप्ट में कुछ नोट्स "रिक्वेस्टनेस" (जानबूझकर अस्पष्ट शब्द, पूर्व-मौजूदा संघों से बचने के लिए) पर आगे रखना चाहता हूं - और मैं यह तर्क देना चाहता हूं कि जावास्क्रिप्ट वैल्यूज में "रिक्तिपन" को कभी भी उदारता से नहीं निपटाया जाना चाहिए।

---

Truthiness / Falsiness

मूल्यों की "रिक्ति" का निर्धारण कैसे किया जाए, यह तय करने के लिए, हमें जावास्क्रिप्ट को इनबिल्ट करने की आवश्यकता है, निहित अर्थ "सत्य" या "मिथ्या" हैं। स्वाभाविक रूप से, nullऔर undefinedदोनों "झूठे" हैं। कम स्वाभाविक रूप से, संख्या 0(और कोई अन्य संख्या को छोड़कर NaN) भी "मिथ्या" है। कम से कम स्वाभाविक रूप से: ''falsy है, लेकिन []और {}(और new Set(), और new Map()) truthy कर रहे हैं - हालांकि वे सभी समान रूप से हलका लगते हैं!

---

अशक्त बनाम अप्रभावित

वहाँ भी कुछ के विषय में चर्चा है nullबनाम undefinedहम वास्तव में हमारे कार्यक्रमों में vacuousness व्यक्त करने के लिए दोनों की क्या ज़रूरत है? - मैं व्यक्तिगत रूप से कभी भी अक्षरों को यू, एन, डी, ई, एफ, आई, एन, ई, डी होने से बचाता हूं। मैं हमेशा null"रिक्ति" का संकेत देने के लिए उपयोग करता हूं । फिर, हालांकि, हमें जावास्क्रिप्ट की अंतर्निहित समझदारी के साथ कैसे nullऔर undefinedअलग होने की आवश्यकता है:

• गैर-मौजूद संपत्ति तक पहुँचने की कोशिश करता है undefined
• किसी पैरामीटर को कॉल करते समय एक पैरामीटर को प्राप्त करने से उस पैरामीटर का परिणाम प्राप्त होता है undefined:

let f = a => a;
console.log(f('hi'));
console.log(f());

• डिफ़ॉल्ट मान वाले पैरामीटर केवल दिए जाने पर डिफ़ॉल्ट प्राप्त करते हैं undefined, नहीं null:

let f = (v='hello') => v;
console.log(f(null));
console.log(f(undefined));

---

गैर-सामान्य रिक्ति

मेरा मानना ​​है कि सामान्य फैशन में कभी भी खालीपन से नहीं निपटना चाहिए। इसके बजाय हमें हमेशा यह निर्धारित करने से पहले अपने डेटा के बारे में अधिक जानकारी प्राप्त करने की कठोरता होनी चाहिए - मैं मुख्य रूप से यह जाँच कर रहा हूं कि मैं किस प्रकार के डेटा के साथ काम कर रहा हूं:

let isType = (value, Cls) => {
  try {
    return Object.getPrototypeOf(value).constructor === Cls;
  } catch(err) {
    return false;
  }
};

ध्यान दें कि यह फ़ंक्शन बहुरूपता को अनदेखा करता है - यह valueएक प्रत्यक्ष उदाहरण होने की उम्मीद करता है Cls, न कि एक उपवर्ग का उदाहरण Cls। मैं instanceofदो मुख्य कारणों से बचता हूं :

• ([] instanceof Object) === true ("एक सरणी एक वस्तु है")
• ('' instanceof String) === false ("एक स्ट्रिंग एक स्ट्रिंग नहीं है")

ध्यान दें कि इस Object.getPrototypeOfतरह के एक मामले से बचने के लिए प्रयोग किया जाता है जैसे फ़ंक्शन अभी भी (झूठे), और (सही) के लिए सही ढंग से वापस आता है ।let v = { constructor: String };isTypeisType(v, String)isType(v, Object)

कुल मिलाकर, मैं isTypeइन युक्तियों के साथ इस फ़ंक्शन का उपयोग करने की सलाह देता हूं :

• अज्ञात प्रकार के कोड प्रसंस्करण मूल्यों की मात्रा कम करें। उदाहरण के लिए let v = JSON.parse(someRawValue);, हमारा vचर अब अज्ञात प्रकार का है। जितनी जल्दी हो सके, हमें अपनी संभावनाओं को सीमित करना चाहिए। ऐसा करने का सबसे अच्छा तरीका एक विशेष प्रकार की आवश्यकता के द्वारा हो सकता है: जैसे if (!isType(v, Array)) throw new Error('Expected Array');- यह वास्तव में एक त्वरित और अभिव्यंजक तरीका है जिससे की सामान्य प्रकृति को हटाया जा सके vऔर यह सुनिश्चित हो कि यह हमेशा ए Array। कभी-कभी, हालांकि, हमें vकई प्रकार के होने की अनुमति देने की आवश्यकता होती है । उन मामलों में, हमें कोड के ब्लॉक बनाने चाहिए जहां vअब सामान्य नहीं है, जितनी जल्दी हो सके:

if (isType(v, String)) {
  /* v isn't generic in this block - It's a String! */
} else if (isType(v, Number)) {
  /* v isn't generic in this block - It's a Number! */
} else if (isType(v, Array)) {
  /* v isn't generic in this block - it's an Array! */
} else {
  throw new Error('Expected String, Number, or Array');
}

• सत्यापन के लिए हमेशा "श्वेतसूची" का उपयोग करें। यदि आपको एक मान की आवश्यकता है, जैसे, एक स्ट्रिंग, संख्या, या ऐरे, उन 3 "सफेद" संभावनाओं की जांच करें, और 3 में से कोई भी संतुष्ट नहीं होने पर एक त्रुटि फेंकें। हम "काला" संभावनाओं के लिए कि जाँच को देखने के लिए सक्षम होना चाहिए बहुत उपयोगी नहीं है: कहते हैं कि हम लिखने if (v === null) throw new Error('Null value rejected');- यह सुनिश्चित करना है कि के लिए अच्छा है nullमूल्यों के माध्यम से यह कर नहीं है, लेकिन एक मूल्य अगर करता है इसके माध्यम से बनाने के लिए, हम अभी भी शायद ही जानते हैं इसके बारे में कुछ भी। एक मान vजो इस अशक्त-जांच से गुजरता है वह अभी भी बहुत सामान्य है - यह कुछ भी है लेकिनnull ! ब्लैकलिस्ट शायद ही जेनेरिक-नेस को दूर करते हैं।

• जब तक एक मूल्य nullनहीं है , कभी भी "एक रिक्त मान" पर विचार न करें। इसके बजाय, "एक एक्स जो खाली है" पर विचार करें। अनिवार्य रूप से, कभी भी ऐसा करने पर विचार if (isEmpty(val)) { /* ... */ }न करें - चाहे वह isEmptyफ़ंक्शन कैसे लागू किया गया हो (मैं जानना नहीं चाहता ...), यह सार्थक नहीं है! और यह बहुत सामान्य है! रिक्तता की गणना केवल ज्ञान के valप्रकार के साथ की जानी चाहिए । इस तरह दिखना चाहिए:

  • "एक तार, जिसमें कोई वर्ण नहीं है": if (isType(val, String) && val.length === 0) ...
  • "एक वस्तु, 0 सहारा के साथ": if (isType(val, Object) && Object.entries(val).length === 0) ...
  • "एक संख्या, समान या शून्य से कम": if (isType(val, Number) && val <= 0) ...

  • "ए अर्रे, विथ नो आइटम": if (isType(val, Array) && val.length === 0) ...

  • एकमात्र अपवाद तब nullहोता है जब कुछ कार्यक्षमता को इंगित करने के लिए उपयोग किया जाता है। इस मामले में यह कहना सार्थक है: "एक रिक्त मान":if (val === null) ...

Comments

मैं देख सकता हूँ कि आपने कुछ सोचा है:>

— रुई मार्केज़

Answer 20

विभिन्न तर्क के साथ प्रयास करें । आप सत्यापन के लिए सभी चार (4) शर्त के लिए bellow कोड का उपयोग कर सकते हैं, जैसे शून्य नहीं, रिक्त नहीं, अपरिभाषित नहीं और शून्य नहीं केवल जावास्क्रिप्ट और jquery में इस कोड ((- (चर))) का उपयोग करें।

function myFunction() {
    var data;  //The Values can be like as null, blank, undefined, zero you can test

    if(!(!(data)))
    {
        alert("data "+data);
    } 
    else 
    {
        alert("data is "+data);
    }
}

Answer 21

नए ECMAScript Nullish कोलेसिंग ऑपरेटर पर एक नज़र डालें

इस सुविधा को के बारे में सोच सकते हैं - ??ऑपरेटर - "के रूप में गिरावट वापस" एक डिफ़ॉल्ट मान पर के लिए एक रास्ता के साथ जब काम कर nullया undefined।

let x = foo ?? bar();

फिर, उपरोक्त कोड निम्नलिखित के बराबर है।

let x = (foo !== null && foo !== undefined) ? foo : bar();

Answer 22

function isEmpty(val){
    return !val;
}

लेकिन यह समाधान अति-इंजीनियर है, यदि आप बाद में फंक्शन को मॉडिफाई करने में सफल नहीं होते हैं, तो इसे कोड में सीधे उपयोग करने के लिए क्लीनर है:

if(!val)...

Answer 23

var myNewValue = myObject && myObject.child && myObject.child.myValue;

यह कभी कोई त्रुटि नहीं करेगा। यदि myObject , बच्चा या myValue शून्य है, तो myNewValue शून्य हो जाएगा। कोई त्रुटि नहीं फेंकी जाएगी

Answer 24

इसी तरह के प्रश्न के लिए यहाँ आने वाले हर व्यक्ति के लिए, निम्नलिखित कार्य बहुत अच्छे हैं और पिछले वर्षों में मेरी लाइब्रेरी में यह है:

(function(g3, $, window, document, undefined){
   g3.utils = g3.utils || {};
/********************************Function type()********************************
* Returns a lowercase string representation of an object's constructor.
* @module {g3.utils}
* @function {g3.utils.type}
* @public
* @param {Type} 'obj' is any type native, host or custom.
* @return {String} Returns a lowercase string representing the object's 
* constructor which is different from word 'object' if they are not custom.
* @reference http://perfectionkills.com/instanceof-considered-harmful-or-how-to-write-a-robust-isarray/
* http://stackoverflow.com/questions/3215046/differentiating-between-arrays-and-hashes-in-javascript
* http://javascript.info/tutorial/type-detection
*******************************************************************************/
g3.utils.type = function (obj){
   if(obj === null)
      return 'null';
   else if(typeof obj === 'undefined')
      return 'undefined';
   return Object.prototype.toString.call(obj).match(/^\[object\s(.*)\]$/)[1].toLowerCase();
};
}(window.g3 = window.g3 || {}, jQuery, window, document));

Answer 25

यदि आप सही होना चाहते हैं, तो यदि jAndy के उत्तर के अनुसार, मूल्य निम्न में से कोई है :

• शून्य
• अपरिभाषित
• NaN
• खाली स्ट्रिंग ("")
• 0
• असत्य

एक संभावित समाधान जो सत्य मूल्यों को प्राप्त करने से बच सकता है वह निम्नलिखित है:

function isUsable(valueToCheck) {
    if (valueToCheck === 0     || // Avoid returning false if the value is 0.
        valueToCheck === ''    || // Avoid returning false if the value is an empty string.
        valueToCheck === false || // Avoid returning false if the value is false.
        valueToCheck)             // Returns true if it isn't null, undefined, or NaN.
    {
        return true;
    } else {
        return false;
    }
}

इसका उपयोग इस प्रकार किया जाएगा:

if (isUsable(x)) {
    // It is usable!
}
// Make sure to avoid placing the logical NOT operator before the parameter (isUsable(!x)) and instead, use it before the function, to check the returned value.
if (!isUsable(x)) {
    // It is NOT usable!
}

---

उन परिदृश्यों के अतिरिक्त, यदि वस्तु या सरणी खाली है, तो आप गलत लौटना चाह सकते हैं :

• ऑब्जेक्ट: {} ( ECMA 7+ का उपयोग करके )
• सरणी: [] ( ECMA 5+ का उपयोग करके )

आप इसके बारे में इस तरह से जाएंगे:

function isEmptyObject(valueToCheck) {
    if(typeof valueToCheck === 'object' && !Object.keys(valueToCheck).length){
        // Object is empty!
        return true;
    } else {
        // Object is not empty!
        return false;
    }
}

function isEmptyArray(valueToCheck) {
    if(Array.isArray(valueToCheck) && !valueToCheck.length) {
        // Array is empty!
        return true;
    } else {
        // Array is not empty!
        return false;
    }
}

यदि आप सभी व्हाट्सएप स्ट्रिंग्स ("") की जांच करना चाहते हैं, तो आप निम्नलिखित कार्य कर सकते हैं:

function isAllWhitespace(){
    if (valueToCheck.match(/^ *$/) !== null) {
        // Is all whitespaces!
        return true;
    } else {
        // Is not all whitespaces!
        return false;
    }
}

---

नोट: hasOwnPropertyरिक्त स्ट्रिंग्स, 0, गलत, NaN, अशक्त और अपरिभाषित के लिए सही है, अगर चर उनमें से किसी के रूप में घोषित किया गया था, तो यह उपयोग करने के लिए सबसे अच्छा नहीं हो सकता है। फ़ंक्शन को यह दिखाने के लिए उपयोग करने के लिए संशोधित किया जा सकता है कि यह घोषित किया गया था, लेकिन उपयोग करने योग्य नहीं है।

Answer 26

GitHub पर कोड

const isEmpty = value => (
  (!value && value !== 0 && value !== false)
  || (Array.isArray(value) && value.length === 0)
  || (isObject(value) && Object.keys(value).length === 0)
  || (typeof value.size === 'number' && value.size === 0)

  // `WeekMap.length` is supposed to exist!?
  || (typeof value.length === 'number'
      && typeof value !== 'function' && value.length === 0)
);

// Source: https://levelup.gitconnected.com/javascript-check-if-a-variable-is-an-object-and-nothing-else-not-an-array-a-set-etc-a3987ea08fd7
const isObject = value =>
  Object.prototype.toString.call(value) === '[object Object]';

गरीब आदमी का परीक्षण 😁

const test = () => {
  const run = (label, values, expected) => {
    const length = values.length;
    console.group(`${label} (${length} tests)`);
    values.map((v, i) => {
      console.assert(isEmpty(v) === expected, `${i}: ${v}`);
    });
    console.groupEnd();
  };

  const empty = [
    null, undefined, NaN, '', {}, [],
    new Set(), new Set([]), new Map(), new Map([]),
  ];
  const notEmpty = [
    ' ', 'a', 0, 1, -1, false, true, {a: 1}, [0],
    new Set([0]), new Map([['a', 1]]),
    new WeakMap().set({}, 1),
    new Date(), /a/, new RegExp(), () => {},
  ];
  const shouldBeEmpty = [
    {undefined: undefined}, new Map([[]]),
  ];

  run('EMPTY', empty, true);
  run('NOT EMPTY', notEmpty, false);
  run('SHOULD BE EMPTY', shouldBeEmpty, true);
};

परीक्षण के परिणाम:

EMPTY (10 tests)
NOT EMPTY (16 tests)
SHOULD BE EMPTY (2 tests)
  Assertion failed: 0: [object Object]
  Assertion failed: 1: [object Map]

Comments

महान कार्य, यहां अन्य सभी उत्तरों में कई मुद्दे थे, जिन्हें आप संबोधित करना चाहते हैं, मैं सिर्फ यही चाहता हूं कि मुझे यह मिल जाए इससे पहले कि मैंने अपना लिखा: p सोचा कि आप मेरे काम पर एक नज़र रखना पसंद कर सकते हैं stackoverflow.com/ प्रश्न / ५५१५३१० / ... हमारे दोनों कार्य बिल्कुल समान आउटपुट के प्रतीत होते हैं, लेकिन मैंने कोड को थोड़ा कम कर दिया है। कृपया मुझे बताएं कि क्या मैंने कुछ भी याद किया है।

— सीन बैनिस्टर

My क्या आपने मेरे "गरीब आदमी के परीक्षण" की कोशिश की? मुझे लगता है कि मैंने विशेष मामलों जैसे मैप, वीचपेज़, और शायद डेट, रेगएक्सप के लिए फ़ंक्शन में अधिक परीक्षण जोड़ना समाप्त कर दिया है। क्या आप अपने बारे में निश्चित हैं value.constructor === Object? इसकी जाँच करें ।

— पास्कल पोलीन्यूस

हां, मैंने आपके परीक्षण चलाए, उनके लिए धन्यवाद, हमारे दोनों कार्य हमारे दोनों परीक्षणों के साथ समान परिणाम लौटाते हैं। मैं सोचता रहता हूं कि क्या मैं इन परीक्षा मामलों के बाहर कुछ याद कर रहा हूं। मेरा मानना value.constructor === Objectहै कि ठीक है, जावास्क्रिप्ट में IF या स्टेटमेंट्स का निष्पादन क्रम है ताकि OR स्टेटमेंट केवल तभी निष्पादित होगा जब पिछले TRUE को वापस नहीं किया है और हमने पहले ही चेक कर लिया है Null। वास्तव में उस अंतिम OR स्टेटमेंट का एकमात्र उद्देश्य {}यह पता लगाना और सुनिश्चित करना है कि यह उन चीजों के लिए TRUE वापस नहीं करता है जो इसे नहीं करना चाहिए।

— सीन बैनिस्टर

Answer 27

यह जाँच करेगा कि क्या अनिश्चित निटिंग का चर अपरिभाषित है

function Undef(str) 
{
  var ary = str.split('.');
  var w = window;
  for (i in ary) {
    try      { if (typeof(w = w[ary[i]]) === "undefined") return true; }
    catch(e) { return true; }
  }
  return false;
}

if (!Undef("google.translate.TranslateElement")) {

यदि Google अनुवाद फ़ंक्शन TranslateElement मौजूद है तो उपरोक्त जाँचें। यह इसके बराबर है:

if (!(typeof google === "undefined" 
 || typeof google.translate === "undefined" 
 || typeof google.translate.TranslateElement === "undefined")) {

Answer 28

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

let customer = {
  name: "Carl",
  details: {
    age: 82,
    location: "Paradise Falls" // detailed address is unknown
  }
};
let customerCity = customer.details?.address?.city;

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

let customer = {
  name: "Carl",
  details: { age: 82 }
};
const customerCity = customer?.city ?? "Unknown city";
console.log(customerCity); // Unknown city

Answer 29

function notEmpty(value){
  return (typeof value !== 'undefined' && value.trim().length);
}

यह निम्नलिखित के साथ सफेद रिक्त स्थान ('') की भी जाँच करेगा:

• अशक्त, अपरिभाषित, NaN, खाली, स्ट्रिंग (""), 0, गलत

Answer 30

मुझे लगता है कि का उपयोग कर? ऑपरेटर थोड़ा क्लीनर है।

var ? function_if_exists() : function_if_doesnt_exist();