# जावास्क्रिप्ट मूल बातें - निर्णय लेना

![जावास्क्रिप्ट मूल बातें - निर्णय लेना](/sketchnotes/webdev101-js-decisions.png)
> [टोमोमी इमुरा](https://twitter.com/girlie_mac) द्वारा स्केचनेट

## पूर्व व्याख्यान प्रश्नोत्तरी
[पूर्व व्याख्यान प्रश्नोत्तरी](https://ashy-river-0debb7803.1.azurestaticapps.net/quiz/11?loc=hi)

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

[![निर्णय लेना](https://img.youtube.com/vi/SxTp8j-fMMY/0.jpg)](https://youtube.com/watch?v=SxTp8j-fMMY "निर्णय लेना")

> निर्णय लेने के बारे में वीडियो के लिए ऊपर दी गई छवि पर क्लिक करें।
## बूलियन्स पर एक संक्षिप्त पुनरावृत्ति

बूलियन केवल दो मूल्य हो सकते हैं: `true` या `false`। बूलियंस निर्णय लेने में मदद करते हैं कि किन शर्तों को पूरा करने पर कोड की लाइनें चलनी चाहिए।

इस तरह से सही या गलत होने के लिए अपना बूलियन सेट करें:

`let myTrueBool = true`
`let myFalseBool = false`

✅ बुलियन का नाम अंग्रेजी गणितज्ञ, दार्शनिक और तर्कशास्त्री जॉर्ज बोले (1815-1864) के नाम पर रखा गया है।

## तुलना ऑपरेटर और बूलियन

ऑपरेटर्स का उपयोग उन परिस्थितियों के मूल्यांकन के लिए किया जाता है जो एक बूलियन मूल्य बनाएंगे। निम्नलिखित ऑपरेटरों की एक सूची है जो अक्सर उपयोग की जाती हैं।

| प्रतीक  | विवरण                                                                                                  | उदाहरण              |
| ----- | ----------------------------------------------------------------------------------------------------- | ------------------ |
| `<`   | **से कम**: दो मानों की तुलना करता है और `true` बूलियन डेटा प्रकार लौटाता है यदि बाईं ओर का मान दाईं ओर से कम है                    | `5 < 6 // true`    |
| `<=`  | ** से कम या इसके बराबर**: दो मानों की तुलना करता है और `true` बूलियन डेटा प्रकार लौटाता है यदि बाईं ओर का मान दाईं ओर से कम या बराबर है | `5 <= 6 // true`   |
| `>`   | **से अधिक**: दो मानों की तुलना करता है और `true` बूलियन डेटा प्रकार लौटाता है यदि बाईं ओर का मान दाईं ओर से बड़ा है                   | `5 > 6 // false`   |
| `>=`  | **से अधिक या बराबर**: दो मानों की तुलना करता है और `true` बूलियन डेटा प्रकार देता है यदि बाईं ओर का मान righ से बड़ा या बराबर हैt      | `5 >= 6 // false`  |
| `===` | **सख्त समानता**: दो मूल्यों की तुलना करता है और `true` बूलियन डेटा प्रकार लौटाता है यदि दाएं और बाएं के मान समान हैं और समान डेटा प्रकार हैं। | `5 === 6 // false` |
| `!==` | **असमानता**: दो मूल्यों की तुलना करता है और एक सख्त समानता ऑपरेटर वापस आने के विपरीत बूलियन मूल्य लौटाता है                        | `5 !== 6 // true`  |

✅ अपने ब्राउज़र के कंसोल में कुछ तुलनाएँ लिखकर अपने ज्ञान की जाँच करें। क्या कोई लौटा डेटा आपको आश्चर्यचकित करता है?

## ऍफ़ स्टेटमेंट 

यदि ऍफ़ कथन सही है, तो स्टेटमेंट उसके ब्लॉक के बीच में कोड चलाएगा।

```javascript
if (condition){
    //Condition was true. Code in this block will run.
}
```

लॉजिकल ऑपरेटर्स का उपयोग अक्सर हालत बनाने के लिए किया जाता है.

```javascript
let currentMoney;
let laptopPrice;

if (currentMoney >= laptopPrice){
    //Condition was true. Code in this block will run.
    console.log("Getting a new laptop!");
}
```

## ऍफ़..ईलस स्टेटमेंट 

स्थिति के गलत होने पर `else` स्टेटमेंट उसके ब्लॉक के बीच कोड चलाएगा। यह `if` स्टेटमेंट के साथ वैकल्पिक है।

```javascript
let currentMoney;
let laptopPrice;

if (currentMoney >= laptopPrice){
    //Condition was true. Code in this block will run.
    console.log("Getting a new laptop!");
}
else{
    //Condition was true. Code in this block will run.
    console.log("Can't afford a new laptop, yet!");
}
```

✅ इस कोड और निम्न कोड को ब्राउज़र कंसोल में चलाकर अपनी समझ का परीक्षण करें। CurrentMoney और laptopPrice वैरिएबल के मानों को बदलकर लौटे `console.log()` को बदलें।

## लॉजिकल ऑपरेटर्स और बुलियन

निर्णयों में एक से अधिक तुलनाओं की आवश्यकता हो सकती है, और बूलियन मूल्य का उत्पादन करने के लिए तार्किक ऑपरेटरों के साथ मिलकर संघर्ष किया जा सकता है।

| प्रतीक   | विवरण                                                                        | उदाहरण                                                    |
| ------ | --------------------------------------------------------------------------- | -------------------------------------------------------- |
| `&&`   | **लॉजिकल एंड**: दो बूलियन अभिव्यक्तियों की तुलना करता है। सच्चा रिटर्न ** केवल ** यदि दोनों पक्ष सत्य हैं | `(5 > 6) && (5 < 6 ) //एक पक्ष झूठा है, दूसरा सच है। झूठा लौटता है`  |
| `\|\|` | **लॉजिकल और**: दो बूलियन अभिव्यक्तियों की तुलना करता है। अगर कम से कम एक पक्ष सच है, तो सच है    | `(5 > 6) \|\| (5 < 6) //एक पक्ष झूठा है, दूसरा सच है। सच लौटाता है` |
| `!`    | **लॉजिकल नॉट**: एक बूलियन अभिव्यक्ति के विपरीत मूल्य देता है                                 | `!(5 > 6) // 5 6 से अधिक नहीं है, लेकिन "!" सच लौटेगा`             |

## तार्किक संचालकों के साथ स्थितियां और निर्णय

तार्किक संचालकों का उपयोग ऍफ़..ईलस स्टेटमेंट में स्थितियाँ बनाने के लिए किया जा सकता है।

```javascript
let currentMoney;
let laptopPrice;
let laptopDiscountPrice = laptopPrice - (laptopPrice * .20) //Laptop price at 20 percent off

if (currentMoney >= laptopPrice || currentMoney >= laptopDiscountPrice){
    //Condition was true. Code in this block will run.
    console.log("Getting a new laptop!");
}
else {
    //Condition was true. Code in this block will run.
    console.log("Can't afford a new laptop, yet!");
}
```

### नेगटिव ऑपरेटर

आपने अभी तक देखा है कि अगर आप सशर्त तर्क बनाने के लिए `if...else` स्टेटमेंट का उपयोग कैसे कर सकते हैं। कुछ भी जो `if` में जाता है, उसे सही/गलत का मूल्यांकन करने की आवश्यकता होती है। '!' ऑपरेटर का उपयोग करके आप अभिव्यक्ति को _निगेट_ कर सकते हैं। ऐसा लगेगा:
```javascript
if (!condition) {
  // runs if condition is false
} else {
  // runs if condition is true
}
```

### टेरनरी एक्सप्रेशंस 

`if...else` निर्णय तर्क व्यक्त करने का एकमात्र तरीका नहीं है। आप टर्नरी ऑपरेटर नामक किसी चीज़ का उपयोग भी कर सकते हैं। इसके लिए सिंटैक्स इस तरह दिखता है:

```javascript
let variable = condition ? <return this if true> : <return this if false>
```

नीचे एक और मूर्त उदाहरण दिया गया है:

```javascript
let firstNumber = 20;
let secondNumber = 10
let biggestNumber = firstNumber > secondNumber ? firstNumber: secondNumber;
```

✅ इस कोड को कुछ समय पढ़ने के लिए एक मिनट लें। क्या आप समझते हैं कि ये ऑपरेटर कैसे काम कर रहे हैं?

उपरोक्त कहा गया है कि
- यदि `firstNumber` `secondNumber` से बड़ा है
- इसके बाद `firstNumber` को `biggestNumber` को असाइन करें
- वरना `secondNumber` असाइन करें।
  
टर्नरी एक्सप्रेशन नीचे दिए गए कोड को लिखने का एक कॉम्पैक्ट तरीका है:

```javascript
let biggestNumber;
if (firstNumber > secondNumber) {
  biggestNumber = firstNumber;
} else {
  biggestNumber = secondNumber;
}
```

---

## 🚀 चुनौती

एक प्रोग्राम बनाएं, जो पहले तार्किक ऑपरेटरों के साथ लिखा गया हो, और फिर इसे एक टर्नरी अभिव्यक्ति का उपयोग करके फिर से लिखना। आपका पसंदीदा सिंटेक्स क्या है?

---
## व्याख्यान उपरांत प्रश्नोत्तरी
[व्याख्यान उपरांत प्रश्नोत्तरी](https://ashy-river-0debb7803.1.azurestaticapps.net/quiz/12?loc=hi)

## समीक्षा और स्व अध्ययन

उपयोगकर्ता के लिए उपलब्ध कई ऑपरेटरों के बारे में और अधिक पढ़ें [MDN पर](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Operators)

जोश कोमू के अद्भुत [ऑपरेटर लुकअप](https://joshwcomeau.com/operator-lookup/) पर जाएं!

## असाइनमेंट

[ऑपरेटर्स](assignment.hi.md)
