कंपैरिज़न ऑपरेटर

कंपैरिज़न ऑपरेटर, दो ऑपरेंड की वैल्यू की तुलना करते हैं और यह आकलन करते हैं कि उनके बनाए गए स्टेटमेंट की वैल्यू 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	सही

Truey और falsy

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

लॉजिकल नॉट (!) एक्सप्रेशन, ऑपरेंड की सच्ची या गलत वैल्यू को बदल देता है. अगर ऑपरेंड की वैल्यू 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 ऑपरेटर, अपने-आप कोई दबाव नहीं डालते. ये फ़ंक्शन, जिन दो ऑपरेंड का आकलन किया जा रहा है उनमें से किसी एक की वैल्यू दिखाते हैं. यह वैल्यू, आकलन के आधार पर चुने गए ऑपरेंड की होती है.

लॉजिकल ऐंड (&&) अपने दो ऑपरेंड में से पहला ऑपरेंड सिर्फ़ तब दिखाता है, जब उस ऑपरेंड का वैल्यू false हो. अगर वैल्यू 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

देखें कि आपको क्या समझ आया

कौनसा ऑपरेटर "सटीक रूप से बराबर" दिखाता है?

===

==

=

!=