18 KiB

Raw Blame History Unescape Escape

ਜਾਵਾਸਕ੍ਰਿਪਟ ਬੁਨਿਆਦੀਆਂ: ਫੈਸਲੇ ਲੈਣਾ

ਸਕੈਚਨੋਟ Tomomi Imura ਵੱਲੋਂ

ਲੈਕਚਰ ਤੋਂ ਪਹਿਲਾਂ ਕਵਿਜ਼

ਫੈਸਲੇ ਲੈਣਾ ਅਤੇ ਆਪਣੇ ਕੋਡ ਦੇ ਚਲਾਉਣ ਦੇ ਕ੍ਰਮ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨਾ ਤੁਹਾਡੇ ਕੋਡ ਨੂੰ ਦੁਬਾਰਾ ਵਰਤਣਯੋਗ ਅਤੇ ਮਜ਼ਬੂਤ ਬਣਾਉਂਦਾ ਹੈ। ਇਸ ਭਾਗ ਵਿੱਚ ਜਾਵਾਸਕ੍ਰਿਪਟ ਵਿੱਚ ਡਾਟਾ ਫਲੋ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਲਈ ਸਿੰਟੈਕਸ ਅਤੇ ਬੂਲੀਅਨ ਡਾਟਾ ਟਾਈਪਸ ਦੇ ਨਾਲ ਇਸਦੇ ਮਹੱਤਵ ਬਾਰੇ ਚਰਚਾ ਕੀਤੀ ਗਈ ਹੈ।

🎥 ਉੱਪਰ ਦਿੱਤੀ ਤਸਵੀਰ 'ਤੇ ਕਲਿਕ ਕਰੋ ਫੈਸਲੇ ਲੈਣ ਬਾਰੇ ਵੀਡੀਓ ਦੇਖਣ ਲਈ।

ਤੁਸੀਂ ਇਹ ਪਾਠ Microsoft Learn 'ਤੇ ਲੈ ਸਕਦੇ ਹੋ!

ਬੂਲੀਅਨਸ ਬਾਰੇ ਇੱਕ ਛੋਟਾ ਜਿਹਾ ਪੁਰਾਲੇਖ

ਬੂਲੀਅਨਸ ਵਿੱਚ ਸਿਰਫ ਦੋ ਮੁੱਲ ਹੁੰਦੇ ਹਨ: true ਜਾਂ false। ਬੂਲੀਅਨਸ ਇਹ ਫੈਸਲਾ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦੇ ਹਨ ਕਿ ਜਦੋਂ ਕੁਝ ਸ਼ਰਤਾਂ ਪੂਰੀਆਂ ਹੁੰਦੀਆਂ ਹਨ ਤਾਂ ਕਿਹੜੀਆਂ ਲਾਈਨਾਂ ਚਲਾਈਆਂ ਜਾਣੀਆਂ ਚਾਹੀਦੀਆਂ ਹਨ।

ਆਪਣੇ ਬੂਲੀਅਨ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ true ਜਾਂ false ਸੈਟ ਕਰੋ:

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 ਸਟੇਟਮੈਂਟ ਆਪਣੇ ਬਲਾਕਾਂ ਦੇ ਵਿਚਕਾਰ ਕੋਡ ਨੂੰ ਚਲਾਏਗਾ ਜੇ ਸ਼ਰਤ ਸੱਚ ਹੈ।

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

ਲੌਜਿਕਲ ਆਪਰੇਟਰਾਂ ਨੂੰ ਅਕਸਰ ਸ਼ਰਤ ਬਣਾਉਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।

let currentMoney;
let laptopPrice;

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

If..Else ਸਟੇਟਮੈਂਟ

else ਸਟੇਟਮੈਂਟ ਆਪਣੇ ਬਲਾਕਾਂ ਦੇ ਵਿਚਕਾਰ ਕੋਡ ਨੂੰ ਚਲਾਏਗਾ ਜਦੋਂ ਸ਼ਰਤ ਗਲਤ ਹੋਵੇ। ਇਹ if ਸਟੇਟਮੈਂਟ ਦੇ ਨਾਲ ਵਿਕਲਪਿਕ ਹੈ।

