ಪ್ರತಿಯೊಂದು ಉಪಯುಕ್ತ ಪ್ರೋಗ್ರಾಂ ಕೂಡ ಅಂತಿಮವಾಗಿ ಒಂದು ನಿರ್ಧಾರದ ಹಂತವನ್ನು ತಲುಪುತ್ತದೆ. ಈ ಬಟನ್ ಫಾರ್ಮ್ ಅನ್ನು ಸಬ್ಮಿಟ್ ಮಾಡಬೇಕೇ ಅಥವಾ ದೋಷವನ್ನು ತೋರಿಸಬೇಕೇ? ಇದು ಈ ಬಳಕೆದಾರ...

ಪ್ರತಿಯೊಂದು ಉಪಯುಕ್ತ ಪ್ರೋಗ್ರಾಂ ಕೂಡ ಅಂತಿಮವಾಗಿ ಒಂದು ನಿರ್ಧಾರದ ಹಂತವನ್ನು ತಲುಪುತ್ತದೆ. ಈ ಬಟನ್ ಫಾರ್ಮ್ ಅನ್ನು ಸಬ್ಮಿಟ್ ಮಾಡಬೇಕೇ ಅಥವಾ ದೋಷವನ್ನು (error) ತೋರಿಸಬೇಕೇ? ಈ ಬಳಕೆದಾರರು ಅಡ್ಮಿನ್ ಡ್ಯಾಶ್‌ಬೋರ್ಡ್ ನೋಡುತ್ತಾರೆಯೇ ಅಥವಾ ಗೆಸ್ಟ್ ವ್ಯೂ ನೋಡುತ್ತಾರೆಯೇ? JavaScript ಈ ಪ್ರಶ್ನೆಗಳಿಗೆ ಕಂಡೀಷನಲ್ ಸ್ಟೇಟ್‌ಮೆಂಟ್‌ಗಳ (conditional statements) ಮೂಲಕ ಉತ್ತರಿಸುತ್ತದೆ. ಅವು ನಿಮ್ಮ ಕೋಡ್‌ನ ನಿಯಂತ್ರಣ ವಾಲ್ವಿಗಳಿದ್ದಂತೆ: ಒಂದು ಎಕ್ಸ್‌ಪ್ರೆಶನ್ ಸತ್ಯ (true) ಅಥವಾ ಸುಳ್ಳು (false) ಎಂದು ನಿರ್ಧರಿಸಿದ ಆಧಾರದ ಮೇಲೆ ಒಂದು ಹಾದಿಯನ್ನು ತೆರೆಯುತ್ತವೆ ಅಥವಾ ಇನ್ನೊಂದನ್ನು ಮುಚ್ಚುತ್ತವೆ. ಅವುಗಳಿಲ್ಲದಿದ್ದರೆ, ನಿಮ್ಮ ಸ್ಕ್ರಿಪ್ಟ್ ಅದನ್ನು ಬಳಸುವ ವ್ಯಕ್ತಿಯ ಪ್ರತಿಕ್ರಿಯೆಗೆ ಎಂದಿಗೂ ಸ್ಪಂದಿಸದೆ ಮೇಲಿನಿಂದ ಕೆಳಕ್ಕೆ ಸಾಗುತ್ತದೆ.

ಅತ್ಯಂತ ಸರಳವಾದ ಶಾಖೆ: if

if ಸ್ಟೇಟ್‌ಮೆಂಟ್ ಎಂಬುದು ನೀವು ಮೊದಲು ಪ್ರವೇಶಿಸುವ ದ್ವಾರವಿದ್ದಂತೆ. ನೀವು ಆವರಣದೊಳಗೆ (parentheses) ಒಂದು ಕಂಡೀಷನ್ ಅನ್ನು ಇರಿಸುತ್ತೀರಿ. ಆ ಕಂಡೀಷನ್ true ಆಗಿದ್ದರೆ, ಅದರ ಕೆಳಗಿರುವ ಕೋಡ್ ಬ್ಲಾಕ್ ಕಾರ್ಯಗತಗೊಳ್ಳುತ್ತದೆ. ಒಂದು ವೇಳೆ ಅದು false ಆಗಿದ್ದರೆ, JavaScript ಆ ಬ್ಲಾಕ್ ಅನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಬಿಟ್ಟು ಮುಂದಿನ ಭಾಗಕ್ಕೆ ಸಾಗುತ್ತದೆ.

