दिलचस्प पोस्ट
MATLAB में निकटतम पड़ोसी प्रक्षेपण एल्गोरिथ्म वह ऑटो-असाइनिंग आईडी रेल करता है जो पहले से मौजूद है onClick पर ViewPager ट्रिगर नहीं जावास्क्रिप्ट नेस्टेड ऑब्जेक्ट को सुरक्षित रूप से एक्सेस करें getOutputStream () को पहले ही इस प्रतिक्रिया के लिए बुलाया गया है asp.net mvc3 रेजर प्रलेखन? AngularJS के साथ कैसे $ http समकालिक कॉल करें मेवेन में संसाधनों का नामकरण FileUpload नियंत्रण के साथ एक फ़ाइल का पूरा पथ प्राप्त करें मैं कैसे जांच करूं अगर कोई रिपॉजिटरी नंगे हो? मौजूदा गैर-रिक्त निर्देशिका को एक गीट कार्य निर्देशिका में कनवर्ट करने और फ़ाइलों को एक दूरस्थ रिपॉजिटरी में कैसे लाया जाए Linq क्या है और यह क्या करता है? क्या <b> और <i> टैग कभी भी नापसंद हो जाएंगे? MySQL क्रम में पंक्ति स्थिति में मिलता है अमान्य UTF-8 वर्णों के उपयोगकर्ता इनपुट को कैसे नियंत्रित करें?

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

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

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

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

Solutions Collecting From Web of "क्या है !! (नहीं) ऑपरेटर जावास्क्रिप्ट में?"

बुलियन के लिए ऑब्जेक्ट 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 

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

! नहीं है तो, !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); 

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

  !!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! 

कुछ चाय काढ़ा:

!! ऑपरेटर नहीं है यह डबल उपयोग है ! – जो तार्किक "नहीं" ऑपरेटर है


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

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

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

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


!! क्या मान नहीं है की "सच्चाई" निर्धारित करता है:

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

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


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


प्रयोग में:

गतिशील टाइपिंग (उर्फ "बतख टंकण") के माध्यम से सुविधा (और इस मामले में, मंच संगतता) का पता लगाता है, जो एक संक्षिप्त समारोह पर विचार करें। हम उस फ़ंक्शन को लिखना चाहते हैं जो उपयोगकर्ता के ब्राउज़र को HTML5 <audio> तत्व का समर्थन करने के लिए true हो जाता है, लेकिन हम नहीं चाहते कि फ़ंक्शन किसी त्रुटि को अगर <audio> अपरिभाषित है; और हम कोशिश नहीं करना चाहते try ... catch किसी भी संभावित त्रुटियों को संभालने के लिए 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 

हम पीछे हटते हैं …

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

!! इसके समतुल्य बूलियन मान के दावे के दावे के अनुसार मूल्य को परिवर्तित करता है (गरीब प्रकार का "प्रकार-कास्टिंग" का तरीका जानें) इसका इरादा आम तौर पर पाठक को व्यक्त करने के लिए होता है कि कोड की परवाह नहीं है कि वैल्यूएबल में क्या मूल्य है, लेकिन यह "सत्य" मान क्या है?

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

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

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

यह सिर्फ तार्किक नहीं ऑपरेटर है, दो बार – इसका उपयोग बूलियन को कुछ रूपांतरित करने के लिए किया जाता है, जैसे:

 true === !!10 false === !!0 

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

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

बस कास्टिंग 🙁

अर्थात्…

  • 0 === false है
  • !!0 === false true

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

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

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

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

सिर्फ कहे
(foo)

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

कहना
(!foo)

ध्यान दें कि कुछ असाधारण मामलों में जहां बुलियन को किसी संख्या में डाल दिया जाता है ( true 1 और false से 0 डाली जाती है) इस मामले में, !! मानसिक रूप से उपयोगी हो सकता है हालांकि, फिर से, ये ऐसे मामलों हैं जहां आप एक गैर-बुलियन की हार्ड-टाइप बूलियन की तुलना कर रहे हैं, जो है, आईएमओ, एक गंभीर गलती है। 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 होगा! इसे एक सीएमडी.एक्सए प्रॉम्प्ट में देखें और देखें! लेकिन WScript.echo(-1 == test()) अभी भी आपको 0 देता है, या WScript के false । दूर देखो। यह भयानक है

