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

लॉजिकल ऑपरेटर आपको बूलियन वैल्यू पर लॉजिकल ऑपरेशंस करने की अनुमति देते हैं। वे आपको बूलियन मूल्यों को संयोजित करने, नकारने या तुलना करने देते हैं और परिणाम के आधार पर आपके कोड में तार्किक निर्णय लेते हैं।

ES6 नलिश कोलेसिंग ऑपरेटर सहित जावास्क्रिप्ट द्वारा समर्थित विभिन्न तार्किक ऑपरेटरों का अन्वेषण करें।

तार्किक AND (&&) ऑपरेटर

AND (&&) ऑपरेटर एक तार्किक ऑपरेटर है जो रिटर्न देता है सत्य यदि दोनों ऑपरेंड मूल्यांकन करते हैं सत्य और असत्य अन्यथा।

यहाँ AND ऑपरेटर का सिंटैक्स है:

ए && बी

यहां AND ऑपरेटर के उपयोग का एक उदाहरण दिया गया है:

कॉन्स्ट एक = 5;
कॉन्स्ट बी = 10;
कॉन्स्ट सी = 15;
कॉन्स्ट परिणाम_1 = (ए सांत्वना देनालॉग (परिणाम_1); // सत्य
कॉन्स्ट परिणाम_2 = (ए> बी) && (बी सांत्वना देनालॉग (परिणाम_2); // असत्य

इस उदाहरण में, परिणाम_1 का मूल्यांकन करता है सत्य क्योंकि अभिव्यक्ति में दो ऑपरेंड मूल्यांकन करते हैं सत्य. हालाँकि, परिणाम_2 का मूल्यांकन करता है असत्य क्योंकि पहला ऑपरेंड (ए> बी) लौटता है असत्य.

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

जावास्क्रिप्ट किसी भी मूल्य को मानता है जो स्पष्ट रूप से गलत नहीं है, एक सत्य मूल्य है। परिवर्तित होने पर, वे एक बूलियन का मूल्यांकन करते हैं सत्य.

हालाँकि, कुछ मान और जावास्क्रिप्ट में डेटा प्रकार झूठे हैं, इसलिए जब जावास्क्रिप्ट उन्हें परिवर्तित करता है, तो वे एक बूलियन का मूल्यांकन करते हैं असत्य.

जावास्क्रिप्ट में झूठे मूल्य हैं:

  • असत्य
  • व्यर्थ
  • अपरिभाषित
  • नेन (संख्या नहीं)
  • 0
  • बिगइंट (0एन)
  • खाली स्ट्रिंग ("" या '' या ``)
  • अपरिभाषित

जब आप गैर-बूलियन मानों का मूल्यांकन करने के लिए AND ऑपरेटर का उपयोग करते हैं, तो अभिव्यक्ति तुरंत पहले ऑपरेंड का मान लौटाती है यदि ऑपरेंड दूसरे का मूल्यांकन किए बिना गलत है। इस व्यवहार को शॉर्ट सर्किटिंग के रूप में जाना जाता है और आप इसे लिखने के लिए उपयोग कर सकते हैं जावास्क्रिप्ट में सशर्त बयान.

हालाँकि, यदि पहला ऑपरेंड सत्य है, तो अभिव्यक्ति दूसरे ऑपरेंड का मूल्यांकन करने के लिए आगे बढ़ती है। यदि दूसरा ऑपरेंड सत्य है, तो यह इसे वापस कर देता है।

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

कॉन्स्ट एक = 5;
कॉन्स्ट बी = 'नमस्ते';
कॉन्स्ट सी = व्यर्थ;
कॉन्स्ट परिणाम_1 = ए && बी;
सांत्वना देनालॉग (परिणाम_1); // "नमस्ते"
कॉन्स्ट परिणाम_2 = सी && बी;
सांत्वना देनालॉग (परिणाम_2); // व्यर्थ

इस उदाहरण में, परिणाम_1 "हैलो" का मूल्यांकन करता है क्योंकि अभिव्यक्ति में दोनों ऑपरेंड सत्य हैं। हालाँकि, परिणाम_2 शॉर्ट-सर्किट और रिटर्न व्यर्थ दूसरे ऑपरेंड का मूल्यांकन किए बिना।

ध्यान दें कि यदि अधिक ऑपरेंड हैं, तो AND ऑपरेटर तब तक उनका मूल्यांकन करना जारी रखेगा जब तक कि यह एक गलत मान का सामना नहीं करता। यदि यह किसी मिथ्या मान का सामना नहीं करता है, तो इसका सामना करने वाला अंतिम सत्य मान लौटाता है।

तार्किक या (||) ऑपरेटर

OR (||) ऑपरेटर एक तार्किक ऑपरेटर है जो रिटर्न देता है सत्य अगर और केवल अगर इसके एक या अधिक ऑपरेंड हैं सत्य. यह केवल लौटता है असत्य जब दोनों ऑपरेंड हैं असत्य.

यहां OR ऑपरेटर का सिंटैक्स है:

ए || बी

यहां उपयोग किए जा रहे OR ऑपरेटर का उदाहरण दिया गया है:

कॉन्स्ट एक = 5;
कॉन्स्ट बी = 10;
कॉन्स्ट सी = 15;
कॉन्स्ट परिणाम_1 = (ए सांत्वना देनालॉग (परिणाम_1); // सत्य


कॉन्स्ट परिणाम_2 = (ए > बी) || (बी सांत्वना देनालॉग (परिणाम_2); // सत्य
कॉन्स्ट परिणाम_3 = (ए> बी) || (बी> सी);
सांत्वना देनालॉग (परिणाम_3); // असत्य

उपरोक्त उदाहरण में, परिणाम_1 का मूल्यांकन करता है सत्य क्योंकि अभिव्यक्ति में दोनों ऑपरेंड मूल्यांकन करते हैं सत्य. परिणाम_2 का मूल्यांकन करता है सत्य क्योंकि दूसरा ऑपरेंड इसका मूल्यांकन करता है सत्य. परिणाम_3 का मूल्यांकन करता है असत्य क्योंकि अभिव्यक्ति में दो ऑपरेंड मूल्यांकन करते हैं असत्य.

जब आप गैर-बूलियन संदर्भों में OR ऑपरेटर का उपयोग करते हैं, तो जावास्क्रिप्ट अभिव्यक्ति का मूल्यांकन करने से पहले बूलियन मानों में बदलने का प्रयास करता है।

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

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

कॉन्स्ट एक = 5;
कॉन्स्ट बी = 'नमस्ते';
कॉन्स्ट सी = व्यर्थ;
कॉन्स्ट परिणाम_1 = एक || बी;
सांत्वना देनालॉग (परिणाम_1); // 5


कॉन्स्ट परिणाम_2 = सी || बी;
सांत्वना देनालॉग (परिणाम_2); // "नमस्ते"
कॉन्स्ट परिणाम_3 = सी || " ";
सांत्वना देनालॉग (परिणाम_3); // " "

उपरोक्त उदाहरण में, परिणाम_1 शॉर्ट-सर्किट और रिटर्न 5 क्योंकि यह एक सत्य मूल्य है। परिणाम_2 "हैलो" लौटाता है क्योंकि यह अभिव्यक्ति में मिलने वाला पहला सत्य मूल्य है। परिणाम_3 एक खाली स्ट्रिंग लौटाता है क्योंकि यह अभिव्यक्ति में अंतिम गलत मान है।

तार्किक नहीं (!) ऑपरेटर

तार्किक NOT (!) ऑपरेटर एक यूनरी ऑपरेटर है जो अपने ऑपरेंड के विपरीत बूलियन मान लौटाता है।

यहाँ NOT ऑपरेटर का सिंटैक्स है:

!एक्स

कहाँ एक्स एक बूलियन या एक सत्य या असत्य मूल्य है।

यहाँ उपयोग में NOT ऑपरेटर का उदाहरण दिया गया है:

कॉन्स्ट एक = 5;
कॉन्स्ट बी = '';
कॉन्स्ट सी = सत्य;
कॉन्स्ट परिणाम_1 = !ए;
सांत्वना देनालॉग (परिणाम_1); // असत्य


कॉन्स्ट परिणाम_2 = !बी;
सांत्वना देनालॉग (परिणाम_2); // सत्य
कॉन्स्ट परिणाम_3 = !सी;
सांत्वना देनालॉग (परिणाम_3); // असत्य

उपरोक्त उदाहरण में, NOT ऑपरेटर बूलियन ऑपरेंड का व्युत्क्रम मान लौटाता है। जब आप गैर-बूलियन संदर्भों में NOT ऑपरेटर का उपयोग करते हैं (परिणाम_1 & परिणाम_2), यह सत्य मानों को के व्युत्क्रम मान में परिवर्तित करता है सत्य और मिथ्या मानों को के व्युत्क्रम मान में परिवर्तित करता है असत्य.

नलिश कोलेसिंग (??) ऑपरेटर

नलिश कोलेसिंग ऑपरेटर एक तार्किक ऑपरेटर है जो दो ऑपरेंड का मूल्यांकन करता है और यदि यह नहीं है तो पहला ऑपरेंड लौटाता है व्यर्थ या अपरिभाषित. अन्यथा, यह दूसरा ऑपरेंड लौटाता है।

एक नज़र में, नलिश कोलेसिंग ऑपरेटर तार्किक OR (||) ऑपरेटर के समान लग सकता है, लेकिन ऐसा नहीं है। मुख्य अंतर यह है कि OR ऑपरेटर दाएं हाथ के ऑपरेंड को लौटाता है यदि बायां ऑपरेंड "कोई" गलत मान है, न केवल व्यर्थ या अपरिभाषित.

मुठभेड़ करते समय यह डिफ़ॉल्ट मान चुनने का एक संक्षिप्त तरीका प्रदान करता है व्यर्थ या अपरिभाषित मान।

यहाँ अशक्त कोलेसिंग ऑपरेटर के लिए सिंटैक्स है:

एक्स?? वाई

यहाँ उपयोग में अशक्त कोलेसिंग ऑपरेटर का एक उदाहरण दिया गया है:

कॉन्स्ट नाम = व्यर्थ;
कॉन्स्ट डिफ़ॉल्ट नाम = "जॉन डो";
कॉन्स्ट परिणाम_1 = नाम?? डिफ़ॉल्ट नाम;
सांत्वना देनालॉग (परिणाम_1); // "जॉन डो"


कॉन्स्ट उम्र = 0;
कॉन्स्ट डिफ़ॉल्ट आयु = 25;
कॉन्स्ट परिणाम_2 = आयु?? डिफ़ॉल्ट आयु;
सांत्वना देनालॉग (परिणाम_2); // 0

उपरोक्त उदाहरण में, परिणाम_1 "जॉन डो" लौटाता है क्योंकि पहले ऑपरेंड का मान था व्यर्थ. परिणाम_2 रिटर्न 0 क्योंकि, हालांकि यह एक झूठा मूल्य है, यह दोनों में से कोई भी नहीं है व्यर्थ और न अपरिभाषित.

अपने कोड में लॉजिकल ऑपरेटर्स का उपयोग करना

तार्किक ऑपरेटरों का उपयोग आमतौर पर सशर्त बयान लिखने, डिफ़ॉल्ट मान निर्दिष्ट करने, या शर्तों के आधार पर बूलियन मानों को टॉगल करने के लिए किया जाता है।

इन तार्किक ऑपरेटरों का उपयोग करके, आप अधिक संक्षिप्त और अभिव्यंजक कोड लिख सकते हैं जो मूल्यों की सत्यता या असत्यता के आधार पर विभिन्न परिदृश्यों को संभालता है।