javascript - हरण - क्या है !! जावास्क्रिप्ट में ऑपरेटर नहीं(नहीं)




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

मैंने कुछ कोड देखा जो एक ऑपरेटर का उपयोग करने लगता है जिसे मैं पहचान नहीं पा रहा हूं, दो विस्मयादिबोधक बिंदुओं के रूप में, जैसे: !! । क्या कोई मुझे बता सकता है कि यह ऑपरेटर क्या करता है?

जिस संदर्भ में मैंने यह देखा था,

this.vertical = vertical !== undefined ? !!vertical : this.vertical;

https://code.i-harness.com


! "बूलियन नहीं" है, जो अनिवार्य रूप से इसके बुलियन के विपरीत "सक्षम" के मान को टाइप करता है। दूसरा ! इस मूल्य flips। तो, !!enable मतलब है "सक्षम नहीं है," आपको बुलियन के रूप में enable करने का मूल्य प्रदान करता है।


आधा काम करने के बहुत सारे जवाब। हां, !!X को "एक्स की सत्यता [बुलियन के रूप में दर्शाया गया]" के रूप में पढ़ा जा सकता है। लेकिन !! व्यावहारिक रूप से बोलना नहीं है, यह पता लगाने के लिए इतना महत्वपूर्ण है कि एक एकल चर है (या यहां तक ​​कि यदि कई चर हैं) सच्चाई या झूठी। !!myVar === true सिर्फ myVar जैसा ही है। तुलना में !!X "असली" बूलियन में वास्तव में उपयोगी नहीं है।

आप क्या हासिल करते हैं !! एक दोहराने योग्य, मानकीकृत (और जेएसलिंट अनुकूल) फैशन में एक दूसरे के खिलाफ कई चर की सत्यता की जांच करने की क्षमता है।

बस कास्टिंग :(

अर्थात्...

  • 0 === false false
  • !!0 === false true

उपर्युक्त इतना उपयोगी नहीं है। if (!0) आपको वही परिणाम देता है जैसे if (!!0 === false) । मैं एक चर को बूलियन के लिए कास्टिंग करने के लिए एक अच्छा मामला नहीं सोच सकता और फिर "सत्य" बूलियन की तुलना कर सकता हूं।

जेएसलिंट के दिशानिर्देशों से "== और! =" देखें (नोट: क्रॉकफ़ोर्ड अपनी साइट को थोड़ा सा स्थानांतरित कर रहा है; वह लिंक किसी बिंदु पर मरने के लिए उत्तरदायी है) क्यों:

तुलना करने से पहले == और! = ऑपरेटर टाइप जबरन करते हैं। यह खराब है क्योंकि यह '\ t \ r \ n' == 0 सत्य होने का कारण बनता है। यह मास्क प्रकार त्रुटियों कर सकते हैं। जेएसलिंट विश्वसनीय रूप से निर्धारित नहीं कर सकता है कि == सही तरीके से उपयोग किया जा रहा है, इसलिए == और! = का उपयोग न करना सबसे अच्छा है और हमेशा इसके बजाय अधिक विश्वसनीय === और! == ऑपरेटरों का उपयोग करना सबसे अच्छा है।

यदि आप केवल यह मानते हैं कि एक मूल्य सत्य या गलत है, तो संक्षिप्त फॉर्म का उपयोग करें। के बजाय
(foo != 0)

सिर्फ कहे
(foo)

और इसके बजाय
(foo == 0)

कहना
(!foo)

ध्यान दें कि कुछ अनजान मामले हैं जहां एक बुलियन को किसी संख्या में तुलना करते समय एक बूलियन को एक संख्या में डाला जाएगा ( true को 1 कास्ट किया गया है और 0 false है)। इस मामले में, !! मानसिक रूप से उपयोगी हो सकता है। हालांकि, फिर, ये ऐसे मामले हैं जहां आप एक गैर-बुलियन की तुलना हार्ड-टाइप किए गए बूलियन से कर रहे हैं, जो कि, इमो, एक गंभीर गलती है। if (-1) अभी भी यहां जाने का रास्ता है।

╔═══════════════════════════════════════╦═══════════════════╦═══════════╗
║               Original                ║    Equivalent     ║  Result   ║
╠═══════════════════════════════════════╬═══════════════════╬═══════════╣
║ if (-1 == true) console.log("spam")   ║ if (-1 == 1)      ║ undefined ║
║ if (-1 == false) console.log("spam")  ║ if (-1 == 0)      ║ undefined ║
║   Order doesn't matter...             ║                   ║           ║
║ if (true == -1) console.log("spam")   ║ if (1 == -1)      ║ undefined ║
╠═══════════════════════════════════════╬═══════════════════╬═══════════╣
║ if (!!-1 == true) console.log("spam") ║ if (true == true) ║ spam      ║ better
╠═══════════════════════════════════════╬═══════════════════╬═══════════╣
║ if (-1) console.log("spam")           ║ if (truthy)       ║ spam      ║ still best
╚═══════════════════════════════════════╩═══════════════════╩═══════════╝

और चीजें आपके इंजन के आधार पर भी पागल हो जाती हैं। उदाहरण के लिए, WScript पुरस्कार जीतता है।

function test()
{
    return (1 === 1);
}
WScript.echo(test());

कुछ ऐतिहासिक विंडोज जैव के कारण , यह संदेश बॉक्स में आउटपुट -1 होगा! इसे cmd.exe प्रॉम्प्ट में आज़माएं और देखें! लेकिन WScript.echo(-1 == test()) अभी भी आपको 0, या WScript की falseदूर देखो। यह घृणित है।

सच्चाई की तुलना :)

