तुलना में

तुलना के बारे में

संख्याओं की तुलना

JavaScript में संख्याओं की तुलना नीचे दिए गए संबंधवाचक और समानता वाले ऑपरेटरों से की जा सकती है।

तुलना का परिणाम हमेशा एक बूलियन वैल्यू होता है, यानी या तो true या false।

1 < 3;
// => true

2 !== 2;
// => false

1 === 1.0;
// => true
// All numbers are floating-points, so this is different syntax
// for the exact same value.

स्ट्रिंग की तुलना

JavaScript में ऊपर दिए गए ऑपरेटरों का उपयोग स्ट्रिंग की तुलना करने के लिए भी किया जा सकता है। ऐसी स्थिति में डिक्शनरी (लेक्सिकोग्राफिक) क्रम लागू होता है। सभी अक्षरों के ठीक क्रम की सूची आप यहाँ देख सकते हैं।

'Apple' > 'Pear';
// => false

'a' < 'above';
// => true

'a' === 'A';
// => false

जब आप ऐसे दो वेरिएबल की तुलना करते हैं जिनमें संख्यात्मक वैल्यू दिखती हैं, लेकिन उनका डेटा टाइप स्ट्रिंग है, तो सावधानी बरतनी ज़रूरी है। डिक्शनरी क्रम के कारण परिणाम वही नहीं होगा जो Number टाइप की वैल्यू की तुलना करने पर मिलता है।

10 < 2;
// => false

'10' < '2';
// => true (because "1" comes before "2")

स्ट्रिंग की तुलना करने का एक और तरीका localeCompare मेथड है। यह स्ट्रिंग की तुलना करने का तरीका बदलने के लिए कई तरह के विकल्प सेट करने देता है।

सख्त समानता

JavaScript में समानता जाँचने के लिए तीन बराबर के चिह्न क्यों होते हैं, यह सोचना स्वाभाविक है। === सख्त समानता की जाँच दर्शाता है, यानी कोई टाइप कन्वर्ज़न नहीं किया जाता और अलग-अलग टाइप की वैल्यू हमेशा असमान होती हैं।

'3' === 3;
// => false
// The value on the left has type string, the value on the right
// has type number.

1 === 1n;
// => false
// The value on the left has type number, the value on the right
// has type bigint.

JavaScript में समानता जाँचने का सुझाया गया तरीका === और !== का उपयोग करना है।

छिपे टाइप कन्वर्ज़न से बचना

== और != भी हैं, जो ढीली समानता की जाँच दर्शाते हैं। इनसे बचना चाहिए, क्योंकि तुलना करने से पहले ये छिपा हुआ टाइप कन्वर्ज़न लागू कर देते हैं। ऐसे मामलों के परिणाम का अनुमान लगाना मुश्किल होता है, और कभी-कभी वे वैसे नहीं होते जैसे आप सोचते हैं। इसके बारे में आप यहाँ और पढ़ सकते हैं।

0 == false;
// => true

सिद्धांत रूप में, आप अलग-अलग टाइप की वैल्यू की तुलना भी कर सकते हैं (जैसे "1" < 2)। तब यह तय करने के लिए कि परिणाम सही है या गलत, वैल्यू का छिपा हुआ कन्वर्ज़न कर दिया जाता है। ढीली समानता की जाँच की तरह, ऊपर बताए गए उसी कारण से यह भी सुझाया नहीं जाता।

तो इसके बजाय क्या करना चाहिए? आप स्पष्ट टाइप कन्वर्ज़न लागू कर सकते हैं। इससे आप तुलना करने से पहले यह सुनिश्चित कर सकते हैं कि वैल्यू का टाइप सही है। तब आपका कोड समझने में आसान और कम गलती वाला बनेगा।