तुलना ऑपरेटर और लॉजिकल ऑपरेटर — JavaScript

यह क्या है और क्यों?

कल्पना करो कि तुम एक रोबोट हो जो आदेशों का पालन करता है। निर्णय लेने के लिए, तुम्हें चीजों की तुलना करने और शर्तों की जाँच करने में सक्षम होना चाहिए। उदाहरण के लिए:

• तुलना: "क्या तुम्हारे पास 100 रुपये हैं?" (तुम अपने पैसे की संख्या 100 से तुलना कर रहे हो)।
• तर्क: "क्या तुम्हारे पास 100 रुपये हैं और तुम भूखे नहीं हो?" (एक साथ दो शर्तों की जाँच कर रहे हो)।

JavaScript में, तुलना ऑपरेटर और लॉजिकल ऑपरेटर कंप्यूटर को ऐसे सवालों के जवाब देने में मदद करते हैं। परिणाम हमेशा true (सत्य) या false (असत्य) होगा। यह एक ट्रैफिक लाइट की तरह है: हरा - तुम जा सकते हो (true), लाल - रुको (false)।

इसकी आवश्यकता क्यों है? इनके बिना प्रोग्राम उबाऊ होंगे - वे बस क्रम से आदेशों को निष्पादित करेंगे। लेकिन इनके साथ, प्रोग्राम विभिन्न स्थितियों पर प्रतिक्रिया कर सकता है: उदाहरण के लिए, यदि उपयोगकर्ता ने सही पासवर्ड डाला है - तो उसे अंदर जाने दें, यदि नहीं - तो एक त्रुटि दिखाएँ।

Python में, ये ऑपरेटर लगभग उसी तरह काम करते हैं, लेकिन JavaScript में अपनी-अपनी ख़ासियतें हैं। हम उन्हें समझेंगे।

स्पष्टीकरण के साथ कोड उदाहरण

1. बुनियादी तुलना ऑपरेटर: >, <, >=, <=

सबसे सरल - जैसे गणित के पाठ में। संख्याओं की तुलना करना:

// उदाहरण 1: बड़ा या छोटा?
let आयु = 12;
let प्रवेश_संभव = आयु >= 12; // क्या प्रवेश संभव है यदि आयु 12 या अधिक है?
console.log(प्रवेश_संभव); // आउटपुट: true (क्योंकि 12 >= 12 — सत्य)

// उदाहरण 2: सीमा से तुलना
let तापमान = 30;
let गर्मी = तापमान > 25;   // क्या 25 से अधिक है?
console.log(गर्मी); // true (30 > 25 — सत्य)

let सर्दी = तापमान < 10; // क्या 10 से कम है?
console.log(सर्दी); // false (30, 10 से कम नहीं है)

// उदाहरण 3: स्ट्रिंग्स की भी तुलना की जा सकती है!
console.log("तरबूज" > "केला"); // false
// क्यों? अक्षरों की तुलना वर्णमाला क्रम से की जाती है: 'त' (पहला अक्षर) 'क' (दूसरे अक्षर) से बड़ा नहीं है
// Python में भी ऐसा ही है, लेकिन वहाँ केस सेंसिटिविटी अलग है

महत्वपूर्ण: JavaScript में, स्ट्रिंग्स की तुलना Unicode कोड (जैसे एक तालिका में) के आधार पर की जाती है। 'अ' 'आ' से छोटा है, और 'A' 'a' से छोटा है। यह एक शब्दकोश की तरह है: पहले बड़े अक्षर आते हैं, फिर छोटे अक्षर।

2. समानता ऑपरेटर: == और ===

यहाँ सबसे दिलचस्प शुरू होता है! JavaScript में यह जाँचने के दो तरीके हैं कि मान समान हैं या नहीं:

• == — "असख्त समानता" (मानों की तुलना करता है, लेकिन प्रकारों को परिवर्तित कर सकता है)
• === — "सख्त समानता" (मान और डेटा प्रकार दोनों की तुलना करता है)

// उदाहरण 4: संख्याओं और स्ट्रिंग्स की तुलना
let संख्या = 5;
let स्ट्रिंग = "5";

console.log(संख्या == स्ट्रिंग);   // true — क्योंकि 5, 5 के बराबर है (JavaScript ने स्ट्रिंग को संख्या में बदल दिया)
console.log(संख्या === स्ट्रिंग);  // false — क्योंकि संख्या (number) स्ट्रिंग (string) के बराबर नहीं है!

