ऑपरेटर और तुलना

docs.scrimba.com

मान लीजिए कि आप एक खरीदारी कार्ट को ट्रैक कर रहे हैं। आप कीमतों को जोड़ते हैं, एक छूट लागू करते हैं, जांचते हैं कि क्या कुल मुफ्त शिपिंग सीमा को पार करता है, और तय करते हैं कि जब कार्ट खाली हो तो एक चेतावनी दिखानी है या नहीं। उन चरणों में से प्रत्येक एक ऑपरेटर का काम है: एक प्रतीक जो एक या दो मानों को लेता है और एक नया मान बनाता है। यह अध्याय उन ऑपरेटरों को कवर करता है जिन्हें आप लगातार उपयोग करते हैं, संख्याओं पर अंकगणित करने से लेकर मानों की तुलना करने और सत्य-या-असत्य परीक्षणों को संयोजित करने तक।

अंकगणित और असाइनमेंट

अंकगणितीय ऑपरेटर वह गणित करते हैं जो आप पहले से जानते हैं: + जोड़ता है, - घटाता है, * गुणा करता है, / भाग देता है। एक और है जो आपने नहीं देखा हो सकता: %, शेषफल ऑपरेटर, जो आपको विभाजन के बाद बचा हुआ देता है।

const total = 8 + 5; // 13
const change = 20 - 13; // 7
const leftover = 17 % 5; // 2, क्योंकि 5 17 में तीन बार जाता है 2 बचा हुआ
console.log(total); // 13

जब आप किसी मान को स्वयं के आधार पर अपडेट करना चाहते हैं, तो एक शॉर्टहैंड है। score = score + 10 लिखने के बजाय, आप score += 10 लिख सकते हैं। इसका मतलब एक जैसा है: वर्तमान मान लें, 10 जोड़ें, परिणाम को वापस संग्रहीत करें।

let score = 100;
score += 10; // score अब 110 है
score -= 30; // score अब 80 है
console.log(score); // 80

और एक संख्या को बिल्कुल एक से ऊपर या नीचे ले जाने के लिए, ++ और -- इसे एक ही चरण में करते हैं। count++ एक जोड़ता है, count-- एक हटाता है।

let lives = 3;
lives--; // lives अब 2 है
console.log(lives); // 2

अंकगणितीय ऑपरेटर +, -, *, /, और % हैं। पहले चार परिचित हैं; % वह है जो दूसरी नज़र के लायक है। यह विभाजन का शेषफल देता है, जो इसे "क्या यह समान रूप से विभाजित है?" जांचों के लिए और किसी मान को एक सीमा के भीतर वापस लपेटने के लिए मानक उपकरण बनाता है।

const isEven = 10 % 2; // 0, तो 10 सम है
const isOdd = 7 % 2; // 1, तो 7 विषम है
console.log(isEven); // 0

किसी मान को स्वयं से अपडेट करना काफी आम है कि इसके लिए शॉर्टहैंड हैं। प्रत्येक अंकगणितीय ऑपरेटर = के साथ युग्मित होता है एक मिश्रित असाइनमेंट बनाने के लिए: +=, -=, *=, /=, %=। तो price *= 1.2 का अर्थ है "price को 1.2 से गुणा करें और इसे वापस संग्रहीत करें", जो आपको price = price * 1.2 लिखने से बचाता है।

let price = 40;
price *= 1.2; // 20 प्रतिशत जोड़ें, price अब 48 है
price -= 8; // price अब 40 है
console.log(price); // 40

बिल्कुल एक के परिवर्तन के लिए, ++ और -- जगह में वृद्धि और कमी करते हैं। वे पठनीय दिखते हैं जब आप एक काउंटर को आगे बढ़ा रहे हैं, और आप उन्हें लगातार देखेंगे।

let attempts = 0;
attempts++; // attempts अब 1 है
console.log(attempts); // 1

अंकगणितीय ऑपरेटर चार बुनियादी लोगों के लिए कम आश्चर्य रखते हैं, इसलिए जिन दोनों को वास्तविक ध्यान देने की आवश्यकता है वे % और + ओवरलोड हैं। शेषफल ऑपरेटर % पूर्णांक-शैली विभाजन के बाद छोड़ा गया भाग देता है, और यह बाएं ऑपरेंड का संकेत रखता है: -7 % 3 -1 है, 2 नहीं, जो उन लोगों को परेशान करता है जो गणितीय मॉड्यूलो की अपेक्षा करते हैं। यह विभाजनशीलता परीक्षणों के लिए और एक सीमा के भीतर एक सूचकांक को लपेटने के लिए आपका जाने-पहचाने टूल है।