लेकिन क्या होगा यदि मेरे पास दो मूल्य हैं तो मुझे समान सत्य / फाल्सी-नेस की जांच करने की आवश्यकता है?

myVar1 = 0; कि हमारे पास myVar1 = 0; और myVar2 = undefined;

  • myVar1 === myVar2 0 === undefined और स्पष्ट रूप से झूठा है।
  • !!myVar1 === !!myVar2 है !!0 === !!undefined और सच है! वही सत्यता! (इस मामले में, दोनों "झूठी सच्चाई है"।)

तो एकमात्र जगह जिसे आपको वास्तव में "बुलियन-कास्ट वैरिएबल" का उपयोग करने की आवश्यकता होगी, यदि आपके पास ऐसी स्थिति हो जहां आप जांच कर रहे हों कि दोनों चरों में एक ही सत्यता है, है ना? यही है, उपयोग करें !! अगर आपको यह देखने की ज़रूरत है कि क्या दो वारा सत्य हैं या दोनों झूठी (या नहीं), यानी, समान (या नहीं) सत्यता है

मैं उस अपहृत के लिए एक महान, गैर-प्रदूषित उपयोग मामले के बारे में नहीं सोच सकता। हो सकता है कि आपने फ़ील्ड को "लिंक" फ़ील्ड में रखा हो?

if (!!customerInput.spouseName !== !!customerInput.spouseAge ) {
    errorObjects.spouse = "Please either enter a valid name AND age " 
        + "for your spouse or leave all spouse fields blank.";
}

तो अब यदि आपके पास दोनों पति / पत्नी के नाम और उम्र दोनों के लिए झूठी बात है, तो आप जारी रख सकते हैं। अन्यथा आपको केवल एक फ़ील्ड (या एक बहुत ही प्रारंभिक व्यवस्थित विवाह) के साथ एक फ़ील्ड मिला है और आपको अपनी त्रुटि errorObjects संग्रह पर अतिरिक्त त्रुटि बनाने की आवश्यकता है।

24 अक्टूबर 2017 संपादित करें:

तृतीय पक्ष पुस्तकालय जो स्पष्ट बूलियन मूल्यों की अपेक्षा करते हैं

यहां एक दिलचस्प मामला है ... !! उपयोगी हो सकता है जब तृतीय पक्ष libs स्पष्ट बूलियन मूल्यों की उम्मीद है।

उदाहरण के लिए, जेएसएक्स (प्रतिक्रिया) में झूठा एक विशेष अर्थ है जो सरल झूठी बात पर ट्रिगर नहीं होता है। यदि आपने अपने messageCount में निम्न की तरह कुछ वापस करने का प्रयास किया है, तो messageCount में int की उम्मीद है ...

