तुलना करने वाले ऑपरेटर दो ऑपरेंड के मानों की तुलना करते हैं और आकलन करते हैं कि
यह स्टेटमेंट true या false है. नीचे दिए गए उदाहरण में
दो ऑपरेंड: एक्सप्रेशन की तुलना करने के लिए, स्ट्रिक्ट इक्वलिटी ऑपरेटर (===)
2 + 2 और वैल्यू 4. क्योंकि एक्सप्रेशन और संख्या
मान 4 एक जैसा है, इस एक्सप्रेशन का आकलन true के रूप में होगा:
2 + 2 === 4
> true
टाइप पर दबाव और समानता
डेटा की तुलना करने के लिए, सबसे ज़्यादा इस्तेमाल किए जाने वाले दो ऑपरेटर हैं: ==
और सख्त बराबरी के लिए ===. == दो के बीच गैर-ज़रूरी तुलना करता है
अगर संभव हो, तो मेल खाने वाले डेटा टाइप में ऑपरेंड को जोड़कर वैल्यू का इस्तेमाल करें. इसके लिए
उदाहरण के लिए, 2 == "2", true दिखाता है, भले ही तुलना की जा रही हो
स्ट्रिंग वैल्यू और संख्या के बीच वैल्यू होती है.
2 == 2
> true
2 == "2"
> true
!= के लिए भी यही सही है, जो सिर्फ़ तब true दिखाता है, जब ऑपरेंड
की तुलना में, दोनों एक जैसे नहीं थे.
2 != 3
> true
2 != "2"
> false
=== या !== का इस्तेमाल करके की गई सख्त तुलनाएं, टाइप का दबाव नहीं डालती हैं.
true की तुलना करने के लिए एक सख्त तुलना, तुलना की जा रही वैल्यू में
एक ही तरह का डेटा टाइप. इस वजह से 2 == "2", true दिखाता है, लेकिन 2 === "2" दिखाता है
false दिखाता है:
2 === 3
> false
2 === "2"
> false
अपने-आप दबाव बनाने की वजह से हो सकने वाली किसी भी अस्पष्टता को हटाने के लिए, किसी भी समय === का इस्तेमाल करें
किया जा सकता है.
| ऑपरेटर | ब्यौरा | इस्तेमाल | नतीजा |
|---|---|---|---|
| === | पूरी तरह से बराबर | दो === | सही |
| !== | पूरी तरह से बराबर नहीं | 2 !== "2" | सही |
| == | बराबर (या "कम बराबर") | 2 == "2" | सही |
| != | बराबर नहीं है | 2 != "3" | सही |
| > | इससे ज़्यादा | 3 > 2 | सही |
| >= | इससे ज़्यादा या इसके बराबर | दो >= दो | सही |
| < | इससे कम | 2 < 3 | सही |
| <= | इससे कम या इसके बराबर | 2 <= तीन | सही |
सच और झूठ
JavaScript में सभी वैल्यू, इंप्लिसिट रूप से true या false होती हैं. साथ ही, इनके लिए बाध्य किया जा सकता है
मिलती-जुलती बूलियन वैल्यू—उदाहरण के लिए, "लोज़ली इक्वल" का इस्तेमाल करके
तुलना करने वाला. वैल्यू का सीमित सेट, false को लागू करता है:
0nullundefinedNaN- एक खाली स्ट्रिंग (
"")
अन्य सभी वैल्यू को true की जगह इस्तेमाल किया जाता है. इनमें एक या उससे ज़्यादा वैल्यू वाली स्ट्रिंग भी शामिल हैं
वर्ण और शून्य के अलावा अन्य नंबर. इन्हें आम तौर पर "सच" कहा जाता है और
"झूठी" वैल्यू.
"My string" == true
> true
100 == true
> true
0 == true
> false
तार्किक ऑपरेटर
दो या उससे ज़्यादा कंडीशनल स्टेटमेंट के आकलन के आधार पर, स्क्रिप्ट के फ़्लो को कंट्रोल करने के लिए लॉजिकल AND (&&), OR (||) और NOT (!) ऑपरेटर का इस्तेमाल करें:
2 === 3 || 5 === 5;
> true
2 === 2 && 2 === "2"
> false
2 === 2 && !"My string."
> false
एक लॉजिकल NOT (!) एक्सप्रेशन, किसी ऑपरेंड की सत्य या असत्य वैल्यू को नकार देता है. अगर ऑपरेंड का आकलन false तक होता है, तो true का मूल्यांकन करता है और अगर ऑपरेंड का आकलन true के रूप में होता है, तो false का मूल्यांकन किया जाता है:
true
> true
!true
> false
!false
> true
किसी दूसरे डेटा टाइप के सामने लॉजिकल NOT ऑपरेटर (!) का इस्तेमाल करना, जैसे कि
संख्या या स्ट्रिंग, उस वैल्यू को एक बूलियन मानकर बदलती है और सच्चाई को उलटा देती है या
नतीजे की गलत वैल्यू.
"string"
> "string"
!"string"
> false
0
> 0
!0
> true
डेटा को तुरंत अलग करने के लिए, दो NOT ऑपरेटर का इस्तेमाल करना आम बात है बूलियन मान से मेल खाता है:
!!"string"
> true
!!0
> false
लॉजिकल AND और OR ऑपरेटर अपने-आप कोई दबाव नहीं डालते हैं. वे चुने गए विकल्प के साथ मूल्यांकन किए जा रहे दो ऑपरेंड में से एक का मान दें उस आकलन के आधार पर तय किया गया ऑपरेंड.
लॉजिकल AND (&&) अपने दो ऑपरेंड में से पहला ऑपरेंड सिर्फ़ तब लौटाता है, जब वह ऑपरेंड
false का मूल्यांकन करता है और दूसरा ऑपरेंड. इसकी तुलना में
बूलियन वैल्यू का आकलन करता है, तो यह true सिर्फ़ तब रिटर्न करता है, जब ऑपरेंड को दोनों साइड में इस्तेमाल किया जाता है
लॉजिकल AND आकलन करें का true. अगर किसी भी पक्ष का आकलन false से होता है, तो
false दिखाता है.
true && false
> false
false && true
> false
false && false
> false
true && true
> true
जब && का इस्तेमाल दो नॉन-बूलियन ऑपरेंड के साथ किया जाता है, तो पहला ऑपरेंड लौटाया जाता है
अगर इसे false की तरह बनाया जा सकता है, तो कोई बदलाव नहीं किया जाएगा. अगर पहले ऑपरेंड के लिए दबाव बनाया जा सकता है, तो
true में, दूसरा ऑपरेंड बिना किसी बदलाव के दिखाया जाता है:
false && "My string"
> false
null && "My string"
> null
"My string" && false
> false
"My string" && "My second string"
> "My second string"
2 === 2 && "My string"
> "My string"
लॉजिकल OR (||) अपने दो ऑपरेंड में से पहला ऑपरेंड सिर्फ़ तब लौटाता है, जब वह ऑपरेंड
true का मूल्यांकन करता है और दूसरा ऑपरेंड. इसकी तुलना में
बूलियन वैल्यू का आकलन करता है, तो इसका मतलब है कि अगर कोई ऑपरेंड है, तो यह true दिखाता है
true का मूल्यांकन करता है और अगर किसी भी पक्ष का मूल्यांकन true के रूप में नहीं होता है, तो यह लौटाता है
false:
true || false
> true
false || true
> true
true || true
> true
false || false
> false
दो नॉन-बूलियन ऑपरेंड के साथ || का इस्तेमाल करने पर, यह पहला ऑपरेंड लौटाता है
अगर इसे true की तरह बनाया जा सकता है, तो कोई बदलाव नहीं किया जाएगा. अगर पहले ऑपरेंड के लिए दबाव बनाया जा सकता है, तो
false में, दूसरा ऑपरेंड बिना किसी बदलाव के दिखाया जाता है:
false || "My string"
> "My string"
null || "My string"
> "My string"
"My string" || false
> "My string"
"My string" || "My second string"
> "My string"
2 === 2 || "My string"
> true
शून्य कोलेसिंग ऑपरेटर
ES2020 में पेश किया गया,
"शून्य कोलेसिंग ऑपरेटर" (??) पहला ऑपरेंड सिर्फ़ तब दिखाता है, जब
ऑपरेंड में null या undefined के अलावा कोई भी मान होता है. ऐसा न करने पर, यह वापस आ जाता है
दूसरा ऑपरेंड.
null ?? "My string"
> "My string"
undefined ?? "My string"
> "My string"
true ?? "My string";
> true
?? लॉजिकल OR के जैसा है, लेकिन पहला ऑपरेंड जितना सख्त है
मूल्यांकन किया गया. || किसी भी एक्सप्रेशन के लिए दूसरा ऑपरेंड लौटाता है
undefined और null को मिलाकर false किया गया. ?? सेकंड वैल्यू दिखाता है
जब पहला ऑपरेंड, null या undefined के अलावा कुछ भी होता है, भले ही वह
बाध्य करके false किया जा सकता है:
0 ?? "My string";
> 0
false ?? "My string";
> false
undefined ?? "My string";
> "My string"
लॉजिकल असाइनमेंट ऑपरेटर
पहले ऑपरेटर को दूसरे ऑपरेटर का मान असाइन करने के लिए असाइनमेंट ऑपरेटर का इस्तेमाल करें
ऑपरेटर का इस्तेमाल करें. इसका सबसे सामान्य उदाहरण, सिंगल बराबर का निशान (=) है, जिसका इस्तेमाल इन कामों के लिए किया जाता है
घोषित वैरिएबल के लिए वैल्यू असाइन करें.
किसी वैरिएबल को शर्त के साथ मान असाइन करने के लिए, लॉजिकल असाइनमेंट ऑपरेटर का इस्तेमाल करना उस वैरिएबल की सही या गलत वैल्यू पर आधारित होना.
लॉजिकल AND असाइनमेंट (&&=) ऑपरेटर दूसरे ऑपरेंड का आकलन करता है और
पहले ऑपरेंड को असाइन करता है, अगर केवल तभी जब पहला ऑपरेंड
true—इस तरह से, "अगर पहला ऑपरेंड सही है, तो इसे
दूसरा ऑपरेंड:"
let myVariable = false;
myVariable &&= 2 + 2;
> false
myVariable = true;
myVariable &&= 2 + 2;
> 4
पहले ऑपरेंड की सही या गलत वैल्यू से यह तय होता है कि कोई असाइनमेंट
किया जाता है. हालांकि, तुलना का इस्तेमाल करके पहले ऑपरेंड का आकलन करने की कोशिश करना
ऑपरेटर के नतीजे में true या false बूलियन होता है, जिसे असाइन नहीं किया जा सकता
मान:
let myVariable = 5;
myVariable > 2 &&= "My string"
> SyntaxError: Invalid left-hand side in assignment
लॉजिकल OR असाइनमेंट (||=) ऑपरेटर, दूसरे ऑपरेंड का आकलन करता है और
अगर पहले ऑपरेंड का आकलन false से होता है, तो पहले ऑपरेंड को असाइन करें—
"अगर पहला ऑपरेंड गलत है, तो उसे दूसरे
इसके बजाय ऑपरेंड:"
let myVariable = false;
myVariable ||= 2 + 2;
> 4
myVariable = true;
myVariable ||= 2 + 2;
> true
देखें कि आपको कितना समझ आया है
कौनसा ऑपरेटर "पूरी तरह बराबर" दिखाता है?
======!=