const remainder = 17 % 5; // 2
const negative = -7 % 3; // -1, संकेत बाएं ऑपरेंड को अनुसरण करता है
console.log(negative); // -1

+ ऑपरेटर अधिभारित है: दो संख्याओं के साथ यह जोड़ता है, लेकिन अगर कोई भी पक्ष एक स्ट्रिंग है तो यह जोड़ता है, दूसरे पक्ष को एक स्ट्रिंग में जबरदस्ती करता है। वह एकल नियम पूरी कक्षा के आश्चर्य के पीछे है, इसलिए जोड़ने से पहले नाम दें कि आपके पास क्या है।

const sum = 5 + 3; // 8
const glued = "5" + 3; // "53", 3 एक स्ट्रिंग बन गया
console.log(glued); // 53

मिश्रित असाइनमेंट (+=, -=, *=, /=, %=) किसी बंधन को स्वयं से अपडेट करने का मुहावरेदार तरीका है, और यह एक ही + ओवरलोड को विरासत में देता है: msg += count को count को स्ट्रिंगीफाई करता है। वृद्धि और कमी ऑपरेटर ++ और -- उपसर्ग और प्रत्यय दोनों रूपों में आते हैं जो अभिव्यक्ति के लिए वापसी मूल्य में भिन्न होते हैं: x++ पुरानी मान का मूल्यांकन करता है फिर वृद्धि करता है, ++x वृद्धि करता है फिर नई मान का मूल्यांकन करता है। एक अभिव्यक्ति में जो अंतर काटता है, इसलिए उन्हें अपने स्वयं के कथन पर रखें जहां अंतर मायने नहीं रखता। ऐसा कुछ भी let का उपयोग करें जिसे आप इस तरीके से पुनः असाइन करते हैं, क्योंकि const बंधन को अपडेट नहीं किया जा सकता है।

let counter = 5;
const before = counter++; // before 5 है, counter अब 6 है
const after = ++counter; // after 7 है, counter अब 7 है
console.log(`${before} ${after}`); // 5 7

Junoअंकगणित और असाइनमेंट गणित के ऑपरेटर वह हैं जिनकी आप अपेक्षा करते हैं, साथ ही विभाजन के बाद शेषफल के लिए %। जब आप किसी मान को स्वयं से अपडेट करते हैं, तो शॉर्टहैंड के लिए पहुंचें: score += 10 score = score + 10 के बजाय। और ++ या -- एक संख्या को एक से ऊपर या नीचे ले जाता है। मुझे इन पर विश्वास करने में कुछ समय लगा, लेकिन वे समान गणित हैं जो छोटे लिखी गई हैं।

Junoअंकगणित और असाइनमेंट पांच अंकगणितीय ऑपरेटर, और शेषफल के लिए % वह है जो विभाजनशीलता जांचों में अपना वजन कमाता है। price *= 1.2 जैसा मिश्रित असाइनमेंट एक मान को एक ही चाल में स्वयं से अपडेट करता है, और ++ या -- एक से आगे बढ़ता है। ऐसा कुछ भी let का उपयोग करें जिसे आप इस तरीके से अपडेट करने की योजना बनाते हैं, क्योंकि एक const को पुनः असाइन नहीं किया जा सकता।

Junoअंकगणित और असाइनमेंट दो चीजों को तीव्र रखें: % बाएं ऑपरेंड का संकेत रखता है, इसलिए -7 % 3 -1 है, और + जोड़ता है जिस क्षण कोई भी पक्ष एक स्ट्रिंग है। उपसर्ग बनाम प्रत्यय ++ अलग-अलग मान देते हैं, इसलिए उन्हें अपने स्वयं के कथन पर रखें जहां यह काट सके। अंकगणितीय ऑपरेटरों का बाकी हिस्सा बिल्कुल वैसे व्यवहार करता है जैसे आप अनुमान लगाएंगे।

तुलना

एक तुलना दो मानों के बारे में एक प्रश्न पूछता है और true या false के साथ उत्तर देता है। वह सत्य-या-असत्य उत्तर बूलियन हैं, और यह वही है जो आपका प्रोग्राम बाद में निर्णय लेने के लिए उपयोग करता है।

तुलना जिसे आप सबसे अधिक उपयोग करेंगे वह === है, जो पूछता है "क्या ये दोनों बिल्कुल बराबर हैं?"