{messageCount && <div>You have messages!</div>}

... जब आप शून्य संदेश प्राप्त करते हैं तो प्रतिक्रिया 0 प्रस्तुत करने के लिए आपको आश्चर्य हो सकता है। आपको जेएसएक्स को रेंडर न करने के लिए स्पष्ट रूप से झूठी वापसी करनी होगी। उपर्युक्त कथन 0 देता है, जो जेएसएक्स खुशी से प्रस्तुत करता है, जैसा कि इसे करना चाहिए। यह नहीं बता सकता कि आपके पास Count: {messageCount && <div>Get your count to zero!</div>} नहीं है Count: {messageCount && <div>Get your count to zero!</div>} (या कुछ कम संकुचित)।

  • एक फिक्स में बंगबैंग शामिल होता है, जो 0 में 0 को जोड़ता है, जो false :
    {!!messageCount && <div>You have messages!</div>}

  • जेएसएक्स 'दस्तावेज़ सुझाव देते हैं कि आप अधिक स्पष्ट हों, स्वयं-टिप्पणी कोड लिखें, और एक बूलियन को बल की तुलना करें।
    {messageCount > 0 && <div>You have messages!</div>}

  • मैं एक टर्नरी के साथ खुद को झूठ बोलने में अधिक आरामदायक हूं -
    {messageCount ? <div>You have messages!</div> : false}

ध्यान रखें कि यह एक जेएसएक्स सम्मेलन है , जावास्क्रिप्ट के लिए एक निहित नहीं है

लेकिन अगर आप अपने प्रस्तुत जेएसएक्स में अजीब 0 एस देखते हैं, तो ढीला झूठा प्रबंधन सोचें।


ऐसा लगता है कि !! ऑपरेटर के परिणामस्वरूप दोहरा निषेध होता है।

var foo = "Hello World!";

!foo // Result: false
!!foo // Result: true

जावास्क्रिप्ट में कुछ ऑपरेटर निहित प्रकार रूपांतरण करते हैं, और कभी-कभी टाइप रूपांतरण के लिए उपयोग किए जाते हैं।

यूनरी ! ऑपरेटर अपने ऑपरेंड को एक बुलियन में बदल देता है और इसे अस्वीकार करता है।

यह तथ्य निम्न मुहावरे को जन्म देता है जिसे आप अपने स्रोत कोड में देख सकते हैं:

!!x // Same as Boolean(x). Note double exclamation mark

बुलियन के लिए obbject oObject । अगर यह झूठा था (उदाहरण के लिए 0, null , undefined , आदि), यह false होगा, अन्यथा, true

!oObject  //Inverted boolean
!!oObject //Non inverted boolean so true boolean representation

तो !! एक ऑपरेटर नहीं है, यह सिर्फ है ! ऑपरेटर दो बार।

रियल वर्ल्ड उदाहरण "टेस्ट आईई संस्करण":

let isIE8 = false;  
isIE8 = !! navigator.userAgent.match(/MSIE 8.0/);  
console.log(isIE8); // returns true or false 

यदि आप ⇒

console.log(navigator.userAgent.match(/MSIE 8.0/));  
// returns null  

लेकिन अगर आप ⇒

console.log(!!navigator.userAgent.match(/MSIE 8.0/));  
// returns true or false

मुझे लगता है कि उल्लेखनीय बात यह है कि तार्किक और / OR के साथ संयुक्त एक शर्त एक बुलियन मूल्य नहीं लौटाएगी लेकिन आखिरी सफलता या पहली बार & amp और पहली सफलता या अंतिम विफलता के मामले में विफल हो जाएगी। हालत श्रृंखला का।

res = (1 && 2); // res is 2
res = (true && alert) // res is function alert()
res = ('foo' || alert) // res is 'foo'

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

res = !!(1 && 2); // res is true
res = !!(true && alert) // res is true
res = !!('foo' || alert) // res is true

