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

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

जांचें कि आपको कितना समझ आया

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

===

==

=

!=