const answer = 42;
console.log(answer === 42); // true
console.log(answer === 7); // false

इसका विपरीत !== है, जो पूछता है "क्या ये दोनों अलग-अलग हैं?" और क्रम के लिए <, >, <=, और >= हैं, जो गणित में काम करते हैं: कम से कम, अधिक से अधिक, कम से कम या बराबर, अधिक से अधिक या बराबर।

const age = 18;
console.log(age >= 18); // true
console.log(age !== 21); // true

हमेशा === के साथ तुलना करें, कभी == नहीं। दोहरे-बराबर संस्करण में एक अजीबोगरीब है जो लोगों को आश्चर्यचकित करता है, और ट्रिपल-बराबर संस्करण हर बार वह करता है जो आप अपेक्षा करते हैं।

एक तुलना दो मान लेता है और एक बूलियन, true या false देता है। वह बूलियन शर्तों में आप जो निर्णय लिखेंगे उसका कच्चा माल है, इसलिए तुलना सही होना मायने रखता है।

समानता के लिए === का उपयोग करें और असमानता के लिए !==। क्रम के लिए <, >, <=, और >= हैं।

const stock = 3;
console.log(stock === 0); // false
console.log(stock > 0); // true
console.log(stock <= 5); // true

== के बजाय === के लिए पहुंचने का कारण यह है कि वे एक ही ऑपरेटर नहीं हैं। === (सख्त समानता) मान और प्रकार दोनों की तुलना करता है, केवल true देता है जब वे मेल खाते हैं। == (ढीली समानता) पहले दोनों पक्षों को एक सामान्य प्रकार में परिवर्तित करता है और फिर तुलना करता है, जो लगभग कोई भी पूर्वानुमान नहीं लगाता परिणाम देता है।

console.log(0 == ""); // true, और शायद ही कभी जो आप चाहते हैं
console.log("1" == 1); // true, स्ट्रिंग एक संख्या बन गई
console.log("1" === 1); // false, अलग-अलग प्रकार

हर बार === और !== को डिफ़ॉल्ट करें। वे परिवर्तन के बिना तुलना करते हैं, इसलिए आपको कभी भी परिवर्तन नियमों के बारे में तर्क नहीं देना पड़ता है। == को पुरानी कोड पढ़ने के लिए बचाएं, नई कोड लिखने के लिए नहीं।

एक तुलना एक बूलियन देता है, और ऑपरेटर दो परिवारों में विभाजित होते हैं: समानता (===, !==) और संबंधपरक (<, >, <=, >=)। संबंधपरक लोग संख्याओं पर सीधे हैं। समानता वाले वह हैं जहां असली निर्णय रहता है, क्योंकि JavaScript आपको उनमें से दो देता है।

=== (सख्त समानता) केवल true देता है जब दोनों ऑपरेंड एक प्रकार और एक मान साझा करते हैं, कोई परिवर्तन के बिना। == (ढीली समानता) एक सार-समानता एल्गोरिदम चलाता है जो पहले ऑपरेंड को एक सामान्य प्रकार की ओर जबरदस्ती करता है, और व्यावहारिक नियम पुरानी कोड पढ़ने के लिए जानने लायक हैं: एक संख्या और एक स्ट्रिंग की तुलना स्ट्रिंग को एक संख्या में परिवर्तित करता है ("1" == 1 true है); एक बूलियन की किसी भी चीज़ से तुलना पहले बूलियन को एक संख्या में परिवर्तित करता है (true == 1, false == 0); null == undefined true है लेकिन न ही कुछ और के बराबर है; और NaN कुछ के बराबर नहीं है, अपने आप को भी नहीं।

console.log(0 == ""); // true, "" 0 बन जाता है
console.log("1" == 1); // true, "1" 1 बन जाता है
console.log(null == undefined); // true, एक विशेष मामला
console.log(NaN === NaN); // false, NaN कभी किसी चीज़ के बराबर नहीं है

=== और !== का उपयोग करें; == को केवल-पढ़ने वाला ज्ञान मानें। मुख्य बात हर जबरदस्ती पथ को याद रखना नहीं है, यह उन्हें दरकिनार करना है: सख्त समानता में कोई जबरदस्ती नहीं है, इसलिए इसका परिणाम ऑपरेंड से सीधे पढ़ता है। एक जगह जहां == का उल्लेख कमाता है वह null == undefined जांच है, जिसे कुछ कोडबेस जानबूझकर दोनों शून्य मान को एक बार में पकड़ने के लिए उपयोग करते हैं, लेकिन इस अध्याय में बाद में शून्य ऑपरेटर वह कार्य अधिक स्पष्ट रूप से करते हैं।