सच्चाई की तुलना 🙂

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

बहाना हम 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 को संपादित करें:

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

यहाँ एक दिलचस्प मामला है … !! उपयोगी हो सकता है जब तीसरी पार्टी लिबर्स स्पष्ट बूलियन मानों की अपेक्षा करते हैं।

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

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

… आपको आश्चर्य हो सकता है कि आपके पास शून्य संदेश होने पर प्रतिक्रिया दें 0 JSX को रेंडर न करने के लिए आपको स्पष्ट रूप से झूठी वापसी करना होगा। उपरोक्त कथन 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}

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

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

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

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

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

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

ऐसा लगता है कि !! ऑपरेटर परिणाम एक डबल नकार में

 var foo = "Hello World!"; !foo // Result: false !!foo // Result: true 

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

 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 

!! निर्माण अपने बूलियन समकक्ष में किसी भी जावास्क्रिप्ट अभिव्यक्ति को बदलने का एक आसान तरीका है

उदाहरण के लिए: !!"he shot me down" === true और !!0 === false

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

 val.enabled = !(!enable); 

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

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

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

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

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

  • यदि x एक गलत मान है !x true , और !!x false
  • यदि x एक सही मूल्य है !x false , और !!x true

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

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

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

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

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

  • if (a = b) के सत्य मान के उपयोग के बाद काम किया जाता है; if (a == b) एक समानता तुलना है
  • if (a & b) एक बिटवर्ड और है; if (a && b) एक तार्किक और है 2 & 5 0 (एक गलत मान); 2 && 5 सही है

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

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

डबल बूलियन अस्वीकरण अक्सर यह जांचने के लिए प्रयोग किया जाता है कि मूल्य अनिर्धारित नहीं है।

!!x Boolean(x) लिए Boolean(x)

पहली धमाके ने Boolean(x) को चलाने के लिए जेएस इंजन की Boolean(x) लेकिन इसके मूल्य को परिवर्तित करने का भी पक्ष प्रभाव पड़ता है। तो दूसरा बैंग पक्ष प्रभाव को नापसंद करता है।

मुझे संदेह है कि यह C ++ से एक बचे हुए है, जहां लोग ओवरराइड करते हैं! ऑपरेटर, लेकिन नहीं bool ऑपरेटर।

तो उस स्थिति में एक नकारात्मक (या सकारात्मक) उत्तर पाने के लिए आपको सबसे पहले इसका उपयोग करना होगा! ऑपरेटर एक बूलियन प्राप्त करने के लिए, लेकिन अगर आप देखना चाहते हैं कि सकारात्मक मामला उपयोग करेगा !!

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

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

उनका इरादा अनुरोध के लिए समारोह की उपलब्धता के आधार पर सही या गलत पर आरएफ़ समर्थन प्रदान करना है।

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

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

छोटा रास्ता इस्तेमाल किया जा सकता है !!

 rafSupported = !!requestAnimationFrame ; 

इसलिए यदि requestAnimationFrame को एक फ़ंक्शन तब आवंटित किया गया था! requestAnimationFrame गलत होगा और एक और! इसके बारे में सच होगा

अगर requestAnimationFrame को assfed किया गया था तो अनिर्धारित! requestAnimationFrame सच हो जाएगा और एक और! इसके बारे में गलत होगा

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

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

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

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

एक चर के बूलियन मान देता है

इसके बजाय, Boolean क्लास का उपयोग किया जा सकता है

(कृपया कोड वर्णन पढ़ें)

 var X = "test"; // X value is "test" as a String value var booleanX = !!X // booleanX is `true` as a Boolean value beacuse non-empty strings evaluates as `true` in boolean var whatIsXValueInBoolean = Boolean(X) // whatIsXValueInBoolean is `true` again console.log(Boolean(X) === !!X) // writes `true` 

अर्थात्, उपयोग में Boolean(X) = !!X