ಸರಳವಾದ, ಏಕದಿನದ ಪರಿಶೀಲನೆಗಳಿಗೆ (one-off checks) ಇದು ನಿಖರವಾಗಿ ಬೇಕಾದದ್ದು. ನೀವು ಸರ್ವರ್‌ಗೆ ಏನನ್ನಾದರೂ ಕಳುಹಿಸುವ ಮೊದಲು ಫಾರ್ಮ್ ಫೀಲ್ಡ್ ಅನ್ನು ವ್ಯಾಲಿಡೇಟ್ ಮಾಡುವುದನ್ನು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ:

const email = document.getElementById("email").value;

if (email === "") {
  alert("Please enter your email.");
}

email ಇಲ್ಲದಿದ್ದರೆ, ಸಬ್ಮಿಷನ್ ಆಗುವುದಿಲ್ಲ. ಈ ಲಾಜಿಕ್ ನೇರ ಮತ್ತು ಸ್ಪಷ್ಟವಾಗಿದೆ. ಕೇವಲ ಒಂದು ವಿಶೇಷ ಸಂದರ್ಭವನ್ನು ತಡೆಯಬೇಕಾದಾಗ ಮತ್ತು ಯಾವುದೇ ಪರ್ಯಾಯ ಕ್ರಮದ ಅಗತ್ಯವಿಲ್ಲದಿದ್ದಾಗ if ಬಳಸಿ.

ಇದೇ ಅಥವಾ ಅದು: if...else

ಹೆಚ್ಚಿನ ನೈಜ ನಿರ್ಧಾರಗಳು ಎರಡು ಮುಖಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ. if...else ಜೋಡಿಯು ನಿಖರವಾಗಿ ಅದನ್ನೇ ಒಳಗೊಂಡಿದೆ. ಕಂಡೀಷನ್ true ಆಗಿದ್ದಾಗ ಒಂದು ಬ್ಲಾಕ್ ಚಲಿಸುತ್ತದೆ, ಅದು false ಆಗಿದ್ದಾಗ ಇನ್ನೊಂದು ಬ್ಲಾಕ್ ಚಲಿಸುತ್ತದೆ. ಈ ಎರಡು ಹಾದಿಗಳು ಪರಸ್ಪರ ವಿಭಿನ್ನವಾಗಿರುತ್ತವೆ.

ಪೇಜ್ ಲೋಡ್ ಆಗುವಾಗ ಡಾರ್ಕ್-ಮೋಡ್ ಪರಿಶೀಲನೆಯನ್ನು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ:

const prefersDark = window.matchMedia("(prefers-color-scheme: dark)").matches;

if (prefersDark) {
  document.body.classList.add("dark");
} else {
  document.body.classList.add("light");
}

ಬ್ರೌಸರ್ ಎಂದಿಗೂ ಎರಡೂ ಕ್ಲಾಸ್‌ಗಳನ್ನು ಸೇರಿಸುವುದಿಲ್ಲ. ಅದು ಒಂದು ಹಾದಿಯನ್ನು ಆರಿಸಿಕೊಳ್ಳುತ್ತದೆ, ಅದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಮುಂದುವರಿಯುತ್ತದೆ. ನಿಮ್ಮ ಲಾಜಿಕ್ ಎರಡು ಸಂಭವನೀಯ ಫಲಿತಾಂಶಗಳಾಗಿ ಸ್ಪಷ್ಟವಾಗಿ ವಿಭಜನೆಯಾದಾಗ, ಈ ರಚನೆಯನ್ನು ಬಳಸಬಹುದು.

ಬಹು ಹಾದಿಗಳು: if...else if...else