Junoतुलना एक तुलना दो मानों के बारे में एक हां-या-नहीं प्रश्न पूछता है और true या false के साथ उत्तर देता है। समानता जांचने के लिए === का उपयोग करें, "अलग" के लिए !==, और क्रम के लिए <, >, <=, >=। === रखें और == को छोड़ दें, क्योंकि दोहरा संस्करण इसमें एक आश्चर्य है और ट्रिपल संस्करण व्यवहार करता है।

Junoतुलना हर तुलना आपको एक बूलियन देती है, जो अगला निर्णय लिखने के लिए ईंधन है। === मान और प्रकार को एक साथ जांचता है; == पहले पक्षों को परिवर्तित करता है और 0 == "" true होने जैसी विचित्रताएं पैदा करता है। === और !== को डिफ़ॉल्ट करें ताकि आप कभी भी परिवर्तन के बारे में तर्क न दें, और पुरानी कोड पढ़ने के लिए == छोड़ दें।

Junoतुलना सख्त समानता कोई जबरदस्ती के बिना प्रकार और मान की तुलना करता है, इसलिए इसका उत्तर ऑपरेंड से सीधे पढ़ता है। ढीली == आपकी पीठ के पीछे एक परिवर्तन एल्गोरिदम चलाता है, जो इसलिए है कि "1" == 1 true है और NaN बिल्कुल कुछ के बराबर नहीं है। === और !== लिखें और जबरदस्ती नियमों को पुरानी कोड के लिए केवल-पढ़ने वाले ज्ञान के रूप में रखें।

तार्किक ऑपरेटर और सत्यता

अक्सर आपको एक से अधिक तुलना को संयोजित करने की आवश्यकता होती है। तार्किक ऑपरेटर आपको ऐसा करने देते हैं: && (और), || (या), और ! (नहीं)।

&& केवल true है जब दोनों पक्ष true हैं। || true है जब कम से कम एक पक्ष true है। ! एक बूलियन को इसके विपरीत में पलट देता है।

const age = 20;
const hasTicket = true;
console.log(age >= 18 && hasTicket); // true, दोनों सत्य हैं
console.log(age < 13 || hasTicket); // true, एक पक्ष काफी है
console.log(!hasTicket); // false, पलटा

एक संबंधित विचार को सत्य और असत्य कहा जाता है। एक सत्य-या-असत्य सेटिंग में, JavaScript कुछ गैर-बूलियन मानों को मानता है जैसे वे false थे। असत्य मान false, 0, "" (एक खाली स्ट्रिंग), null, undefined, और NaN हैं। बाकी सब कुछ सत्य गिना जाता है।

const name = "";
console.log(!name); // true, एक खाली स्ट्रिंग असत्य है

तार्किक ऑपरेटर बूलियन मानों को संयोजित करते हैं: && (और) केवल true है जब दोनों ऑपरेंड true हैं, || (या) true है जब कम से कम एक है, और ! (नहीं) एक एकल बूलियन को व्युत्क्रम करता है।

const loggedIn = true;
const isAdmin = false;
console.log(loggedIn && isAdmin); // false, दोनों सत्य होने चाहिए
console.log(loggedIn || isAdmin); // true, एक काफी है
console.log(!isAdmin); // true

ऑपरेटर वास्तविक बूलियन पर नहीं रुकते हैं, क्योंकि JavaScript हर मान को सत्य या असत्य में सॉर्ट करता है। असत्य सेट कम है और याद रखने लायक है: false, 0, "", null, undefined, और NaN। बाकी सब कुछ सत्य है, जिसमें "0", "false", और कोई भी गैर-खाली स्ट्रिंग शामिल है। यह वही है जो आपको !username जैसी जांच लिखने देता है अर्थ "कोई उपयोगकर्ता नाम नहीं दर्ज किया गया था"।

const username = "";
console.log(!username); // true, "" असत्य है
console.log(Boolean("hello")); // true, एक गैर-खाली स्ट्रिंग सत्य है

तार्किक ऑपरेटर &&, ||, और ! हैं, और मुख्य अंतर्दृष्टि यह है कि && और || बूलियन नहीं देते हैं। वे छोटी-सर्किट: प्रत्येक बाएं ऑपरेंड का मूल्यांकन करता है, और केवल दाएं का मूल्यांकन करता है अगर इसे करना पड़े, फिर एक वास्तविक ऑपरेंड देता है, जबरदस्ती true या false नहीं।