let currentMoney;
let laptopPrice;

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!");
}

✅ ਇਸ ਕੋਡ ਅਤੇ ਹੇਠਾਂ ਦਿੱਤੇ ਕੋਡ ਦੀ ਸਮਝ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਇਸਨੂੰ ਬ੍ਰਾਊਜ਼ਰ ਕਨਸੋਲ ਵਿੱਚ ਚਲਾਓ। currentMoney ਅਤੇ laptopPrice ਵੈਰੀਏਬਲ ਦੇ ਮੁੱਲਾਂ ਨੂੰ ਬਦਲੋ ਤਾਂ ਜੋ ਵਾਪਸ ਕੀਤੇ console.log() ਨੂੰ ਬਦਲਿਆ ਜਾ ਸਕੇ।

Switch ਸਟੇਟਮੈਂਟ

switch ਸਟੇਟਮੈਂਟ ਵੱਖ-ਵੱਖ ਸ਼ਰਤਾਂ ਦੇ ਅਧਾਰ 'ਤੇ ਵੱਖ-ਵੱਖ ਕਾਰਵਾਈਆਂ ਕਰਨ ਲਈ ਵਰਤੀ ਜਾਂਦੀ ਹੈ। switch ਸਟੇਟਮੈਂਟ ਨੂੰ ਚੁਣਨ ਲਈ ਵਰਤੋ ਕਿ ਕੌਣ-ਕੌਣ ਕੋਡ ਬਲਾਕ ਚਲਾਏ ਜਾਣਗੇ।

switch (expression) {
  case x:
    // code block
    break;
  case y:
    // code block
    break;
  default:
  // code block
}

// program using switch statement
let a = 2;

switch (a) {
  case 1:
    a = "one";
    break;
  case 2:
    a = "two";
    break;
  default:
    a = "not found";
    break;
}
console.log(`The value is ${a}`);

✅ ਇਸ ਕੋਡ ਅਤੇ ਹੇਠਾਂ ਦਿੱਤੇ ਕੋਡ ਦੀ ਸਮਝ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਇਸਨੂੰ ਬ੍ਰਾਊਜ਼ਰ ਕਨਸੋਲ ਵਿੱਚ ਚਲਾਓ। ਵੈਰੀਏਬਲ a ਦੇ ਮੁੱਲਾਂ ਨੂੰ ਬਦਲੋ ਤਾਂ ਜੋ ਵਾਪਸ ਕੀਤੇ console.log() ਨੂੰ ਬਦਲਿਆ ਜਾ ਸਕੇ।

ਲੌਜਿਕਲ ਆਪਰੇਟਰ ਅਤੇ ਬੂਲੀਅਨਸ

ਫੈਸਲੇ ਲਈ ਇੱਕ ਤੋਂ ਵੱਧ ਤੁਲਨਾ ਦੀ ਲੋੜ ਹੋ ਸਕਦੀ ਹੈ, ਅਤੇ ਇਹਨਾਂ ਨੂੰ ਬੂਲੀਅਨ ਮੁੱਲ ਪੈਦਾ ਕਰਨ ਲਈ ਲੌਜਿਕਲ ਆਪਰੇਟਰਾਂ ਨਾਲ ਜੋੜਿਆ ਜਾ ਸਕਦਾ ਹੈ।