कृपया नीचे दिए गए कोड स्निपेट को चेक करें

 let a = 0 console.log("a: ", a) // writes a value in its kind console.log("!a: ", !a) // writes '0 is NOT true in boolean' value as boolean - So that's true.In boolean 0 means false and 1 means true. console.log("!!a: ", !!a) // writes 0 value in boolean. 0 means false. console.log("Boolean(a): ", Boolean(a)) // equals to `!!a` console.log("\n") // newline a = 1 console.log("a: ", a) console.log("!a: ", !a) console.log("!!a: ", !!a) // writes 1 value in boolean console.log("\n") // newline a = "" console.log("a: ", a) console.log("!a: ", !a) // writes '"" is NOT true in boolean' value as boolean - So that's true.In boolean empty strings, null and undefined values mean false and if there is a string it means true. console.log("!!a: ", !!a) // writes "" value in boolean console.log("\n") // newline a = "test" console.log("a: ", a) // writes a value in its kind console.log("!a: ", !a) console.log("!!a: ", !!a) // writes "test" value in boolean console.log("Boolean(a) === !!a: ", Boolean(a) === !!a) // writes true 
 a = 1; alert(!a) // -> false : a is not not defined alert(!!a) // -> true : a is not not defined 

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

!!a ही जैसा है !(!a) । अगर a परिभाषित है, तो a true !a false , और !!a true

दो बार तार्किक नहीं ऑपरेटर का उपयोग करें
इसका मतलब है! सच = गलत
और !! सच = सच

!! बूलियन कन्स्ट्रक्टर का उपयोग करने के समान है, या बेशक बुलियन फ़ंक्शन की तरह अधिक है।

 console.log(Boolean(null)); // Preffered over the Boolean object console.log(new Boolean(null).valueOf()); // Not recommended for coverting non-boolean values console.log(!!null); // A hacky way to omit calling the Boolean function, but essentially does the same thing. // The context you saw earlier (your example) var vertical; function Example(vertical) { this.vertical = vertical !== undefined ? !!vertical : this.vertical; // Let's break it down: If vertical is strictly not undefined, return the boolean value of vertical and set it to this.vertical. If not, don't set a value for this.vertical (just ignore it and set it back to what it was before; in this case, nothing). return this.vertical; } console.log( "\n---------------------" ) // vertical is currently undefined console.log(new Example(vertical).vertical); // The falsey or truthy value of this.vertical console.log(!!new Example(vertical).vertical); // Coerced value of this.vertical vertical = 12.5; // set vertical to 12.5, a truthy value. console.log(new Example(vertical).vertical); // The falsey or truthy value of this.vertical which happens to be true anyway console.log(!!new Example(vertical).vertical); // Coerced value of this.vertical vertical = -0; // set vertical to -0, a falsey value. console.log(new Example(vertical).vertical); // The falsey or truthy value of this.vertical which happens to be false either way console.log(!!new Example(vertical).vertical); // Coerced value of this.vertical 

I just wanted to add that

 if(variableThing){ // do something } 

के समान है

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

But this can be an issue when something is undefined.

 // 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 

The trick here is the chain of && s will return the first falsey value it finds — and this can be fed to an if statement etc. So if b.foo is undefined, it will return undefined and skip the b.foo.bar statement, and we get no error.

The above return undefined but if you have an empty string, false, null, 0, undefined those values will return and soon as we encounter them in the chain — [] and {} are both truthy.

After seeing all these great answers, I would like to add another reason for using !! । Currenty I'm working in Angular 2-4 (TypeScript) and I want to return a boolean as false when my user is not authenticated. If he isn't authenticated, the token-string would be null or "" . I can do this by using the next block of code:

 public isAuthenticated(): boolean { return !!this.getToken(); } 

!! it's using NOT operation twice together, ! convert the value to a boolean and reverse it, here is a the simple example to see how !! works:

At first place you have:

 var zero = 0; 

Then you do !0 , it will be converted to boolean and be evaluated to true , because 0 is falsy , so you get the reversed value and converted to boolean, so it gets evaluated to true .

 !zero; //true 

but we don't want the reversed boolean version of the value, so we can reverse it again to get our result! That's why we use another !

Basically, !! make us sure, the value we get is boolean, not falsy, truthy or string etc…

So it's like using Boolean function in javascript, but easy and shorter way to convert a value to boolean:

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