Making decisions and controlling the order in which your code runs makes your code reusable and robust. This section covers the syntax for controlling data flow in JavaScript and its significance when used with Boolean data types
निर्णय लेना और उस आदेश को नियंत्रित करना जिसमें आपका कोड चलता है, आपके कोड को पुन: प्रयोज्य और मजबूत बनाता है। यह खंड बूलियन डेटा प्रकारों के साथ उपयोग किए जाने पर जावास्क्रिप्ट में डेटा प्रवाह को नियंत्रित करने और इसके महत्व के लिए सिंटैक्स को कवर करता है
> Click the image above for a video about making decisions.
> निर्णय लेने के बारे में वीडियो के लिए ऊपर दी गई छवि पर क्लिक करें।
## A Brief Recap on Booleans
## बूलियन्स पर एक संक्षिप्त पुनरावृत्ति
Booleans can be only two values: `true` or `false`. Booleans help make decisions on which lines of code should run when certain conditions are met.
बूलियन केवल दो मूल्य हो सकते हैं: `true` या `false`। बूलियंस निर्णय लेने में मदद करते हैं कि किन शर्तों को पूरा करने पर कोड की लाइनें चलनी चाहिए।
Set your boolean to be true or false like this:
इस तरह से सही या गलत होने के लिए अपना बूलियन सेट करें:
`let myTrueBool = true`
`let myTrueBool = true`
`let myFalseBool = false`
`let myFalseBool = false`
✅ Booleans are named after the English mathematician, philosopher and logician George Boole (1815–1864).
✅ बुलियन का नाम अंग्रेजी गणितज्ञ, दार्शनिक और तर्कशास्त्री जॉर्ज बोले (1815-1864) के नाम पर रखा गया है।
## Comparison Operators and Booleans
## तुलना ऑपरेटर और बूलियन
Operators are used to evaluate conditions by making comparisons that will create a Boolean value. The following is a list of operators that are frequently used.
ऑपरेटर्स का उपयोग उन परिस्थितियों के मूल्यांकन के लिए किया जाता है जो एक बूलियन मूल्य बनाएंगे। निम्नलिखित ऑपरेटरों की एक सूची है जो अक्सर उपयोग की जाती हैं।
| `<` | **Less than**: Compares two values and returns the `true` Boolean data type if the value on the left side is less than the right | `5 < 6 // true` |
| `<` | **से कम**: दो मानों की तुलना करता है और `true` बूलियन डेटा प्रकार लौटाता है यदि बाईं ओर का मान दाईं ओर से कम है | `5 < 6 // true` |
| `<=` | **Less than or equal to**: Compares two values and returns the `true` Boolean data type if the value on the left side is less than or equal to the right | `5 <= 6 // true` |
| `<=` | ** से कम या इसके बराबर**: दो मानों की तुलना करता है और `true` बूलियन डेटा प्रकार लौटाता है यदि बाईं ओर का मान दाईं ओर से कम या बराबर है | `5 <= 6 // true` |
| `>` | **Greater than**: Compares two values and returns the `true` Boolean data type if the value on the left side is larger than the right | `5 > 6 // false` |
| `>` | **से अधिक**: दो मानों की तुलना करता है और `true` बूलियन डेटा प्रकार लौटाता है यदि बाईं ओर का मान दाईं ओर से बड़ा है | `5 > 6 // false` |
| `>=` | **Greater than or equal to**: Compares two values and returns the `true` Boolean data type if the value on the left side is larger than or equal to the right | `5 >= 6 // false` |
| `>=` | **से अधिक या बराबर**: दो मानों की तुलना करता है और `true` बूलियन डेटा प्रकार देता है यदि बाईं ओर का मान righ से बड़ा या बराबर हैt | `5 >= 6 // false` |
| `===` | **Strict equality**: Compares two values and returns the `true` Boolean data type if values on the right and left are equal AND are the same data type. | `5 === 6 // false` |
| `===` | **सख्त समानता**: दो मूल्यों की तुलना करता है और `true` बूलियन डेटा प्रकार लौटाता है यदि दाएं और बाएं के मान समान हैं और समान डेटा प्रकार हैं। | `5 === 6 // false` |
| `!==` | **Inequality**: Compares two values and returns the opposite Boolean value of what a strict equality operator would return | `5 !== 6 // true` |
| `!==` | **असमानता**: दो मूल्यों की तुलना करता है और एक सख्त समानता ऑपरेटर वापस आने के विपरीत बूलियन मूल्य लौटाता है | `5 !== 6 // true` |
✅ Check your knowledge by writing some comparisons in your browser's console. Does any returned data surprise you?
✅ अपने ब्राउज़र के कंसोल में कुछ तुलनाएँ लिखकर अपने ज्ञान की जाँच करें। क्या कोई लौटा डेटा आपको आश्चर्यचकित करता है?
## If Statement
## ऍफ़ स्टेटमेंट
The if statement will run code in between its blocks if the condition is true.
यदि ऍफ़ कथन सही है, तो स्टेटमेंट उसके ब्लॉक के बीच में कोड चलाएगा।
```javascript
```javascript
if (condition){
if (condition){
@ -47,7 +47,7 @@ if (condition){
}
}
```
```
Logical operators are often used to form the condition.
लॉजिकल ऑपरेटर्स का उपयोग अक्सर हालत बनाने के लिए किया जाता है.
```javascript
```javascript
let currentMoney;
let currentMoney;
@ -59,9 +59,9 @@ if (currentMoney >= laptopPrice){
}
}
```
```
## IF..Else Statement
## ऍफ़..ईलस स्टेटमेंट
The `else` statement will run the code in between its blocks when the condition is false. It's optional with an `if` statement.
स्थिति के गलत होने पर `else` स्टेटमेंट उसके ब्लॉक के बीच कोड चलाएगा। यह `if` स्टेटमेंट के साथ वैकल्पिक है।
```javascript
```javascript
let currentMoney;
let currentMoney;
@ -77,21 +77,21 @@ else{
}
}
```
```
✅ Test your understanding of this code and the following code by running it in a browser console. Change the values of the currentMoney and laptopPrice variables to change the returned `console.log()`.
✅ इस कोड और निम्न कोड को ब्राउज़र कंसोल में चलाकर अपनी समझ का परीक्षण करें। CurrentMoney और laptopPrice वैरिएबल के मानों को बदलकर लौटे `console.log()` को बदलें।
## Logical Operators and Booleans
## लॉजिकल ऑपरेटर्स और बुलियन
Decisions might require more than one comparison, and can be strung together with logical operators to produce a Boolean value.
निर्णयों में एक से अधिक तुलनाओं की आवश्यकता हो सकती है, और बूलियन मूल्य का उत्पादन करने के लिए तार्किक ऑपरेटरों के साथ मिलकर संघर्ष किया जा सकता है।
| `&&` | **Logical AND**: Compares two Boolean expressions. Returns true **only** if both sides are true | `(5 > 6) && (5 < 6 ) //One side is false, other is true. Returns false` |
| `&&` | **लॉजिकल एंड**: दो बूलियन अभिव्यक्तियों की तुलना करता है। सच्चा रिटर्न ** केवल ** यदि दोनों पक्ष सत्य हैं | `(5 > 6) && (5 < 6 ) //एक पक्ष झूठा है, दूसरा सच है। झूठा लौटता है` |
| `\|\|` | **Logical OR**: Compares two Boolean expressions. Returns true if at least one side is true | `(5 > 6) \|\| (5 < 6) //One side is false, other is true. Returns true` |
| `\|\|` | **लॉजिकल और**: दो बूलियन अभिव्यक्तियों की तुलना करता है। अगर कम से कम एक पक्ष सच है, तो सच है | `(5 > 6) \|\| (5 < 6) //एक पक्ष झूठा है, दूसरा सच है। सच लौटाता है` |
| `!` | **Logical NOT**: Returns the opposite value of a Boolean expression | `!(5 > 6) // 5 is not greater than 6, but "!" will return true` |
| `!` | **लॉजिकल नॉट**: एक बूलियन अभिव्यक्ति के विपरीत मूल्य देता है | `!(5 > 6) // 5 6 से अधिक नहीं है, लेकिन "!" सच लौटेगा` |
## Conditions and Decisions with Logical Operators
## तार्किक संचालकों के साथ स्थितियां और निर्णय
Logical operators can be used to form conditions in if..else statements.
तार्किक संचालकों का उपयोग ऍफ़..ईलस स्टेटमेंट में स्थितियाँ बनाने के लिए किया जा सकता है।
```javascript
```javascript
let currentMoney;
let currentMoney;
@ -108,10 +108,9 @@ else {
}
}
```
```
### Negation operator
### नेगटिव ऑपरेटर
You've seen so far how if you can use an `if...else` statement to create conditional logic. Anything that goes into an `if` needs to evaluate to true/false. By using the `!` operator you can _negate_ the expression. It would look like so:
आपने अभी तक देखा है कि अगर आप सशर्त तर्क बनाने के लिए `if...else` स्टेटमेंट का उपयोग कैसे कर सकते हैं। कुछ भी जो `if` में जाता है, उसे सही/गलत का मूल्यांकन करने की आवश्यकता होती है। '!' ऑपरेटर का उपयोग करके आप अभिव्यक्ति को _निगेट_ कर सकते हैं। ऐसा लगेगा:
```javascript
```javascript
if (!condition) {
if (!condition) {
// runs if condition is false
// runs if condition is false
@ -120,15 +119,15 @@ if (!condition) {
}
}
```
```
### Ternary expressions
### टेरनरी एक्सप्रेशंस
`if...else`isn't the only way to express decision logic. You can also use something called a ternary operator. The syntax for it looks like this:
`if...else`निर्णय तर्क व्यक्त करने का एकमात्र तरीका नहीं है। आप टर्नरी ऑपरेटर नामक किसी चीज़ का उपयोग भी कर सकते हैं। इसके लिए सिंटैक्स इस तरह दिखता है:
```javascript
```javascript
let variable = condition ? <returnthisiftrue> : <returnthisiffalse>
let variable = condition ? <returnthisiftrue> : <returnthisiffalse>
```
```
Below is a more tangible example:
नीचे एक और मूर्त उदाहरण दिया गया है:
```javascript
```javascript
let firstNumber = 20;
let firstNumber = 20;
@ -136,14 +135,14 @@ let secondNumber = 10
let biggestNumber = firstNumber > secondNumber ? firstNumber: secondNumber;
let biggestNumber = firstNumber > secondNumber ? firstNumber: secondNumber;
```
```
✅ Take a minute to read this code a few times. Do you understand how these operators are working?
✅ इस कोड को कुछ समय पढ़ने के लिए एक मिनट लें। क्या आप समझते हैं कि ये ऑपरेटर कैसे काम कर रहे हैं?
The above states that
उपरोक्त कहा गया है कि
- if `firstNumber` is larger than `secondNumber`
- यदि `firstNumber``secondNumber` से बड़ा है
- then assign `firstNumber` to `biggestNumber`
- इसके बाद `firstNumber` को `biggestNumber` को असाइन करें
- else assign `secondNumber`.
- वरना `secondNumber` असाइन करें।
The ternary expression is just a compact way of writing the code below:
टर्नरी एक्सप्रेशन नीचे दिए गए कोड को लिखने का एक कॉम्पैक्ट तरीका है:
```javascript
```javascript
let biggestNumber;
let biggestNumber;
@ -156,20 +155,20 @@ if (firstNumber > secondNumber) {
---
---
## 🚀 Challenge
## 🚀 चुनौती
Create a program that is written first with logical operators, and then rewrite it using a ternary expression. What's your preferred syntax?
एक प्रोग्राम बनाएं, जो पहले तार्किक ऑपरेटरों के साथ लिखा गया हो, और फिर इसे एक टर्नरी अभिव्यक्ति का उपयोग करके फिर से लिखना। आपका पसंदीदा सिंटेक्स क्या है?
Sanjay
4 years ago