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




operators (25)

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

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

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

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

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

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, अपरिभाषित वे मान वापस आ जाएंगे और जैसे ही हम उन्हें श्रृंखला में सामना करेंगे - []और {}दोनों सत्य हैं।


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

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

 var rafSupported = !!requestAnimationFrame;

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

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

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

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

rafSupported = !!requestAnimationFrame ;

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

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


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

val.enabled = !(!enable);

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

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

Falsey मूल्यों जावास्क्रिप्ट में मजबूर करने के लिए झूठा है, और truthy मूल्यों मजबूर करने के लिए सही। झूठी और सच्चे मूल्यों का भी ifविवरणों में उपयोग किया जा सकता है और अनिवार्य रूप से उनके संबंधित बुलियन मूल्य पर "मानचित्र" होगा। हालांकि, आपको संभवतः खुद को उचित बूलियन मूल्यों का उपयोग नहीं करना पड़ेगा, क्योंकि वे अधिकतर आउटपुट (रिटर्न वैल्यू) में भिन्न होते हैं।

हालांकि इस कास्टिंग के लिए इसी तरह लग सकता है, वास्तविक इस संभावना एक है मात्र संयोग नहीं है और 'बनाया' या जानबूझ कर किया जाता है के लिए और एक बूलियन कलाकारों की तरह। तो चलिए इसे कॉल न करें।

क्यों और कैसे काम करता है

संक्षिप्त होने के लिए, ऐसा कुछ दिखता है ! ( !null ):। जबकि, nullहै falsey , इसलिए !nullहो सकता है सच । फिर !trueहोगा झूठी और यह अनिवार्य रूप से होगा वापस पलट क्या वह पहले था, एक के रूप में इस समय को छोड़कर उचित बूलियन मान (या इसके विपरीत के साथ truthy मूल्यों की तरह {}या 1)।


अपने उदाहरण पर वापस जा रहे हैं

कुल मिलाकर, जो संदर्भ आपने देखा है, उस this.verticalपर निर्भर करता है कि verticalपरिभाषित किया गया है या नहीं , और यदि ऐसा है; यह लंबवत के परिणामी बुलियन मूल्य पर सेट किया जाएगा, अन्यथा यह नहीं बदलेगा। दूसरे शब्दों में, यदि verticalपरिभाषित किया गया है; this.verticalइसके बुलियन मूल्य पर सेट किया जाएगा, अन्यथा, यह वही रहेगा। मुझे लगता है कि आप में एक उदाहरण है कि आप कैसे उपयोग करेंगे !!, और यह क्या करता है।


लंबवत I / O उदाहरण

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

var vertical = document.getElementById("vertical");
var p = document.getElementById("result");

function Example(vertical)
{
        this.vertical = vertical !== undefined ? !!vertical : 
        this.vertical;   

        return this.vertical;
}

document.getElementById("run").onclick = function()
{

  p.innerHTML = !!( new Example(eval(vertical.value)).vertical );
  
}
input
{
  text-align: center;
  width: 5em;
} 

button 
{
  margin: 15.5px;
  width: 14em;
  height: 3.4em;
  color: blue;
}

var 
{
  color: purple;
}

p {
  margin: 15px;
}

span.comment {
  color: brown;
}
<!--Vertical I/O Example-->
<h4>Vertical Example</h4>
<code id="code"><var class="var">var</var> vertical = <input type="text" id="vertical" maxlength="9" />; <span class="comment">// enter any valid javascript value</span></code>
<br />
<button id="run">Run</button>
<p id="result">...</p>


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


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

var foo = "Hello World!";

!foo // Result: false
!!foo // Result: 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


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

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


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

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

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

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

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

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

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


आधा काम करने के बहुत सारे जवाब। हां, !!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 एस देखते हैं, तो ढीला झूठा प्रबंधन सोचें।


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

तो उस मामले में एक नकारात्मक (या सकारात्मक) जवाब प्राप्त करने के लिए आपको सबसे पहले उपयोग करने की आवश्यकता होगी! एक बुलियन प्राप्त करने के लिए ऑपरेटर, लेकिन यदि आप सकारात्मक मामले की जांच करना चाहते हैं !! !!


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

इसके बजाय, 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 उपयोग में 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


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

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

var zero = 0;

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

!zero; //true

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

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

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

var zero = 0;
!!zero; //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

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

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

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

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

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

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


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


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


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

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

true === !!10

false === !!0

नल Coalesce ऑपरेटर "??" (PHP 7 में जोड़ा गया)

एक ऑपरेटर के लिए सबसे आकर्षक नाम नहीं है, लेकिन PHP 7 बल्कि आसान काम को लाता है इसलिए मैंने सोचा कि मैं एक उदाहरण साझा करूंगा।

PHP 5 में, हमारे पास पहले से ही एक टर्नरी ऑपरेटर है, जो एक मान का परीक्षण करता है, और उसके बाद दूसरा तत्व देता है यदि यह सत्य लौटाता है और तीसरा यदि यह नहीं करता है:

echo $count ? $count : 10; // outputs 10

इसके लिए एक शॉर्टेंड भी है जो आपको दूसरे तत्व को छोड़ने की इजाजत देता है यदि यह पहले जैसा ही है: echo $ count?: 10; // 10 आउटपुट भी

PHP 7 में हम अतिरिक्त रूप से प्राप्त करते हैं ?? ऑपरेटर जो चरम भ्रम का संकेत देने के बजाए है, इस तरह मैं आमतौर पर दो प्रश्न चिह्नों का उपयोग करता हूं, इसके बजाय हम मूल्यों की एक स्ट्रिंग को एक साथ जोड़ सकते हैं। बाएं से दाएं पढ़ना, पहला मान जो मौजूद है और शून्य नहीं है वह मान है जो वापस किया जाएगा।

// $a is not set
$b = 16;

echo $a ?? 2; // outputs 2
echo $a ?? $b ?? 7; // outputs 16

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





javascript operators