यह Boolean() कास्टिंग फ़ंक्शन के व्यवहार को अनुकरण करता है। पहला बूलियन वैल्यू NOT देता है इससे कोई फर्क नहीं पड़ता कि यह किस ऑपरेंड को दिया जाता है। दूसरी बात यह NOT बताती कि Boolean मान और इसलिए एक चर के true बूलियन मान देता है। अंतिम परिणाम एक मूल्य पर Boolean() फ़ंक्शन का उपयोग करने जैसा ही है।


यह एक एकल ऑपरेटर नहीं है, यह दो है। यह निम्नलिखित के बराबर है और बुलियन के लिए मूल्य डालने का एक त्वरित तरीका है।

val.enabled = !(!enable);

यह एक प्रकार का रूपांतरण करने के लिए एक बेहद अस्पष्ट तरीका है।

! नहीं है तो !true false , और !false true!0 true , और !1 false

तो आप एक मूल्य को एक बूलियन में परिवर्तित कर रहे हैं, फिर इसे परिवर्तित कर रहे हैं, फिर इसे फिर से बदल रहे हैं।

// Maximum Obscurity:
val.enabled = !!userId;

// Partial Obscurity:
val.enabled = (userId != 0) ? true : false;

// And finally, much easier to understand:
val.enabled = (userId != 0);

यह प्रत्यय को एक बूलियन मान में परिवर्तित करता है।


यहां कोणीय जेएस से कोड का एक टुकड़ा है

var requestAnimationFrame = $window.requestAnimationFrame ||
                                $window.webkitRequestAnimationFrame ||
                                $window.mozRequestAnimationFrame;

 var rafSupported = !!requestAnimationFrame;

उनका इरादा राफ को सेट करना है अनुरोध में फ़ंक्शन की उपलब्धता के आधार पर सच्चे या झूठे में समर्थितएनीमेशन फ्रेम

इसे सामान्य रूप से निम्नलिखित तरीके से जांचकर हासिल किया जा सकता है:

if(typeof  requestAnimationFrame === 'function')
rafSupported =true;
else
rafSupported =false;

छोटा रास्ता उपयोग कर सकता है !!

rafSupported = !!requestAnimationFrame ;

इसलिए अगर अनुरोध एनीमेशन फ़्रेम को फ़ंक्शन सौंपा गया था! requestAnimationFrame गलत होगा और एक और! यह सच होगा

अगर अनुरोधएनीमेशन फ्रेम को अपरिभाषित किया गया था तो अनुरोध! अनुरोध एनीमेशन फ्रेम सत्य होगा और एक और! यह झूठा होगा


यहां महान उत्तरों के टन, लेकिन यदि आपने इसे अभी तक पढ़ा है, तो इससे मुझे 'इसे प्राप्त करने में मदद मिली।' क्रोम (आदि) पर कंसोल खोलें, और टाइपिंग शुरू करें:

!(!(1))
!(!(0))
!(!('truthy')) 
!(!(null))
!(!(''))
!(!(undefined))
!(!(new Object())
!(!({}))
woo = 'hoo'
!(!(woo))
...etc, etc, until the light goes on ;)

स्वाभाविक रूप से, ये सभी टाइपिंग के समान ही हैं !! कुछ टिंगिंग, लेकिन जोड़े गए कोष्ठक इसे और अधिक समझने में मदद कर सकते हैं।


!! मूल्य को इसके बराबर बूलियन मान में दाईं ओर परिवर्तित करता है। (गरीब आदमी के "प्रकार-कास्टिंग" के तरीके को सोचें)। इसका इरादा आमतौर पर पाठक को व्यक्त करना है कि कोड परवाह नहीं है कि चर में क्या मूल्य है, लेकिन यह "सत्य" मान क्या है।


!! यह दो बार एक साथ ऑपरेशन का उपयोग NOT कर रहा है ! मूल्य को एक boolean परिवर्तित करें और इसे उलट दें, यह देखने के लिए यहां एक सरल उदाहरण है !! काम करता है:

सबसे पहले, आपके पास जगह है:

var zero = 0;