ਚਿੰਨ੍ਹ	ਵੇਰਵਾ	ਉਦਾਹਰਨ
`&&`	ਲੌਜਿਕਲ AND: ਦੋ ਬੂਲੀਅਨ ਅਭਿਵਿਅਕਤੀਆਂ ਦੀ ਤੁਲਨਾ ਕਰਦਾ ਹੈ। ਸਿਰਫ ਦੋਵੇਂ ਪਾਸੇ ਸੱਚ ਹੋਣ 'ਤੇ ਸੱਚ ਵਾਪਸ ਕਰਦਾ ਹੈ।	`(5 > 6) && (5 < 6 ) //ਇੱਕ ਪਾਸੇ ਗਲਤ ਹੈ, ਦੂਜਾ ਸੱਚ ਹੈ। ਗਲਤ ਵਾਪਸ ਕਰਦਾ ਹੈ।`
`\|\|`	ਲੌਜਿਕਲ OR: ਦੋ ਬੂਲੀਅਨ ਅਭਿਵਿਅਕਤੀਆਂ ਦੀ ਤੁਲਨਾ ਕਰਦਾ ਹੈ। ਜੇ ਘੱਟੋ-ਘੱਟ ਇੱਕ ਪਾਸੇ ਸੱਚ ਹੈ ਤਾਂ ਸੱਚ ਵਾਪਸ ਕਰਦਾ ਹੈ।	`(5 > 6) \|\| (5 < 6) //ਇੱਕ ਪਾਸੇ ਗਲਤ ਹੈ, ਦੂਜਾ ਸੱਚ ਹੈ। ਸੱਚ ਵਾਪਸ ਕਰਦਾ ਹੈ।`
`!`	ਲੌਜਿਕਲ NOT: ਬੂਲੀਅਨ ਅਭਿਵਿਅਕਤੀ ਦੇ ਵਿਰੁੱਧ ਮੁੱਲ ਵਾਪਸ ਕਰਦਾ ਹੈ।	`!(5 > 6) // 5 6 ਤੋਂ ਵੱਧ ਨਹੀਂ ਹੈ, ਪਰ "!" ਸੱਚ ਵਾਪਸ ਕਰੇਗਾ।`

ਲੌਜਿਕਲ ਆਪਰੇਟਰਾਂ ਨਾਲ ਸ਼ਰਤਾਂ ਅਤੇ ਫੈਸਲੇ

ਲੌਜਿਕਲ ਆਪਰੇਟਰਾਂ ਨੂੰ if..else ਸਟੇਟਮੈਂਟ ਵਿੱਚ ਸ਼ਰਤਾਂ ਬਣਾਉਣ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ।

let currentMoney;
let laptopPrice;
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 true. Code in this block will run.
  console.log("Can't afford a new laptop, yet!");
}

ਨਿਗੇਸ਼ਨ ਆਪਰੇਟਰ

ਤੁਸੀਂ ਹੁਣ ਤੱਕ ਦੇਖਿਆ ਹੈ ਕਿ ਤੁਸੀਂ if...else ਸਟੇਟਮੈਂਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸ਼ਰਤੀ ਤਰਕਸ਼ੀਲਤਾ ਕਿਵੇਂ ਬਣਾਉਣਗੇ। ਜੋ ਕੁਝ ਵੀ if ਵਿੱਚ ਜਾਂਦਾ ਹੈ ਉਸਨੂੰ ਸੱਚ/ਗਲਤ ਦਾ ਮੁਲਾਂਕਣ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ! ਆਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਤੁਸੀਂ ਅਭਿਵਿਅਕਤੀ ਨੂੰ ਨਕਾਰ ਸਕਦੇ ਹੋ। ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਲੱਗੇਗਾ:

if (!condition) {
  // runs if condition is false
} else {
  // runs if condition is true
}

ਟਰਨਰੀ ਅਭਿਵਿਅਕਤੀਆਂ

if...else ਫੈਸਲੇ ਦੀ ਤਰਕਸ਼ੀਲਤਾ ਨੂੰ ਪ੍ਰਗਟ ਕਰਨ ਦਾ ਇੱਕੋ ਤਰੀਕਾ ਨਹੀਂ ਹੈ। ਤੁਸੀਂ ਕੁਝ ਐਸਾ ਵਰਤ ਸਕਦੇ ਹੋ ਜਿਸਨੂੰ ਟਰਨਰੀ ਆਪਰੇਟਰ ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਇਸਦਾ ਸਿੰਟੈਕਸ ਇਸ ਤਰ੍ਹਾਂ ਲੱਗਦਾ ਹੈ:

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

ਹੇਠਾਂ ਇੱਕ ਹੋਰ ਵਾਸਤਵਿਕ ਉਦਾਹਰਨ ਦਿੱਤੀ ਗਈ ਹੈ:

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