// Python में ऐसा नहीं है: "5" == 5 तुरंत False देगा, बिना रूपांतरण के

// उदाहरण 5: true/false से तुलना
console.log(1 == true);  // true — क्योंकि true को 1 में बदल दिया जाता है
console.log(1 === true); // false — अलग-अलग प्रकार (संख्या बनाम boolean)

console.log(0 == false); // true
console.log(0 === false); // false

// उदाहरण 6: खाली मान
console.log(null == undefined); // true — JS का विशेष नियम
console.log(null === undefined); // false — अलग-अलग प्रकार

// Python में undefined नहीं है, केवल None है, और वह अपने अलावा किसी और चीज़ के बराबर नहीं है

शुरुआती लोगों के लिए सलाह: आश्चर्य से बचने के लिए हमेशा === (सख्त समानता) का उपयोग करें। यह गणित की तरह है: 5 और "5" अलग-अलग चीज़ें हैं, भले ही वे समान दिखते हों।

3. लॉजिकल ऑपरेटर && (AND)

"AND" ऑपरेटर केवल तभी true लौटाता है जब दोनों शर्तें सत्य हों। जीवन में यह ऐसा है: "मैं टहलने जाऊँगा यदि मैं अपना होमवर्क कर लूँ और माँ अनुमति दें"।

// उदाहरण 7: दो शर्तों की जाँच
let आयु = 14;
let है_टिकट = true;

let सिनेमा_जा_सकता = (आयु >= 12) && (है_टिकट === true);
console.log(सिनेमा_जा_सकता); // true — आयु उपयुक्त है और टिकट भी है

// यदि आयु 10 होती:
आयु = 10;
सिनेमा_जा_सकता = (आयु >= 12) && (है_टिकट === true);
console.log(सिनेमा_जा_सकता); // false — पहली शर्त गलत है, दूसरी सही है, लेकिन AND को दोनों चाहिए

// उदाहरण 8: जटिल शर्त
let ग्रेड = 4;
let व्यवहार = "उत्कृष्ट";

let प्रशंसा_मिलेगी = (ग्रेड === 5) && (व्यवहार === "उत्कृष्ट");
console.log(प्रशंसा_मिलेगी); // false — ग्रेड 5 नहीं है, हालाँकि व्यवहार उत्कृष्ट है

// Python में इसे ऐसे लिखा जाता है: and

टिप: JavaScript "आलसी" है - यदि && में पहली शर्त गलत है, तो वह दूसरी की जाँच भी नहीं करता। इसे "शॉर्ट सर्किट" कहते हैं। समय बचाएँ!

4. लॉजिकल ऑपरेटर || (OR)

"OR" ऑपरेटर true लौटाता है यदि कम से कम एक शर्त सत्य हो। जीवन में ऐसा: "मैं टहलने जाऊँगा यदि मैं अपना होमवर्क कर लूँ या यदि बाहर धूप हो"।

// उदाहरण 9: दो विकल्पों में से चुनाव
let है_पैसे = false;
let है_उपहार = true;

let खिलौना_खरीद_सकता = है_पैसे || है_उपहार;
console.log(खिलौना_खरीद_सकता); // true — पैसे नहीं हैं, लेकिन उपहार है (एक शर्त सत्य है)

// उदाहरण 10: आयु की जाँच
let उपयोगकर्ता_आयु = 17;
let प्रवेश_अनुमति = (उपयोगकर्ता_आयु >= 18) || (उपयोगकर्ता_आयु >= 16 && है_टिकट);
// यदि आयु >=18 या (आयु >=16 और टिकट है)
console.log(प्रवेश_अनुमति); // false — 17, >=18 नहीं है, और हालाँकि 17>=16 है, लेकिन है_टिकट परिभाषित नहीं है (undefined — यह false है)

// उदाहरण 11: डिफ़ॉल्ट मान
let नाम = "";
let प्रदर्शित_नाम = नाम || "अतिथि";
console.log(प्रदर्शित_नाम); // "अतिथि" — क्योंकि खाली स्ट्रिंग को false माना जाता है

// Python में: नाम or "अतिथि" — उसी तरह काम करता है

ट्रिक: || भी "आलसी" है - यदि पहली शर्त सत्य है, तो दूसरी की जाँच नहीं की जाती। इसका उपयोग डिफ़ॉल्ट मान सेट करने के लिए किया जाता है।

5.