फिर आप करते हैं !0 , इसे बूलियन में परिवर्तित कर दिया जाएगा और true मूल्यांकन किया जाएगा, क्योंकि 0 falsy , इसलिए आपको उल्टा मूल्य मिलता है और बूलियन में परिवर्तित किया जाता है, इसलिए इसे true मूल्यांकन किया जाता true

!zero; //true

लेकिन हम मूल्य के उल्टा बूलियन संस्करण नहीं चाहते हैं, इसलिए हम अपना परिणाम प्राप्त करने के लिए इसे फिर से उलट सकते हैं! यही कारण है कि हम दूसरे का उपयोग करते हैं !

असल में, !! हमें सुनिश्चित करें, हमें जो मूल्य मिलता है वह बुलियन है, झूठी, सच्चाई या स्ट्रिंग आदि नहीं ...

तो यह जावास्क्रिप्ट में Boolean फ़ंक्शन का उपयोग करना है, लेकिन एक मूल्य को बूलियन में परिवर्तित करने के लिए आसान और छोटा तरीका:

var zero = 0;
!!zero; //false

!!expr अभिव्यक्ति की सत्यता के आधार पर !!expr एक बूलियन मान ( true या false ) देता है। जब गैर-बूलियन प्रकारों पर उपयोग किया जाता है तो यह अधिक समझ में आता है। इन उदाहरणों पर विचार करें, खासकर तीसरा उदाहरण और आगे:

          !!false === false
           !!true === true

              !!0 === false
!!parseInt("foo") === false // NaN is falsy
              !!1 === true
             !!-1 === true  // -1 is truthy

             !!"" === false // empty string is falsy
          !!"foo" === true  // non-empty string is truthy
        !!"false" === true  // ...even if it contains a falsy value

     !!window.foo === false // undefined is falsy
           !!null === false // null is falsy

             !!{} === true  // an (empty) object is truthy
             !![] === true  // an (empty) array is truthy; PHP programmers beware!

!!foo यूनरी ऑपरेटर को दो बार लागू नहीं करता है और स्ट्रिंग में डालने के लिए एक खाली स्ट्रिंग ''+foo को कंटेंट करने के लिए यूनरी प्लस +foo के उपयोग के समान बुलियन प्रकार को डालने के लिए उपयोग किया जाता है।

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

Boolean(foo) === !!foo
Number(foo)  === +foo
String(foo)  === ''+foo

if और वक्तव्य और ? ऑपरेटर सत्य मूल्यों का उपयोग यह निर्धारित करने के लिए करता है कि कोड की कौन सी शाखा चलाना है। उदाहरण के लिए, शून्य और NaN संख्याएं और खाली स्ट्रिंग झूठी हैं, लेकिन अन्य संख्याएं और तार सत्य हैं। ऑब्जेक्ट्स सत्य हैं, लेकिन अपरिभाषित मान और null दोनों झूठे हैं।

डबल अस्वीकरण ऑपरेटर !! एक मूल्य के सत्य मूल्य की गणना करता है। यह वास्तव में दो ऑपरेटरों है, जहां !!x मतलब है !(!x) , और निम्नानुसार व्यवहार करता है:

  • यदि x एक झूठा मान है, तो !x true , और !!x false
  • यदि x एक वास्तविक मान है, तो !x false , और !!x true

जब एक बूलियन संदर्भ के शीर्ष स्तर पर उपयोग किया जाता है ( if , while , या ? ), !! ऑपरेटर व्यवहारिक रूप से नो-ऑप है। उदाहरण के लिए, if (x) और if (!!x) मतलब वही बात है।

व्यावहारिक उपयोग

हालांकि इसमें कई व्यावहारिक उपयोग हैं।

एक प्रयोग किसी ऑब्जेक्ट को अपने सच्चे मूल्य पर हानिकारक रूप से संपीड़ित करना है, ताकि आपका कोड किसी बड़े ऑब्जेक्ट का संदर्भ न रख सके और इसे जीवंत बनाए रखे। असाइन करना !!some_big_object बजाय !!some_big_object को एक चर के लिए कचरा कलेक्टर के लिए जाने दें। यह उन मामलों के लिए उपयोगी है जो ऑब्जेक्ट या झूठी मान उत्पन्न करते हैं जैसे null या अनिर्धारित मान, जैसे ब्राउज़र सुविधा पहचान।