✅ ਇਸ ਕੋਡ ਨੂੰ ਕੁਝ ਵਾਰ ਪੜ੍ਹਨ ਲਈ ਇੱਕ ਮਿੰਟ ਲਓ। ਕੀ ਤੁਸੀਂ ਸਮਝਦੇ ਹੋ ਕਿ ਇਹ ਆਪਰੇਟਰ ਕਿਵੇਂ ਕੰਮ ਕਰ ਰਹੇ ਹਨ?

ਉਪਰੋਕਤ ਕਹਿੰਦਾ ਹੈ ਕਿ

ਜੇ firstNumber secondNumber ਤੋਂ ਵੱਡਾ ਹੈ
ਤਾਂ firstNumber ਨੂੰ biggestNumber ਵਿੱਚ ਅਸਾਈਨ ਕਰੋ
ਨਹੀਂ ਤਾਂ secondNumber ਨੂੰ ਅਸਾਈਨ ਕਰੋ।

ਟਰਨਰੀ ਅਭਿਵਿਅਕਤੀ ਸਿਰਫ ਹੇਠਾਂ ਦਿੱਤੇ ਕੋਡ ਨੂੰ ਲਿਖਣ ਦਾ ਇੱਕ ਸੰਕੁਚਿਤ ਤਰੀਕਾ ਹੈ:

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

🚀 ਚੁਣੌਤੀ

ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਬਣਾਓ ਜੋ ਪਹਿਲਾਂ ਲੌਜਿਕਲ ਆਪਰੇਟਰਾਂ ਨਾਲ ਲਿਖਿਆ ਗਿਆ ਹੋਵੇ, ਅਤੇ ਫਿਰ ਇਸਨੂੰ ਟਰਨਰੀ ਅਭਿਵਿਅਕਤੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਦੁਬਾਰਾ ਲਿਖੋ। ਤੁਹਾਡਾ ਮਨਪਸੰਦ ਸਿੰਟੈਕਸ ਕਿਹੜਾ ਹੈ?

GitHub Copilot Agent ਚੁਣੌਤੀ 🚀

Agent ਮੋਡ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਹੇਠਾਂ ਦਿੱਤੀ ਚੁਣੌਤੀ ਪੂਰੀ ਕਰੋ:

ਵੇਰਵਾ: ਇੱਕ ਵਿਸਤ੍ਰਿਤ ਗ੍ਰੇਡ ਕੈਲਕੂਲੇਟਰ ਬਣਾਓ ਜੋ ਇਸ ਪਾਠ ਵਿੱਚ ਦਿੱਤੇ ਗਏ ਕਈ ਫੈਸਲੇ ਲੈਣ ਵਾਲੇ ਸੰਕਲਪਾਂ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ if-else ਸਟੇਟਮੈਂਟ, switch ਸਟੇਟਮੈਂਟ, ਲੌਜਿਕਲ ਆਪਰੇਟਰ ਅਤੇ ਟਰਨਰੀ ਅਭਿਵਿਅਕਤੀਆਂ।

ਪ੍ਰੋੰਪਟ: ਇੱਕ ਜਾਵਾਸਕ੍ਰਿਪਟ ਪ੍ਰੋਗਰਾਮ ਲਿਖੋ ਜੋ ਵਿਦਿਆਰਥੀ ਦੇ ਅੰਕਾਂ (0-100) ਨੂੰ ਲੈਂਦਾ ਹੈ ਅਤੇ ਹੇਠਾਂ ਦਿੱਤੇ ਮਾਪਦੰਡਾਂ ਦੇ ਅਧਾਰ 'ਤੇ ਉਨ੍ਹਾਂ ਦਾ ਲੇਟਰ ਗ੍ਰੇਡ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ:

A: 90-100
B: 80-89
C: 70-79
D: 60-69
F: 60 ਤੋਂ ਘੱਟ

ਸ਼ਰਤਾਂ:

ਲੇਟਰ ਗ੍ਰੇਡ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ if-else ਸਟੇਟਮੈਂਟ ਦੀ ਵਰਤੋਂ ਕਰੋ
ਜਾਂਚ ਕਰੋ ਕਿ ਵਿਦਿਆਰਥੀ ਪਾਸ ਕਰਦਾ ਹੈ (grade >= 60) ਅਤੇ ਮਾਨ (grade >= 90) ਹੈ
ਹਰ ਲੇਟਰ ਗ੍ਰੇਡ ਲਈ ਵਿਸ਼ੇਸ਼ ਫੀਡਬੈਕ ਪ੍ਰਦਾਨ ਕਰਨ ਲਈ switch ਸਟੇਟਮੈਂਟ ਦੀ ਵਰਤੋਂ ਕਰੋ
ਵਿਦਿਆਰਥੀ ਅਗਲੇ ਕੋਰਸ ਲਈ ਯੋਗ ਹੈ ਜਾਂ ਨਹੀਂ (grade >= 70) ਇਹ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਟਰਨਰੀ ਆਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰੋ
ਇਹ ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਅੰਕ 0 ਤੋਂ 100 ਦੇ ਵਿਚਕਾਰ ਹਨ

ਆਪਣੇ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਵੱਖ-ਵੱਖ ਅੰਕਾਂ ਨਾਲ ਟੈਸਟ ਕਰੋ ਜਿਸ ਵਿੱਚ 59, 60, 89, 90 ਅਤੇ ਗਲਤ ਇਨਪੁਟ ਵਰਗੇ ਐਜ ਕੇਸ ਸ਼ਾਮਲ ਹਨ।

ਲੈਕਚਰ ਤੋਂ ਬਾਅਦ ਕਵਿਜ਼

ਸਮੀਖਿਆ ਅਤੇ ਖੁਦ ਅਧਿਐਨ

ਉਪਭੋਗਤਾ ਲਈ ਉਪਲਬਧ ਕਈ ਆਪਰੇਟਰਾਂ ਬਾਰੇ ਹੋਰ ਪੜ੍ਹੋ MDN 'ਤੇ।

Josh Comeau ਦਾ ਸ਼ਾਨਦਾਰ operator lookup ਦੇਖੋ!

ਅਸਾਈਨਮੈਂਟ

Operators

ਅਸਵੀਕਰਤਾ:
ਇਹ ਦਸਤਾਵੇਜ਼ AI ਅਨੁਵਾਦ ਸੇਵਾ Co-op Translator ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਨੁਵਾਦ ਕੀਤਾ ਗਿਆ ਹੈ। ਜਦੋਂ ਕਿ ਅਸੀਂ ਸਹੀ ਹੋਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹਾਂ, ਕਿਰਪਾ ਕਰਕੇ ਧਿਆਨ ਦਿਓ ਕਿ ਸਵੈਚਾਲਿਤ ਅਨੁਵਾਦਾਂ ਵਿੱਚ ਗਲਤੀਆਂ ਜਾਂ ਅਸੁਚਨਾਵਾਂ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਇਸ ਦੀ ਮੂਲ ਭਾਸ਼ਾ ਵਿੱਚ ਮੂਲ ਦਸਤਾਵੇਜ਼ ਨੂੰ ਅਧਿਕਾਰਤ ਸਰੋਤ ਮੰਨਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਮਹੱਤਵਪੂਰਨ ਜਾਣਕਾਰੀ ਲਈ, ਪੇਸ਼ੇਵਰ ਮਨੁੱਖੀ ਅਨੁਵਾਦ ਦੀ ਸਿਫਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਸ ਅਨੁਵਾਦ ਦੀ ਵਰਤੋਂ ਤੋਂ ਪੈਦਾ ਹੋਣ ਵਾਲੇ ਕਿਸੇ ਵੀ ਗਲਤਫਹਿਮੀ ਜਾਂ ਗਲਤ ਵਿਆਖਿਆ ਲਈ ਅਸੀਂ ਜ਼ਿੰਮੇਵਾਰ ਨਹੀਂ ਹਾਂ।

18 KiB Raw Blame History Unescape Escape