ಪ್ರತಿಯೊಂದು ಸಮಸ್ಯೆಯೂ ಬೈನರಿ (binary) ಆಗಿರುವುದಿಲ್ಲ. ಕೆಲವೊಮ್ಮೆ ನಿಮಗೆ ಸಾಧ್ಯತೆಗಳ ಸರಣಿ (ladder of possibilities) ಬೇಕಾಗಬಹುದು. if...else if...else ಚೈನ್ ನಿಮಗೆ ಹಲವಾರು ಕಂಡೀಷನ್‌ಗಳನ್ನು ಕ್ರಮಬದ್ಧವಾಗಿ ಪರೀಕ್ಷಿಸಲು ಅನುಮತಿಸುತ್ತದೆ. JavaScript ಅವುಗಳನ್ನು ಮೇಲಿನಿಂದ ಕೆಳಕ್ಕೆ ಮೌಲ್ಯಮಾಪನ ಮಾಡುತ್ತದೆ ಮತ್ತು ಯಾವ ಕಂಡೀಷನ್ true ಆಗಿರುತ್ತದೆಯೋ ಆ ಮೊದಲ ಬ್ಲಾಕ್ ಅನ್ನು ರನ್ ಮಾಡುತ್ತದೆ. ಆ ಹೊಂದಾಣಿಕೆಯ ನಂತರ, ಉಳಿದ ಸರಣಿಯನ್ನು ನಿರ್ಲಕ್ಷಿಸಲಾಗುತ್ತದೆ.

ನಂಬರ್ ಸ್ಕೋರ್ ಅನ್ನು ಅಕ್ಷರ ರೂಪದ ಗ್ರೇಡ್‌ಗೆ ಮ್ಯಾಪ್ ಮಾಡುವುದು ಒಂದು ಸಾಂಪ್ರದಾಯಿಕ ಉದಾಹರಣೆ:

const score = 87;
let grade;

if (score >= 90) {
  grade = "A";
} else if (score >= 80) {
  grade = "B";
} else if (score >= 70) {
  grade = "C";
} else {
  grade = "F";
}

ಇಲ್ಲಿ ಕ್ರಮವು (order) ಬಹಳ ಮುಖ್ಯವಾಗಿದೆ. ನೀವು score >= 90 ಗಿಂತ ಮೊದಲು score >= 70 ಅನ್ನು ಪರಿಶೀಲಿಸಿದರೆ, ಬಹುತೇಕ ಎಲ್ಲಾ ಪಾಸ್ ಆಗುವ ಗ್ರೇಡ್‌ಗಳು C ಬಕೆಟ್‌ನಲ್ಲಿ ಸಿಲುಕಿಕೊಳ್ಳುತ್ತವೆ, ಏಕೆಂದರೆ ಮೊದಲನೇ true ಹೊಂದಾಣಿಕೆಯೇ ಗೆಲ್ಲುತ್ತದೆ. ನಿಮ್ಮ ಕಂಡೀಷನ್‌ಗಳನ್ನು ಹೆಚ್ಚು ನಿರ್ದಿಷ್ಟವಾದವುಗಳಿಂದ ಕಡಿಮೆ ನಿರ್ದಿಷ್ಟವಾದವುಗಳ ಕಡೆಗೆ ಜೋಡಿಸಿ ಮತ್ತು ಯಾವುದೇ ಸಂದರ್ಭಗಳು ತಪ್ಪಿಹೋಗದಂತೆ ಕೊನೆಯಲ್ಲಿ ಯಾವಾಗಲೂ else ಬಳಸಿ.

ಸ್ಥಿರ ಮೌಲ್ಯಗಳ ಹೊಂದಾಣಿಕೆ: switch