एक अन्य उपयोग, जिसे मैंने सी के बारे में एक जवाब में बताया है !! ऑपरेटर , "लिंट" उपकरण के साथ है जो सामान्य टाइपो और प्रिंट डायग्नोस्टिक्स की तलाश में हैं। उदाहरण के लिए, सी और जावास्क्रिप्ट दोनों में, बूलियन ऑपरेशंस के लिए कुछ सामान्य टाइपो अन्य व्यवहार उत्पन्न करते हैं जिनका आउटपुट बूलियन के रूप में नहीं है:

  • if (a = b) असाइनमेंट है जिसके बाद b के सत्य मूल्य का उपयोग किया जाता है; if (a == b) एक समानता तुलना है।
  • if (a & b) थोड़ा सा है और; if (a && b) एक तार्किक है और। 2 & 5 0 (एक झूठा मूल्य); 2 && 5 सत्य है।

!! ऑपरेटर लिंट टूल को आश्वस्त करता है जो आपने लिखा था वह है जो आप चाहते थे: इस ऑपरेशन को करें, फिर परिणाम का सत्य मूल्य लें।

लॉजिकल एक्सओआर और लॉजिकल एक्सएनओआर का उत्पादन करने का तीसरा उपयोग है। सी और जावास्क्रिप्ट दोनों में, a && b एक तार्किक निष्पादित करता है और (यदि दोनों पक्ष सत्य हैं तो सत्य), और a & b थोड़ा सा प्रदर्शन करता है और। a || b a || b एक तार्किक प्रदर्शन करता है या (यदि कम से कम एक सत्य है), और a | b a | b थोड़ा सा प्रदर्शन करता है या। a ^ b रूप a ^ b सा एक्सओआर (अनन्य OR) है, लेकिन लॉजिकल एक्सओआर के लिए कोई अंतर्निहित ऑपरेटर नहीं है (सच है यदि वास्तव में एक तरफ सच है)। उदाहरण के लिए, आप उपयोगकर्ता को दो फ़ील्ड में से एक में पाठ दर्ज करने की अनुमति देना चाहते हैं। आप क्या कर सकते हैं प्रत्येक को एक वास्तविक मूल्य में परिवर्तित करें और उनकी तुलना करें: !!x !== !!y


कुछ चाय खींचा:

!! एक ऑपरेटर नहीं है। यह दोहरा उपयोग है ! - जो तार्किक "नहीं" ऑपरेटर है।

सिद्धांत रूप में:

! एक मूल्य क्या नहीं है "सत्य" निर्धारित करता है:

  • सच्चाई यह है कि false true नहीं true (यही कारण है कि !false true में !false परिणाम)

  • सच्चाई यह है कि true false नहीं false (यही कारण है कि !true में false परिणाम)

!! एक मूल्य नहीं है कि "सत्य" निर्धारित करता है:

  • सच्चाई यह है कि true नहीं true (यही कारण है कि !!true में true परिणाम)

  • सच्चाई यह है कि false नहीं false (यही कारण है कि !!false परिणाम false )

हम तुलना में निर्धारित करना चाहते हैं कि संदर्भ के मूल्य के बारे में "सत्य" है, न कि संदर्भ का मूल्य । एक उपयोग-मामला है जहां हम मूल्य के बारे में सच्चाई जानना चाहते हैं, भले ही हम मान को false (या false ) होने की उम्मीद करते हैं, या यदि हम उम्मीद करते हैं कि मूल्य boolean टाइप न हो।

प्रयोग में:

