|
|
<!--
|
|
|
CO_OP_TRANSLATOR_METADATA:
|
|
|
{
|
|
|
"original_hash": "90a3c32c3377f83ab750c2447c77ab98",
|
|
|
"translation_date": "2025-10-22T17:25:18+00:00",
|
|
|
"source_file": "2-js-basics/3-making-decisions/README.md",
|
|
|
"language_code": "pa"
|
|
|
}
|
|
|
-->
|
|
|
# ਜਾਵਾਸਕ੍ਰਿਪਟ ਬੇਸਿਕਸ: ਫੈਸਲੇ ਲੈਣਾ
|
|
|
|
|
|
|
|
|
|
|
|
> ਸਕੈਚਨੋਟ [ਟੋਮੋਮੀ ਇਮੁਰਾ](https://twitter.com/girlie_mac) ਦੁਆਰਾ
|
|
|
|
|
|
ਕੀ ਤੁਸੀਂ ਕਦੇ ਸੋਚਿਆ ਹੈ ਕਿ ਐਪਲੀਕੇਸ਼ਨ ਸਮਾਰਟ ਫੈਸਲੇ ਕਿਵੇਂ ਲੈਂਦੀਆਂ ਹਨ? ਜਿਵੇਂ ਕਿ ਇੱਕ ਨੈਵੀਗੇਸ਼ਨ ਸਿਸਟਮ ਸਭ ਤੋਂ ਤੇਜ਼ ਰਸਤਾ ਚੁਣਦਾ ਹੈ, ਜਾਂ ਇੱਕ ਥਰਮੋਸਟੈਟ ਤਪਸ਼ ਚਾਲੂ ਕਰਨ ਦਾ ਸਮਾਂ ਕਿਵੇਂ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ? ਇਹ ਪ੍ਰੋਗਰਾਮਿੰਗ ਵਿੱਚ ਫੈਸਲੇ ਲੈਣ ਦਾ ਮੁੱਖ ਸਿਧਾਂਤ ਹੈ।
|
|
|
|
|
|
ਜਿਵੇਂ ਚਾਰਲਸ ਬੈਬੇਜ ਦੇ ਐਨਾਲਿਟਿਕਲ ਇੰਜਨ ਨੂੰ ਹਾਲਾਤਾਂ ਦੇ ਅਧਾਰ 'ਤੇ ਵੱਖ-ਵੱਖ ਕਾਰਵਾਈਆਂ ਦੇ ਕ੍ਰਮਾਂ ਦੀ ਪਾਲਣਾ ਕਰਨ ਲਈ ਡਿਜ਼ਾਈਨ ਕੀਤਾ ਗਿਆ ਸੀ, ਆਧੁਨਿਕ ਜਾਵਾਸਕ੍ਰਿਪਟ ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਵੱਖ-ਵੱਖ ਹਾਲਾਤਾਂ ਦੇ ਅਧਾਰ 'ਤੇ ਚੋਣਾਂ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਇਹ ਸ਼ਾਖਾ ਬਣਾਉਣ ਅਤੇ ਫੈਸਲੇ ਲੈਣ ਦੀ ਯੋਗਤਾ ਹੈ ਜੋ ਸਥਿਰ ਕੋਡ ਨੂੰ ਪ੍ਰਤੀਕ੍ਰਿਆਸ਼ੀਲ, ਸਮਰੱਥ ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ ਬਦਲਦੀ ਹੈ।
|
|
|
|
|
|
ਇਸ ਪਾਠ ਵਿੱਚ, ਤੁਸੀਂ ਆਪਣੇ ਪ੍ਰੋਗਰਾਮਾਂ ਵਿੱਚ ਸ਼ਰਤੀ ਤਰਕ ਨੂੰ ਲਾਗੂ ਕਰਨਾ ਸਿੱਖੋਗੇ। ਅਸੀਂ ਸ਼ਰਤੀ ਬਿਆਨ, ਤੁਲਨਾ ਆਪਰੇਟਰ ਅਤੇ ਤਰਕਸ਼ੀਲ ਅਭਿਵਿਅਕਤੀਆਂ ਦੀ ਪੜਚੋਲ ਕਰਾਂਗੇ ਜੋ ਤੁਹਾਡੇ ਕੋਡ ਨੂੰ ਹਾਲਾਤਾਂ ਦਾ ਮੁਲਾਂਕਣ ਕਰਨ ਅਤੇ ਉਚਿਤ ਤਰੀਕੇ ਨਾਲ ਪ੍ਰਤੀਕ੍ਰਿਆ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੇ ਹਨ।
|
|
|
|
|
|
## ਪਾਠ ਤੋਂ ਪਹਿਲਾਂ ਕਵਿਜ਼
|
|
|
|
|
|
[ਪਾਠ ਤੋਂ ਪਹਿਲਾਂ ਕਵਿਜ਼](https://ff-quizzes.netlify.app/web/quiz/11)
|
|
|
|
|
|
ਫੈਸਲੇ ਲੈਣ ਅਤੇ ਪ੍ਰੋਗਰਾਮ ਦੇ ਪ੍ਰਵਾਹ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਦੀ ਯੋਗਤਾ ਪ੍ਰੋਗਰਾਮਿੰਗ ਦਾ ਇੱਕ ਮੁੱਖ ਪੱਖ ਹੈ। ਇਹ ਸੈਕਸ਼ਨ ਕਵਰ ਕਰਦਾ ਹੈ ਕਿ ਜਾਵਾਸਕ੍ਰਿਪਟ ਪ੍ਰੋਗਰਾਮਾਂ ਦੇ ਕਾਰਜ ਪੱਧਰ ਨੂੰ ਬੂਲੀਅਨ ਮੁੱਲਾਂ ਅਤੇ ਸ਼ਰਤੀ ਤਰਕ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕਿਵੇਂ ਨਿਯੰਤਰਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।
|
|
|
|
|
|
[](https://youtube.com/watch?v=SxTp8j-fMMY "ਫੈਸਲੇ ਲੈਣਾ")
|
|
|
|
|
|
> 🎥 ਉੱਪਰ ਦਿੱਤੀ ਤਸਵੀਰ 'ਤੇ ਕਲਿਕ ਕਰੋ ਫੈਸਲੇ ਲੈਣ ਬਾਰੇ ਵੀਡੀਓ ਦੇਖਣ ਲਈ।
|
|
|
|
|
|
> ਤੁਸੀਂ ਇਹ ਪਾਠ [ਮਾਈਕਰੋਸਾਫਟ ਲਰਨ](https://docs.microsoft.com/learn/modules/web-development-101-if-else/?WT.mc_id=academic-77807-sagibbon) 'ਤੇ ਲੈ ਸਕਦੇ ਹੋ!
|
|
|
|
|
|
## ਬੂਲੀਅਨ ਬਾਰੇ ਇੱਕ ਛੋਟਾ ਜਿਹਾ ਦੁਹਰਾਵਾ
|
|
|
|
|
|
ਫੈਸਲੇ ਲੈਣ ਦੀ ਪੜਚੋਲ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਆਓ ਆਪਣੇ ਪਿਛਲੇ ਪਾਠ ਤੋਂ ਬੂਲੀਅਨ ਮੁੱਲਾਂ ਨੂੰ ਦੁਹਰਾਈਏ। ਗਣਿਤਜੀਵਨ ਜਾਰਜ ਬੂਲ ਦੇ ਨਾਮ 'ਤੇ ਰੱਖੇ ਗਏ, ਇਹ ਮੁੱਲ ਦੋਹਰੇ ਰਾਜਾਂ ਦਾ ਪ੍ਰਤੀਨਿਧਿਤਾ ਕਰਦੇ ਹਨ - ਜਾਂ `true` ਜਾਂ `false`। ਇੱਥੇ ਕੋਈ ਗੁੰਝਲ ਨਹੀਂ, ਕੋਈ ਮੱਧਮ ਜਗ੍ਹਾ ਨਹੀਂ।
|
|
|
|
|
|
ਇਹ ਦੋਹਰੇ ਮੁੱਲ ਸਾਰੇ ਗਣਨਾਤਮਕ ਤਰਕ ਦੀ ਬੁਨਿਆਦ ਬਣਾਉਂਦੇ ਹਨ। ਤੁਹਾਡਾ ਪ੍ਰੋਗਰਾਮ ਜੋ ਵੀ ਫੈਸਲਾ ਲੈਂਦਾ ਹੈ, ਆਖਿਰਕਾਰ ਇੱਕ ਬੂਲੀਅਨ ਮੁਲਾਂਕਣ 'ਤੇ ਆਧਾਰਿਤ ਹੁੰਦਾ ਹੈ।
|
|
|
|
|
|
ਬੂਲੀਅਨ ਵੈਰੀਏਬਲ ਬਣਾਉਣਾ ਸਿੱਧਾ ਹੈ:
|
|
|
|
|
|
```javascript
|
|
|
let myTrueBool = true;
|
|
|
let myFalseBool = false;
|
|
|
```
|
|
|
|
|
|
ਇਹ ਦੋ ਵੈਰੀਏਬਲਾਂ ਨੂੰ ਸਪਸ਼ਟ ਬੂਲੀਅਨ ਮੁੱਲਾਂ ਨਾਲ ਬਣਾਉਂਦਾ ਹੈ।
|
|
|
|
|
|
✅ ਬੂਲੀਅਨ ਦਾ ਨਾਮ ਅੰਗਰੇਜ਼ੀ ਗਣਿਤਜੀਵਨ, ਦਰਸ਼ਨਸ਼ਾਸਤਰੀ ਅਤੇ ਤਰਕਸ਼ਾਸਤਰੀ ਜਾਰਜ ਬੂਲ (1815–1864) ਦੇ ਨਾਮ 'ਤੇ ਰੱਖਿਆ ਗਿਆ ਹੈ।
|
|
|
|
|
|
## ਤੁਲਨਾ ਆਪਰੇਟਰ ਅਤੇ ਬੂਲੀਅਨ
|
|
|
|
|
|
ਅਮਲ ਵਿੱਚ, ਤੁਸੀਂ ਕਦੇ ਵੀ ਬੂਲੀਅਨ ਮੁੱਲਾਂ ਨੂੰ ਹੱਥੋਂ ਸੈੱਟ ਨਹੀਂ ਕਰਦੇ। ਇਸ ਦੀ ਬਜਾਏ, ਤੁਸੀਂ ਹਾਲਾਤਾਂ ਦਾ ਮੁਲਾਂਕਣ ਕਰਕੇ ਉਹਨਾਂ ਨੂੰ ਜਨਮ ਦਿੰਦੇ ਹੋ: "ਕੀ ਇਹ ਨੰਬਰ ਉਸ ਤੋਂ ਵੱਧ ਹੈ?" ਜਾਂ "ਕੀ ਇਹ ਮੁੱਲ ਬਰਾਬਰ ਹਨ?"
|
|
|
|
|
|
ਤੁਲਨਾ ਆਪਰੇਟਰ ਇਹ ਮੁਲਾਂਕਣ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੇ ਹਨ। ਉਹ ਮੁੱਲਾਂ ਦੀ ਤੁਲਨਾ ਕਰਦੇ ਹਨ ਅਤੇ ਓਪਰੇਂਡਾਂ ਦੇ ਸੰਬੰਧ ਦੇ ਅਧਾਰ 'ਤੇ ਬੂਲੀਅਨ ਨਤੀਜੇ ਵਾਪਸ ਕਰਦੇ ਹਨ।
|
|
|
|
|
|
| ਚਿੰਨ੍ਹ | ਵੇਰਵਾ | ਉਦਾਹਰਨ |
|
|
|
| ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------ |
|
|
|
| `<` | **ਘੱਟ ਤੋਂ ਘੱਟ**: ਦੋ ਮੁੱਲਾਂ ਦੀ ਤੁਲਨਾ ਕਰਦਾ ਹੈ ਅਤੇ `true` ਬੂਲੀਅਨ ਡੇਟਾ ਟਾਈਪ ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੇਕਰ ਖੱਬੇ ਪਾਸੇ ਵਾਲਾ ਮੁੱਲ ਸੱਜੇ ਪਾਸੇ ਤੋਂ ਘੱਟ ਹੈ | `5 < 6 // true` |
|
|
|
| `<=` | **ਘੱਟ ਜਾਂ ਬਰਾਬਰ**: ਦੋ ਮੁੱਲਾਂ ਦੀ ਤੁਲਨਾ ਕਰਦਾ ਹੈ ਅਤੇ `true` ਬੂਲੀਅਨ ਡੇਟਾ ਟਾਈਪ ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੇਕਰ ਖੱਬੇ ਪਾਸੇ ਵਾਲਾ ਮੁੱਲ ਸੱਜੇ ਪਾਸੇ ਤੋਂ ਘੱਟ ਜਾਂ ਬਰਾਬਰ ਹੈ | `5 <= 6 // true` |
|
|
|
| `>` | **ਵੱਧ ਤੋਂ ਵੱਧ**: ਦੋ ਮੁੱਲਾਂ ਦੀ ਤੁਲਨਾ ਕਰਦਾ ਹੈ ਅਤੇ `true` ਬੂਲੀਅਨ ਡੇਟਾ ਟਾਈਪ ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੇਕਰ ਖੱਬੇ ਪਾਸੇ ਵਾਲਾ ਮੁੱਲ ਸੱਜੇ ਪਾਸੇ ਤੋਂ ਵੱਡਾ ਹੈ | `5 > 6 // false` |
|
|
|
| `>=` | **ਵੱਧ ਜਾਂ ਬਰਾਬਰ**: ਦੋ ਮੁੱਲਾਂ ਦੀ ਤੁਲਨਾ ਕਰਦਾ ਹੈ ਅਤੇ `true` ਬੂਲੀਅਨ ਡੇਟਾ ਟਾਈਪ ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੇਕਰ ਖੱਬੇ ਪਾਸੇ ਵਾਲਾ ਮੁੱਲ ਸੱਜੇ ਪਾਸੇ ਤੋਂ ਵੱਡਾ ਜਾਂ ਬਰਾਬਰ ਹੈ | `5 >= 6 // false` |
|
|
|
| `===` | **ਸਖ਼ਤ ਬਰਾਬਰੀ**: ਦੋ ਮੁੱਲਾਂ ਦੀ ਤੁਲਨਾ ਕਰਦਾ ਹੈ ਅਤੇ `true` ਬੂਲੀਅਨ ਡੇਟਾ ਟਾਈਪ ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੇਕਰ ਸੱਜੇ ਅਤੇ ਖੱਬੇ ਪਾਸੇ ਦੇ ਮੁੱਲ ਬਰਾਬਰ ਹਨ ਅਤੇ ਇੱਕੋ ਜਿਹੇ ਡੇਟਾ ਟਾਈਪ ਹਨ। | `5 === 6 // false` |
|
|
|
| `!==` | **ਅਸਮਾਨਤਾ**: ਦੋ ਮੁੱਲਾਂ ਦੀ ਤੁਲਨਾ ਕਰਦਾ ਹੈ ਅਤੇ ਉਹ ਬੂਲੀਅਨ ਮੁੱਲ ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੋ ਸਖ਼ਤ ਬਰਾਬਰੀ ਆਪਰੇਟਰ ਵਾਪਸ ਕਰੇਗਾ | `5 !== 6 // true` |
|
|
|
|
|
|
✅ ਆਪਣੇ ਬ੍ਰਾਊਜ਼ਰ ਦੇ ਕੰਸੋਲ ਵਿੱਚ ਕੁਝ ਤੁਲਨਾਵਾਂ ਲਿਖ ਕੇ ਆਪਣੀ ਜਾਣਕਾਰੀ ਦੀ ਜਾਂਚ ਕਰੋ। ਕੀ ਕੋਈ ਵਾਪਸ ਕੀਤਾ ਡੇਟਾ ਤੁਹਾਨੂੰ ਹੈਰਾਨ ਕਰਦਾ ਹੈ?
|
|
|
|
|
|
## If ਬਿਆਨ
|
|
|
|
|
|
`if` ਬਿਆਨ ਤੁਹਾਡੇ ਕੋਡ ਵਿੱਚ ਸਵਾਲ ਪੁੱਛਣ ਵਰਗਾ ਹੈ। "ਜੇ ਇਹ ਹਾਲਾਤ ਸਹੀ ਹਨ, ਤਾਂ ਇਹ ਕੰਮ ਕਰੋ।" ਇਹ ਸ਼ਾਇਦ ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ ਸੰਦ ਹੈ ਜੋ ਤੁਸੀਂ ਜਾਵਾਸਕ੍ਰਿਪਟ ਵਿੱਚ ਫੈਸਲੇ ਲੈਣ ਲਈ ਵਰਤੋਂਗੇ।
|
|
|
|
|
|
ਇਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ:
|
|
|
|
|
|
```javascript
|
|
|
if (condition) {
|
|
|
// Condition is true. Code in this block will run.
|
|
|
}
|
|
|
```
|
|
|
|
|
|
ਹਾਲਾਤ ਪੈਰੈਂਥੀਸਿਸ ਦੇ ਅੰਦਰ ਜਾਂਦੇ ਹਨ, ਅਤੇ ਜੇ ਇਹ `true` ਹੈ, ਜਾਵਾਸਕ੍ਰਿਪਟ ਕਰਲੀ ਬ੍ਰੇਸਜ਼ ਦੇ ਅੰਦਰ ਕੋਡ ਚਲਾਉਂਦਾ ਹੈ। ਜੇ ਇਹ `false` ਹੈ, ਜਾਵਾਸਕ੍ਰਿਪਟ ਉਸ ਸਾਰੇ ਬਲਾਕ ਨੂੰ ਛੱਡ ਦਿੰਦਾ ਹੈ।
|
|
|
|
|
|
ਤੁਸੀਂ ਅਕਸਰ ਇਹ ਹਾਲਾਤ ਬਣਾਉਣ ਲਈ ਤੁਲਨਾ ਆਪਰੇਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋਗੇ। ਆਓ ਇੱਕ ਵਿਹੰਗਮ ਉਦਾਹਰਨ ਦੇਖੀਏ:
|
|
|
|
|
|
```javascript
|
|
|
let currentMoney = 1000;
|
|
|
let laptopPrice = 800;
|
|
|
|
|
|
if (currentMoney >= laptopPrice) {
|
|
|
// Condition is true. Code in this block will run.
|
|
|
console.log("Getting a new laptop!");
|
|
|
}
|
|
|
```
|
|
|
|
|
|
ਕਿਉਂਕਿ `1000 >= 800` ਦਾ ਮੁਲਾਂਕਣ `true` ਹੈ, ਬਲਾਕ ਦੇ ਅੰਦਰ ਕੋਡ ਚਲਦਾ ਹੈ, ਕੰਸੋਲ ਵਿੱਚ "Getting a new laptop!" ਦਿਖਾਉਂਦਾ ਹੈ।
|
|
|
|
|
|
## If..Else ਬਿਆਨ
|
|
|
|
|
|
ਪਰ ਜੇ ਤੁਸੀਂ ਚਾਹੁੰਦੇ ਹੋ ਕਿ ਜਦੋਂ ਹਾਲਾਤ ਗਲਤ ਹੋਵੇ ਤਾਂ ਤੁਹਾਡਾ ਪ੍ਰੋਗਰਾਮ ਕੁਝ ਵੱਖਰਾ ਕਰੇ? ਇਹ ਜਿੱਥੇ `else` ਆਉਂਦਾ ਹੈ - ਇਹ ਜਿਵੇਂ ਬੈਕਅਪ ਯੋਜਨਾ ਹੋਵੇ।
|
|
|
|
|
|
`else` ਬਿਆਨ ਤੁਹਾਨੂੰ ਇਹ ਕਹਿਣ ਦਾ ਤਰੀਕਾ ਦਿੰਦਾ ਹੈ "ਜੇ ਇਹ ਹਾਲਾਤ ਸਹੀ ਨਹੀਂ ਹੈ, ਤਾਂ ਇਸ ਦੂਜੇ ਕੰਮ ਨੂੰ ਕਰੋ।"
|
|
|
|
|
|
```javascript
|
|
|
let currentMoney = 500;
|
|
|
let laptopPrice = 800;
|
|
|
|
|
|
if (currentMoney >= laptopPrice) {
|
|
|
// Condition is true. Code in this block will run.
|
|
|
console.log("Getting a new laptop!");
|
|
|
} else {
|
|
|
// Condition is false. Code in this block will run.
|
|
|
console.log("Can't afford a new laptop, yet!");
|
|
|
}
|
|
|
```
|
|
|
|
|
|
ਹੁਣ ਕਿਉਂਕਿ `500 >= 800` `false` ਹੈ, ਜਾਵਾਸਕ੍ਰਿਪਟ ਪਹਿਲੇ ਬਲਾਕ ਨੂੰ ਛੱਡ ਦਿੰਦਾ ਹੈ ਅਤੇ ਇਸਦੇ ਬਦਲੇ `else` ਬਲਾਕ ਚਲਾਉਂਦਾ ਹੈ। ਤੁਸੀਂ ਕੰਸੋਲ ਵਿੱਚ "Can't afford a new laptop, yet!" ਦੇਖੋਗੇ।
|
|
|
|
|
|
✅ ਇਸ ਕੋਡ ਅਤੇ ਹੇਠਾਂ ਦਿੱਤੇ ਕੋਡ ਨੂੰ ਬ੍ਰਾਊਜ਼ਰ ਕੰਸੋਲ ਵਿੱਚ ਚਲਾਕੇ ਆਪਣੀ ਸਮਝ ਦੀ ਜਾਂਚ ਕਰੋ। `currentMoney` ਅਤੇ `laptopPrice` ਵੈਰੀਏਬਲਾਂ ਦੇ ਮੁੱਲਾਂ ਨੂੰ ਬਦਲੋ ਤਾਂ ਜੋ ਵਾਪਸ ਕੀਤੇ `console.log()` ਨੂੰ ਬਦਲਿਆ ਜਾ ਸਕੇ।
|
|
|
|
|
|
## Switch ਬਿਆਨ
|
|
|
|
|
|
ਕਈ ਵਾਰ ਤੁਹਾਨੂੰ ਇੱਕ ਮੁੱਲ ਨੂੰ ਕਈ ਵਿਕਲਪਾਂ ਦੇ ਨਾਲ ਤੁਲਨਾ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਜਦੋਂ ਕਿ ਤੁਸੀਂ ਕਈ `if..else` ਬਿਆਨਾਂ ਨੂੰ ਜੋੜ ਸਕਦੇ ਹੋ, ਇਹ ਪਹੁੰਚ ਅਸੁਵਿਧਾਜਨਕ ਹੋ ਜਾਂਦੀ ਹੈ। `switch` ਬਿਆਨ ਕਈ ਵੱਖਰੇ ਮੁੱਲਾਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਇੱਕ ਸਾਫ਼ ਸਟ੍ਰਕਚਰ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।
|
|
|
|
|
|
ਇਸ ਦਾ ਸਿਧਾਂਤ ਸ਼ੁਰੂਆਤੀ ਟੈਲੀਫੋਨ ਐਕਸਚੇਂਜਾਂ ਵਿੱਚ ਵਰਤੇ ਗਏ ਮਕੈਨਿਕਲ ਸਵਿੱਚਿੰਗ ਸਿਸਟਮਾਂ ਦੇ ਸਮਾਨ ਹੈ - ਇੱਕ ਇਨਪੁਟ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ ਕਿ ਕਿਹੜਾ ਵਿਸ਼ੇਸ਼ ਰਸਤਾ ਕਾਰਜਨਵਤੀ ਕਰਦਾ ਹੈ।
|
|
|
|
|
|
```javascript
|
|
|
switch (expression) {
|
|
|
case x:
|
|
|
// code block
|
|
|
break;
|
|
|
case y:
|
|
|
// code block
|
|
|
break;
|
|
|
default:
|
|
|
// code block
|
|
|
}
|
|
|
```
|
|
|
|
|
|
ਇਹ ਕਿਵੇਂ ਬਣਾਇਆ ਜਾਂਦਾ ਹੈ:
|
|
|
- ਜਾਵਾਸਕ੍ਰਿਪਟ ਇੱਕ ਵਾਰ ਅਭਿਵਿਅਕਤੀ ਦਾ ਮੁਲਾਂਕਣ ਕਰਦਾ ਹੈ
|
|
|
- ਇਹ ਹਰ `case` ਨੂੰ ਵੇਖਦਾ ਹੈ ਕਿ ਕੋਈ ਮੇਲ ਮਿਲਦਾ ਹੈ
|
|
|
- ਜਦੋਂ ਇਹ ਮੇਲ ਮਿਲਦਾ ਹੈ, ਇਹ ਉਸ ਕੋਡ ਬਲਾਕ ਨੂੰ ਚਲਾਉਂਦਾ ਹੈ
|
|
|
- `break` ਜਾਵਾਸਕ੍ਰਿਪਟ ਨੂੰ ਰੋਕਦਾ ਹੈ ਅਤੇ ਸਵਿੱਚ ਤੋਂ ਬਾਹਰ ਨਿਕਲਦਾ ਹੈ
|
|
|
- ਜੇ ਕੋਈ ਕੇਸ ਮੇਲ ਨਹੀਂ ਖਾਂਦਾ, ਇਹ `default` ਬਲਾਕ ਚਲਾਉਂਦਾ ਹੈ (ਜੇ ਤੁਹਾਡੇ ਕੋਲ ਹੈ)
|
|
|
|
|
|
```javascript
|
|
|
// Program using switch statement for day of week
|
|
|
let dayNumber = 2;
|
|
|
let dayName;
|
|
|
|
|
|
switch (dayNumber) {
|
|
|
case 1:
|
|
|
dayName = "Monday";
|
|
|
break;
|
|
|
case 2:
|
|
|
dayName = "Tuesday";
|
|
|
break;
|
|
|
case 3:
|
|
|
dayName = "Wednesday";
|
|
|
break;
|
|
|
default:
|
|
|
dayName = "Unknown day";
|
|
|
break;
|
|
|
}
|
|
|
console.log(`Today is ${dayName}`);
|
|
|
```
|
|
|
|
|
|
ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ, ਜਾਵਾਸਕ੍ਰਿਪਟ ਵੇਖਦਾ ਹੈ ਕਿ `dayNumber` `2` ਹੈ, ਮੇਲ ਖਾਣ ਵਾਲਾ `case 2` ਲੱਭਦਾ ਹੈ, `dayName` ਨੂੰ "Tuesday" ਸੈੱਟ ਕਰਦਾ ਹੈ, ਅਤੇ ਫਿਰ ਸਵਿੱਚ ਤੋਂ ਬਾਹਰ ਨਿਕਲ ਜਾਂਦਾ ਹੈ। ਨਤੀਜਾ? "Today is Tuesday" ਕੰਸੋਲ ਵਿੱਚ ਲੌਗ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।
|
|
|
|
|
|
✅ ਇਸ ਕੋਡ ਅਤੇ ਹੇਠਾਂ ਦਿੱਤੇ ਕੋਡ ਨੂੰ ਬ੍ਰਾਊਜ਼ਰ ਕੰਸੋਲ ਵਿੱਚ ਚਲਾਕੇ ਆਪਣੀ ਸਮਝ ਦੀ ਜਾਂਚ ਕਰੋ। ਵੈਰੀਏਬਲ a ਦੇ ਮੁੱਲਾਂ ਨੂੰ ਬਦਲੋ ਤਾਂ ਜੋ ਵਾਪਸ ਕੀਤੇ `console.log()` ਨੂੰ ਬਦਲਿਆ ਜਾ ਸਕੇ।
|
|
|
|
|
|
## ਤਰਕਸ਼ੀਲ ਆਪਰੇਟਰ ਅਤੇ ਬੂਲੀਅਨ
|
|
|
|
|
|
ਜਟਿਲ ਫੈਸਲੇ ਅਕਸਰ ਇੱਕੋ ਸਮੇਂ ਕਈ ਹਾਲਾਤਾਂ ਦਾ ਮੁਲਾਂਕਣ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੇ ਹਨ। ਜਿਵੇਂ ਕਿ ਬੂਲੀਅਨ ਅਲਜੈਬਰਾ ਗਣਿਤਜੀਵਨ ਨੂੰ ਤਰਕਸ਼ੀਲ ਅਭਿਵਿਅਕਤੀਆਂ ਨੂੰ ਜੋੜਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ, ਪ੍ਰੋਗਰਾਮਿੰਗ ਕਈ ਬੂਲੀਅਨ ਹਾਲਾਤਾਂ ਨੂੰ ਜੁੜਨ ਲਈ ਤਰਕਸ਼ੀਲ ਆਪਰੇਟਰ ਪ੍ਰਦਾਨ ਕਰਦੀ ਹੈ।
|
|
|
|
|
|
ਇਹ ਆਪਰੇਟਰ ਸਧਾਰਨ ਸੱਚ/ਝੂਠੇ ਮੁਲਾਂਕਣਾਂ ਨੂੰ ਜੋੜ ਕੇ ਜਟਿਲ ਸ਼ਰਤੀ ਤਰਕ ਦੀ ਆਗਿਆ ਦਿੰਦੇ ਹਨ।
|
|
|
|
|
|
| ਚਿੰਨ੍ਹ | ਵੇਰਵਾ | ਉਦਾਹਰਨ |
|
|
|
| ------ | ----------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------- |
|
|
|
| `&&` | **ਲਾਜ਼ਮੀ AND**: ਦੋ ਬੂਲੀਅਨ ਅਭਿਵਿਅਕਤੀਆਂ ਦੀ ਤੁਲਨਾ ਕਰਦਾ ਹੈ। ਸੱਚ ਵਾਪਸ ਕਰਦਾ ਹੈ **ਸਿਰਫ** ਜੇ ਦੋਵੇਂ ਪਾਸੇ ਸੱਚ ਹਨ | `(5 > 3) && (5 < 10) // ਦੋਵੇਂ ਪਾਸੇ ਸੱਚ ਹਨ। ਸੱਚ ਵਾਪਸ ਕਰਦਾ ਹੈ` |
|
|
|
| `\|\|` | **ਲਾਜ਼ਮੀ OR**: ਦੋ ਬੂਲੀਅਨ ਅਭਿਵਿਅਕਤੀਆਂ ਦੀ ਤੁਲਨਾ ਕਰਦਾ ਹੈ। ਸੱਚ ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੇ ਘੱਟੋ-ਘੱਟ ਇੱਕ ਪਾਸਾ ਸੱਚ ਹੈ | `(5 > 10) \|\| (5 < 10) // ਇੱਕ ਪਾਸਾ ਗਲਤ ਹੈ, ਦੂਜਾ ਸੱਚ ਹੈ। ਸੱਚ ਵਾਪਸ ਕਰਦਾ ਹੈ` |
|
|
|
| `!` | **ਲਾਜ਼ਮੀ NOT**: ਇੱਕ ਬੂਲੀਅਨ ਅਭਿਵਿਅਕਤੀ ਦਾ ਵਿਰੋਧੀ ਮੁੱਲ ਵਾਪਸ ਕਰਦਾ ਹੈ | `!(5 > 10) // 5 10 ਤੋਂ ਵੱਧ ਨਹੀਂ ਹੈ, ਇਸ ਲਈ "!" ਇਸਨੂੰ ਸੱਚ ਬਣਾਉਂਦਾ ਹੈ` |
|
|
|
|
|
|
ਇਹ ਆਪਰੇਟਰ ਤੁਹਾਨੂੰ ਹਾਲਾਤਾਂ ਨੂੰ ਲਾਭਕਾਰੀ ਢੰਗ ਨਾਲ ਜੋੜਨ ਦੀ ਆਗਿਆ ਦਿੰਦੇ ਹਨ:
|
|
|
- AND (`&&`) ਦਾ ਮਤਲਬ ਹੈ ਦੋਵੇਂ ਹਾਲਾਤ ਸੱਚ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ
|
|
|
- OR (`||`) ਦਾ ਮਤਲਬ ਹੈ ਘੱਟੋ-ਘੱਟ ਇੱਕ ਹਾਲਾਤ ਸੱਚ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ
|
|
|
- NOT (`!`) ਸੱਚ ਨੂੰ ਝੂਠ ਵਿੱਚ ਬਦਲਦਾ ਹੈ (ਅਤੇ ਵਿਰੋਧੀ)
|
|
|
|
|
|
## ਤਰਕਸ਼ੀਲ ਆਪਰੇਟਰਾਂ ਨਾਲ ਹਾਲਾਤ ਅਤੇ ਫੈਸਲੇ
|
|
|
|
|
|
ਆਓ ਇੱਕ ਹੋਰ ਹਕੀਕਤੀ ਉਦਾਹਰਨ ਦੇ ਨਾਲ ਇਹ ਤਰਕਸ਼ੀਲ ਆਪਰੇਟਰ ਦੇਖੀਏ:
|
|
|
|
|
|
```javascript
|
|
|
let currentMoney = 600;
|
|
|
let laptopPrice = 800;
|
|
|
let laptopDiscountPrice = laptopPrice - (laptopPrice * 0.2); // Laptop price at 20 percent off
|
|
|
|
|
|
if (currentMoney >= laptopPrice || currentMoney >= laptopDiscountPrice) {
|
|
|
// Condition is true. Code in this block will run.
|
|
|
console.log("Getting a new laptop!");
|
|
|
} else {
|
|
|
// Condition is false. Code in this block will run.
|
|
|
console.log("Can't afford a new laptop, yet!");
|
|
|
}
|
|
|
```
|
|
|
|
|
|
ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ: ਅਸੀਂ 20% ਛੂਟ ਦੀ ਕੀਮਤ (640) ਦੀ ਗਣਨਾ ਕਰਦੇ ਹਾਂ, ਫਿਰ ਮੁਲਾਂਕਣ ਕਰਦੇ ਹਾਂ ਕਿ ਸਾਡੀ ਉਪਲਬਧ ਰਕਮ ਪੂਰੀ ਕੀਮਤ ਜਾਂ ਛੂਟ ਵਾਲੀ ਕੀਮਤ ਨੂੰ ਕਵਰ ਕਰਦੀ ਹੈ। ਕਿਉਂਕਿ 600 ਛੂਟ ਵਾਲੀ ਕੀਮਤ ਦੀ ਸੀਮਾ 640 ਨੂੰ ਪੂਰਾ ਕਰਦਾ ਹੈ, ਹਾਲਾਤ ਸੱਚ ਹੋ ਜਾਂਦੇ ਹਨ।
|
|
|
|
|
|
### ਨੈਗੇਸ਼ਨ ਆਪਰੇਟਰ
|
|
|
|
|
|
ਕਈ ਵਾਰ ਇਹ ਸੋਚਣਾ ਆਸਾਨ ਹੁੰਦਾ ਹੈ ਕਿ ਜਦੋਂ ਕੁਝ ਸੱਚ ਨਹੀਂ ਹੁੰਦਾ। ਜਿਵੇਂ "ਕੀ ਯੂਜ਼ਰ ਲੌਗਇਨ ਹੈ?" ਪੁੱਛਣ ਦੀ ਬਜਾਏ, ਤੁਸੀਂ "ਕੀ ਯੂਜ਼ਰ ਲੌਗਇਨ ਨਹੀਂ ਹੈ?" ਪੁੱਛਣਾ ਚਾਹੁੰਦੇ ਹੋ। ਚਿੰਨ੍ਹ (`!`) ਆਪਰੇਟਰ ਤੁਹਾਡੇ ਲਈ ਤਰਕ ਨੂੰ ਪਲਟ ਦਿੰਦਾ ਹੈ।
|
|
|
|
|
|
```javascript
|
|
|
if (!condition) {
|
|
|
// runs if condition is false
|
|
|
} else {
|
|
|
// runs if condition is true
|
|
|
}
|
|
|
```
|
|
|
|
|
|
`!` ਆਪਰੇਟਰ ਇਹ ਕਹਿਣ ਵਰਗਾ ਹੈ "ਵਿਰੋਧੀ...". ਜੇ ਕੁਝ `true` ਹੈ, `!` ਇਸਨੂੰ `false` ਬਣਾਉਂਦਾ ਹੈ, ਅਤੇ ਵਿਰੋਧੀ।
|
|
|
|
|
|
### ਟਰਨਰੀ ਅਭਿਵਿਅਕਤੀਆਂ
|
|
|
|
|
|
ਸਧਾਰਨ ਸ਼ਰਤੀ ਅਸਾਈਨਮੈਂਟਾਂ ਲਈ, ਜਾਵਾਸਕ੍ਰਿਪਟ **ਟਰਨਰੀ ਆਪਰੇਟਰ** ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਇਹ ਸੰਖੇਪ ਸਿੰਟੈਕਸ ਤੁਹਾਨੂੰ ਇੱਕ ਸਿੰਗਲ ਲਾਈਨ ਵਿੱਚ ਸ਼ਰਤੀ ਅਭਿਵਿਅਕਤੀ ਲਿਖਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ, ਜਦੋਂ ਤੁਹਾਨੂੰ ਹਾਲਾਤ ਦੇ ਅਧਾਰ 'ਤੇ ਦੋ
|
|
|
|
|
|
---
|
|
|
|
|
|
**ਅਸਵੀਕਰਤੀ**:
|
|
|
ਇਹ ਦਸਤਾਵੇਜ਼ AI ਅਨੁਵਾਦ ਸੇਵਾ [Co-op Translator](https://github.com/Azure/co-op-translator) ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਨੁਵਾਦ ਕੀਤਾ ਗਿਆ ਹੈ। ਜਦੋਂ ਕਿ ਅਸੀਂ ਸਹੀ ਹੋਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹਾਂ, ਕਿਰਪਾ ਕਰਕੇ ਧਿਆਨ ਦਿਓ ਕਿ ਸਵੈਚਾਲਿਤ ਅਨੁਵਾਦਾਂ ਵਿੱਚ ਗਲਤੀਆਂ ਜਾਂ ਅਸੁੱਤੀਆਂ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਇਸ ਦੀ ਮੂਲ ਭਾਸ਼ਾ ਵਿੱਚ ਮੂਲ ਦਸਤਾਵੇਜ਼ ਨੂੰ ਅਧਿਕਾਰਤ ਸਰੋਤ ਮੰਨਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਮਹੱਤਵਪੂਰਨ ਜਾਣਕਾਰੀ ਲਈ, ਪੇਸ਼ੇਵਰ ਮਨੁੱਖੀ ਅਨੁਵਾਦ ਦੀ ਸਿਫਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਸ ਅਨੁਵਾਦ ਦੀ ਵਰਤੋਂ ਤੋਂ ਪੈਦਾ ਹੋਣ ਵਾਲੇ ਕਿਸੇ ਵੀ ਗਲਤਫਹਿਮੀ ਜਾਂ ਗਲਤ ਵਿਆਖਿਆ ਲਈ ਅਸੀਂ ਜ਼ਿੰਮੇਵਾਰ ਨਹੀਂ ਹਾਂ। |
