तुलना करने वाले ऑपरेटर, दो ऑपरेंड की वैल्यू की तुलना करते हैं और यह आकलन करते हैं कि उनसे बनाया गया स्टेटमेंट, 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 == "2" | सही |
!= | बराबर नहीं है | 2 != "3" | सही |
> | इससे ज़्यादा | 3 > 2 | सही |
>= | इससे ज़्यादा या इसके बराबर | 2 >= 2 | सही |
< | इससे कम | 2 < 3 | सही |
<= | इससे कम या इसके बराबर | 2, 3 या 3 से कम | सही |
सच और झूठ
JavaScript में सभी वैल्यू इंप्लिसिट तौर पर true
या false
होती हैं और उन्हें संबंधित बूलियन वैल्यू के साथ लागू किया जा सकता है—उदाहरण के लिए, "लूज़ली बराबर" तुलना करने वाली वैल्यू का इस्तेमाल करके. वैल्यू का सीमित सेट false
के लिए लागू है:
0
null
undefined
NaN
- खाली स्ट्रिंग (
""
)
अन्य सभी वैल्यू, 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 की तरह है. हालांकि, पहले ऑपरेंड के आकलन के तरीके में यह ज़्यादा सख्त है. ||
ऐसे किसी भी एक्सप्रेशन के लिए दूसरा ऑपरेंड दिखाता है जिसे
false
लागू किया जा सकता है. इसमें undefined
और null
भी शामिल हैं. जब पहला ऑपरेंड 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
जांचें कि आपको कितना समझ आया
कौनसा ऑपरेटर "पूरी तरह बराबर" दिखाता है?
===
==
=
!=