एक संक्षिप्त कार्य पर विचार करें जो गतिशील टाइपिंग (उर्फ "बतख टाइपिंग") के माध्यम से फीचर कार्यक्षमता (और इस मामले में, प्लेटफार्म संगतता) का पता लगाता है। हम एक ऐसा फ़ंक्शन लिखना चाहते हैं जो उपयोगकर्ता के ब्राउज़र को HTML5 <audio> तत्व का समर्थन करता है, लेकिन हम नहीं चाहते हैं कि फ़ंक्शन एक त्रुटि फेंक दे यदि <audio> अपरिभाषित है; और हम कोशिश नहीं करना चाहते हैं try ... catch किसी भी संभावित त्रुटियों को संभालने के लिए पकड़ें (क्योंकि वे सकल हैं); और हम फ़ंक्शन के अंदर एक चेक का उपयोग नहीं करना चाहते हैं जो सुविधा के बारे में सच्चाई को लगातार प्रकट नहीं करेगा (उदाहरण के लिए, document.createElement('audio') अभी भी <audio> नामक तत्व बना देगा, भले ही HTML5 <audio> समर्थित नहीं है)।

यहां तीन दृष्टिकोण दिए गए हैं:

// this won't tell us anything about HTML5 `<audio>` as a feature
var foo = function(tag, atr) { return document.createElement(tag)[atr]; }

// this won't return true if the feature is detected (although it works just fine)
var bar = function(tag, atr) { return !document.createElement(tag)[atr]; }

// this is the concise, feature-detecting solution we want
var baz = function(tag, atr) { return !!document.createElement(tag)[atr]; }

foo('audio', 'preload'); // returns "auto"
bar('audio', 'preload'); // returns false
baz('audio', 'preload'); // returns true

प्रत्येक फ़ंक्शन एक <tag> और एक attribute लिए एक तर्क के लिए एक तर्क स्वीकार करता है, लेकिन वे प्रत्येक तुलना के आधार पर अलग-अलग मान वापस करते हैं।

लेकिन रुको, और भी है!

आप में से कुछ ने शायद देखा है कि इस विशिष्ट उदाहरण में, किसी व्यक्ति के पास संपत्ति की संपत्ति होने पर जांच करने के थोड़ा अधिक प्रदर्शन माध्यमों का उपयोग करके संपत्ति की जांच कर सकती है। इसे करने के दो तरीके हैं:

// the native `hasOwnProperty` method
var qux = function(tag, atr) { return document.createElement(tag).hasOwnProperty(atr); }

// the `in` operator
var quux = function(tag, atr) { return atr in document.createElement(tag); }

qux('audio', 'preload');  // returns true
quux('audio', 'preload'); // returns true

हम digress ...

हालांकि, ये परिस्थितियां दुर्लभ हो सकती हैं, ऐसे कुछ परिदृश्य मौजूद हो सकते हैं जहां सबसे संक्षिप्त, सबसे अधिक प्रदर्शन करने वाला, और इस प्रकार गैर-बूलियन से true होने का सबसे पसंदीदा माध्यम, संभवतः अपरिभाषित मूल्य वास्तव में उपयोग कर रहा है !! । उम्मीद है कि यह हास्यास्पद इसे साफ़ करता है।


मैं बस इसे जोड़ना चाहता था

if(variableThing){
  // do something
}

के समान है

if(!!variableThing){
  // do something
}

लेकिन यह एक मुद्दा हो सकता है जब कुछ अपरिभाषित होता है।

// a is undefined, b is empty object.
var a, b = {};

// Both of these give error a.foo is not defined etc.
// you'd see the same behavior for !!a.foo and !!b.foo.bar

a.foo 
b.foo.bar

// This works -- these return undefined

a && a.foo
b.foo && b.foo.bar
b && b.foo && b.foo.bar

यहां की चाल है कि &&एस इच्छा की श्रृंखला पहले झूठे मूल्य को वापस लाएगी - और इसे किसी कथन कथन आदि को खिलाया जा सकता है। इसलिए यदि बी.फू अपरिभाषित है, तो यह अनिर्धारित हो जाएगा और b.foo.barकथन छोड़ देगा , और हमें कोई नहीं मिलेगा त्रुटि।

उपर्युक्त वापसी अपरिभाषित है, लेकिन यदि आपके पास खाली स्ट्रिंग है, झूठी, शून्य, 0, अपरिभाषित वे मान वापस आ जाएंगे और जैसे ही हम उन्हें श्रृंखला में सामना करेंगे - []और {}दोनों सत्य हैं।


लॉजिकल ऑपरेटर का दो बार
इसका मतलब नहीं है! सच = झूठा
और !! सच = सच







operators