a || b a देता है अगर a सत्य है, अन्यथा b। a && b a देता है अगर a असत्य है, अन्यथा b। वह व्यवहार असत्य सेट को रेखांकित करता है: false, 0, "", null, undefined, और NaN छह असत्य मान हैं, और बाकी सब कुछ सत्य है।

const name = "";
const display = name || "Guest"; // "Guest", क्योंकि "" असत्य है
const label = "Raj" && "active"; // "active", बाएं सत्य है तो यह दाएं देता है
console.log(display); // Guest

|| डिफ़ॉल्ट ट्रिक का एक तीव्र किनारा है, जो इसलिए है ?? (शून्य संयोजन) मौजूद है। || जब भी बाएं पक्ष कोई भी असत्य मान हो तो वापस आता है, इसलिए 0 || 10 10 है और "" || "n/a" "n/a" है, यहां तक कि जब 0 और "" मान्य इनपुट थे जिन्हें आप रखना चाहते थे। ?? केवल तब वापस आता है जब बाएं पक्ष null या undefined हो, 0 और "" को वास्तविक मान मानता है।

const count = 0;
console.log(count || 5); // 5, लेकिन 0 एक वास्तविक मान था
console.log(count ?? 5); // 0, ?? केवल null या undefined को प्रतिस्थापित करता है

जब आपको एक स्थिति के आधार पर दो मानों के बीच चुनना हो, तो एक पूर्ण तुलना साथ ही त्रिगुणात्मक (condition ? whenTrue : whenFalse) एक-पंक्ति रूप है, उदाहरण के लिए age >= 18 ? "adult" : "minor"। यह एक पूर्वदर्शन है; शर्तें अध्याय इसे और if कथन को पूरी तरह से कवर करता है।

Junoतार्किक ऑपरेटर और सत्यता&& "दोनों" है, || "दोनों में से कोई" है, और ! एक बूलियन को पलटता है। इसके ऊपर, JavaScript कुछ मानों को असत्य मानता है: false, 0, "", null, undefined, और NaN असत्य लोग हैं, और बाकी सब कुछ सत्य है। यह वही है जो !name को "कोई नाम नहीं दिया गया था" के लिए खड़े होने देता है।

Junoतार्किक ऑपरेटर और सत्यता&& को दोनों पक्षों को सत्य की आवश्यकता है, || को एक की आवश्यकता है, और ! व्युत्क्रम करता है। हर मान भी या तो सत्य या असत्य है, और असत्य सेट याद रखने के लिए काफी छोटा है: false, 0, "", null, undefined, NaN। ध्यान दें कि "0" और "false" स्ट्रिंग हैं, इसलिए दोनों सत्य हैं।

Junoतार्किक ऑपरेटर और सत्यता&& और || छोटी-सर्किट करते हैं और एक ऑपरेंड देते हैं, एक बूलियन नहीं, जो इसलिए है name || "Guest" एक डिफ़ॉल्ट के रूप में काम करता है। उस डिफ़ॉल्ट का एक किनारा है: || हर असत्य मान को प्रतिस्थापित करता है, इसलिए ?? का उपयोग करें जब 0 और "" इनपुट हैं जिन्हें आप रखना चाहते हैं। छह असत्य मान पूरी कहानी हैं, तो सेट को सीखें और बाकी पतन हो जाती है।

ऑपरेटर यहां से कहां जाते हैं

ऑपरेटर भाषा की क्रियाएं हैं: वे आप जो मान संग्रहीत करते हैं उन्हें परिणामों और निर्णयों में बदलते हैं। अंकगणित नई संख्याएं देता है, तुलना बूलियन देती है, और तार्किक ऑपरेटर उन बूलियन को हां-या-नहीं उत्तरों में संयोजित करते हैं जो आपका प्रोग्राम कार्य करता है।

वह बूलियन अपने आप पर बहुत कुछ नहीं करते हैं। अगला कदम उन्हें अपने कोड को स्टीयर करने के लिए उपयोग करना है, एक शाखा चलाना जब एक जांच पास होती है और दूसरी जब यह विफल होती है, जो शर्तें अध्याय के बारे में है। अगर यहां कोई भी मान अस्पष्ट लग रहा है, तो डेटा प्रकार अध्याय वह है जहां संख्याओं, स्ट्रिंग्स, और बूलियन को पूरा उपचार मिलता है।