ನೀವು ಒಂದು ವೇರಿಯೇಬಲ್ ಅನ್ನು ತಿಳಿದಿರುವ ಸ್ಥಿರ ಮೌಲ್ಯಗಳ (constants) ಪಟ್ಟಿಯೊಂದಿಗೆ ಹೋಲಿಸುತ್ತಿರುವಾಗ, ಉದ್ದವಾದ if...else ಚೈನ್ ಗೊಂದಲಮಯವಾಗಬಹುದು. switch ಸ್ಟೇಟ್‌ಮೆಂಟ್ ವಿಷಯಗಳನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ. ಇದು ಒಂದು ಎಕ್ಸ್‌ಪ್ರೆಶನ್ ಅನ್ನು ಒಮ್ಮೆ ಮೌಲ್ಯಮಾಪನ ಮಾಡುತ್ತದೆ, ನಂತರ ಸ್ಟ್ರಿಕ್ಟ್ ಈಕ್ವಲಿಟಿ (===) ಬಳಸಿ ಅದನ್ನು case ಲೇಬಲ್‌ಗಳೊಂದಿಗೆ ಹೋಲಿಸುತ್ತದೆ. ಆಯ್ಕೆಗಳು ಪ್ರತ್ಯೇಕವಾಗಿದ್ದಾಗ ಮತ್ತು ಹೆಸರಿಸಲ್ಪಟ್ಟಿದ್ದಾಗ, ಇದು ಕೋಡ್ ಅನ್ನು ಸುಲಭವಾಗಿ ಓದಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.

ಪ್ರಸ್ತುತ ದಿನದ ಆಧಾರದ ಮೇಲೆ ಸ್ಟೋರ್ ಸಮಯವನ್ನು ನಿಗದಿಪಡಿಸುವುದನ್ನು ಪರಿಗಣಿಸಿ:

const day = new Date().getDay();

switch (day) {
  case 0:
    console.log("Sunday hours: 10am - 4pm");
    break;
  case 6:
    console.log("Saturday hours: 9am - 6pm");
    break;
  default:
    console.log("Weekday hours: 8am - 8pm");
}

break ಬಳಕೆಯಲ್ಲಿ ಎಚ್ಚರವಿರಲಿ. ನೀವು ಅದನ್ನು ಬಿಟ್ಟರೆ, ಎಕ್ಸಿಕ್ಯೂಷನ್ ಮುಂದಿನ case ಗೆ ಹೋಗುತ್ತದೆ ಮತ್ತು ರನ್ ಆಗುತ್ತಲೇ ಇರುತ್ತದೆ. ಆ ವರ್ತನೆಯು ಕೆಲವೊಮ್ಮೆ ಉಪಯುಕ್ತವಾಗಿದ್ದರೂ, ಹೆಚ್ಚಿನ ಸಂದರ್ಭಗಳಲ್ಲಿ ಅದು ಸೈಲೆಂಟ್ ಬಗ್‌ಗಳಿಗೆ (silent bugs) ಕಾರಣವಾಗುತ್ತದೆ. ಸರಿಯಾಗಿ ಬಳಸಿದರೆ, switch ನಿಮ್ಮ ಉದ್ದೇಶವನ್ನು ತಕ್ಷಣವೇ ಸ್ಪಷ್ಟಪಡಿಸುತ್ತದೆ ಮತ್ತು ಸಂಬಂಧಿತ ಶಾಖೆಗಳನ್ನು ಒಂದೇ ಸಾಲಿನಲ್ಲಿ ಅಚ್ಚುಕಟ್ಟಾಗಿ ಇರಿಸುತ್ತದೆ.

ಸಂಕ್ಷಿಪ್ತ ನಿರ್ಧಾರಗಳು: ಟೆರ್ನರಿ ಆಪರೇಟರ್ (Ternary Operator)

ಟೆರ್ನರಿ ಆಪರೇಟರ್—? : ಎಂದು ಬರೆಯಲಾಗುತ್ತದೆ—ಇದು ಒಂದು ಎಕ್ಸ್‌ಪ್ರೆಶನ್ ಆಗಿದೆಯೇ ಹೊರತು ಸ್ಟೇಟ್‌ಮೆಂಟ್ ಅಲ್ಲ. ಆ ವ್ಯತ್ಯಾಸವು ಮುಖ್ಯವಾಗಿದೆ.