ಪ್ರತಿಯೊಂದು ಪ್ರೋಗ್ರಾಂ ಕೂಡ ಪ್ರತಿಕ್ರಿಯಿಸಬೇಕಾಗುತ್ತದೆ. ಬಳಕೆದಾರರು ಒಂದು ಬಟನ್ ಕ್ಲಿಕ್ ಮಾಡುತ್ತಾರೆ. ಒಂದು API ಡೇಟಾವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಫಾರ್ಮ್ ಫೀಲ್ಡ್ ಖಾಲಿಯಾಗುತ್ತದೆ. ವಿಭಿನ್ನ ಹಾದಿಗಳನ್ನು (branching) ಆಯ್ಕೆ ಮಾಡುವ ವಿಧಾನವಿಲ್ಲದಿದ್ದರೆ, ನಿಮ್ಮ ಕೋಡ್ನಲ್ಲಿ ಏನೇ ನಡೆಯುತ್ತಿರಲಿ, ಅದು ಸಾಲು ಸಾಲಾಗಿ (line by line) ಚಲಿಸುತ್ತದೆ. ಕಂಡೀಷನಲ್ಗಳು (Conditionals) JavaScript ಗೆ ಆಯ್ಕೆ ಮಾಡುವ ಸಾಮರ್ಥ್ಯವನ್ನು ನೀಡುತ್ತವೆ. ಅವು ನಿಮ್ಮ ಫಂಕ್ಷನ್ಗಳ ಒಳಗಿನ ನಿರ್ಧಾರ ತೆಗೆದುಕೊಳ್ಳುವವರು, ಯಾವುದು ಚಲಿಸಬೇಕು ಮತ್ತು ಯಾವುದು ಬಿಡಬೇಕು ಎಂದು ನಿರ್ಧರಿಸುವ ಗೇಟ್ಕೀಪರ್ಗಳು. ನೀವು ಅವುಗಳನ್ನು ಸರಿಯಾಗಿ ಬರೆಯುವುದನ್ನು ಕಲಿತ一旦, ನೀವು ಕೇವಲ ಸ್ಥಗಿತಗೊಂಡ ಸ್ಕ್ರಿಪ್ಟ್ಗಳನ್ನು ಬರೆಯುವುದನ್ನು ನಿಲ್ಲಿಸಿ, ವಾಸ್ತವವಾಗಿ ಪ್ರತಿಕ್ರಿಯಿಸುವ ಸಾಫ್ಟ್ವೇರ್ ಅನ್ನು ನಿರ್ಮಿಸಲು ಪ್ರಾರಂಭಿಸುತ್ತೀರಿ.
ಕಂಡೀಷನಲ್ಗಳು ಏಕೆ ಮುಖ್ಯ
ಕಂಟ್ರೋಲ್ ಫ್ಲೋ (Control flow) ತರ್ಕದ ಬೆನ್ನೆಲುಬು. ನೀವು ಪಾಸ್ವರ್ಡ್ಗಳನ್ನು ಸರ್ವರ್ಗೆ ಕಳುಹಿಸುವ ಮೊದಲು ಅವುಗಳನ್ನು ವ್ಯಾಲಿಡೇಟ್ ಮಾಡಲು ಕಂಡೀಷನಲ್ಗಳನ್ನು ಬಳಸುತ್ತೀರಿ. ತೆರಿಗೆಯನ್ನು ಲೆಕ್ಕಹಾಕುವ ಮೊದಲು ಶಾಪಿಂಗ್ ಕಾರ್ಟ್ ಖಾಲಿಯಿದೆಯೇ ಎಂದು ನೀವು ಪರಿಶೀಲಿಸುತ್ತೀರಿ. ನೆಟ್ವರ್ಕ್ ರಿಕ್ವೆಸ್ಟ್ ವಿಫಲವಾಗಿದ್ದರೆ, ಖಾಲಿ ಪರದೆಯ ಬದಲಿಗೆ ಎರರ್ (error) ತೋರಿಸಲು ನೀವು ಅದನ್ನು ಪತ್ತೆಹಚ್ಚುತ್ತೀರಿ. ಈ ಎಲ್ಲಾ ಸನ್ನಿವೇಶಗಳು ಒಂದೇ ಸರಳ ಕಲ್ಪನೆಯನ್ನು ಅವಲಂಬಿಸಿವೆ: ಯಾವುದನ್ನಾದರೂ ಮೌಲ್ಯಮಾಪನ ಮಾಡಿ (evaluate), ನಂತರ ಅದಕ್ಕೆ ಅನುಗುಣವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸಿ.
ಕಂಡೀಷನಲ್ಗಳಿಲ್ಲದೆ, ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಸಂಭಾಷಣೆಯ ಬದಲಿಗೆ ಏಕಪಕ್ಷೀಯ ಮಾತುಕತೆಯಂತೆ (monologue) ಇರುತ್ತದೆ. ಅದು ವಿಭಿನ್ನ ಡೇಟಾ ಸನ್ನಿವೇಶಗಳನ್ನು ನಿಭಾಯಿಸಲು, ದೋಷಗಳನ್ನು (errors) ಸುಗಮವಾಗಿ ನಿರ್ವಹಿಸಲು ಅಥವಾ ಬಳಕೆದಾರರ ಕ್ರಮಗಳಿಗೆ ಅರ್ಥಪೂರ್ಣವಾಗಿ ಪ್ರತಿಕ್ರಿಯಿಸಲು ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ. ವಾಸ್ತವ ಪ್ರಪಂಚದ ಅನಿಶ್ಚಿತತೆಯ ಅಡಿಯಲ್ಲಿ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಹೇಗೆ ಚಲಿಸಬೇಕು ಎಂಬುದನ್ನು ನಿಯಂತ್ರಿಸಲು ಅವು ನಿಮಗೆ ಅವಕಾಶ ನೀಡುತ್ತವೆ.
ಮೂಲ if ಸ್ಟೇಟ್ಮೆಂಟ್
ಪ್ರಾರಂಭಿಸಲು ಅತ್ಯಂತ ಸರಳವಾದ ಸ್ಥಳವೆಂದರೆ ಸ್ಟ್ಯಾಂಡ್ಅಲೋನ್ if. ಇದು, "ಒಂದು ವೇಳೆ ಇದು ನಿಜವಾಗಿದ್ದರೆ, ಈ ಕೆಲಸವನ್ನು ಮಾಡು" ಎಂದು ಹೇಳುತ್ತದೆ. ಅಷ್ಟೇ. ಯಾವುದೇ ಪರ್ಯಾಯ ಮಾರ್ಗವಿಲ್ಲ.
if (x % 2 === 0) {
console.log("Even");
}
ಈ ಸ್ನಿಪೆಟ್ನಲ್ಲಿ, ಮಾಡ್ಯುಲಸ್ ಆಪರೇಟರ್ (modulus operator) x ಅನ್ನು ಎರಡು ಇಂದ ಸಮನಾಗಿ ಭಾಗಿಸಬಹುದು ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಶೇಷವು (remainder) ಸೊನ್ನೆಯಾದಾಗ, ಕನ್ಸೋಲ್ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಲಾಗ್ ಮಾಡುತ್ತದೆ. x ಬೆಸ ಸಂಖ್ಯೆಯಾಗಿದ್ದರೆ (odd), ಏನೂ ಆಗುವುದಿಲ್ಲ. ಆ ಬ್ಲಾಕ್ ಅನ್ನು ನಿರ್ಲಕ್ಷಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆ (execution) ಕೆಳಗೆ ಮುಂದುವರಿಯುತ್ತದೆ.
ಆ ಮೌನವಾಗಿ ನಿರ್ಲಕ್ಷಿಸುವುದು ಮುಖ್ಯವಾಗಿದೆ. ಕೆಲವೊಮ್ಮೆ ನೀವು ಕೇವಲ ಒಂದು ಕ್ರಿಯೆಯನ್ನು ಮಾತ್ರ ರಕ್ಷಿಸಲು ಬಯಸುತ್ತೀರಿ. ಬಹುಶಃ ಬಟನ್ ಸಕ್ರಿಯವಾಗಿದ್ದಾಗ ಮಾತ್ರ ಅದಕ್ಕೆ CSS ಕ್ಲಾಸ್ ಅನ್ನು ಸೇರಿಸಲು ಅಥವಾ ಇನ್ಪುಟ್ ಖಾಲಿಯಾಗಿಲ್ಲದಿದ್ದಾಗ ಮಾತ್ರ ಅರೇಗೆ (array) ಐಟಂ ಅನ್ನು ಸೇರಿಸಲು ನೀವು ಬಯಸಬಹುದು. ಅಗತ್ಯವಿಲ್ಲದ ಲಾಜಿಕ್ ಅನ್ನು ಬರೆಯುವ ಒತ್ತಡವಿಲ್ಲದೆ ಕೇವಲ if ಸ್ಟೇಟ್ಮೆಂಟ್ ಅಂತಹ ಕ್ಷಣಗಳನ್ನು ನಿಭಾಯಿಸುತ್ತದೆ.
if-else ಮೂಲಕ ಪರ್ಯಾಯವನ್ನು ಸೇರಿಸುವುದು
ನೈಜ ನಿರ್ಧಾರಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಎರಡು ಮುಖಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ. ಬಳಕೆದಾರರಿಗೆ ಬೇಕಾದ ವಯಸ್ಸು ಇರಬಹುದು ಅಥವಾ ಇಲ್ಲದಿರಬಹುದು. ಪಾವತಿಯು ಯಶಸ್ವಿಯಾಗಿದೆ ಅಥವಾ ಅದು ವಿಫಲವಾಗಿದೆ. if-else ರಚನೆಯು ಎರಡನ್ನೂ ಒಳಗೊಳ್ಳುತ್ತದೆ.
if (age >= 18) {
console.log("Adult");
} else {
console.log("Not an Adult");
}
ಮೊದಲ ಕಂಡೀಷನ್ ತಿರಸ್ಕರಿಸಿದ ಎಲ್ಲವನ್ನೂ else ಬ್ಲಾಕ್ ಹಿಡಿಯುತ್ತದೆ. ಇದು ಒಂದು ಸ್ಪಷ್ಟವಾದ ಬೈನರಿ ಬ್ರಾಂಚ್ ಅನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ. ಈ ಮಾದರಿಯು ಟೋಗಲ್ಸ್ (toggles), ಅನುಮತಿಗಳು (permissions) ಮತ್ತು ಫೀಚರ್ ಫ್ಲಾಗ್ಗಳಿಗೆ (feature flags) ಚೆನ್ನಾಗಿ ಕೆಲಸ ಮಾಡುತ್ತದೆ. ಪ್ರತಿ ಬ್ಲಾಕ್ನ ಒಳಗಿನ ಲಾಜಿಕ್ ಅನ್ನು ಕೇಂದ್ರೀಕೃತವಾಗಿಡಿ. ನೀವು ಒಂದೇ ಬ್ರಾಂಚ್ನಲ್ಲಿ ಅತಿಯಾದ ಕಾರ್ಯಗಳನ್ನು ಜೋಡಿಸುತ್ತಿದ್ದರೆ, ಅದು ಕೆಲಸವನ್ನು ಸಣ್ಣ ಫಂಕ್ಷನ್ಗಳಾಗಿ ವಿಂಗಡಿಸಲು ಸೂಚನೆಯಾಗಿದೆ.
else if ಮೂಲಕ ಬಹು ಹಾದಿಗಳನ್ನು ಪರಿಶೀಲಿಸುವುದು
ಜೀವನವು ಅಪರೂಪವಾಗಿ ಕೇವಲ ಎರಡು ಆಯ್ಕೆಗಳನ್ನು ಮಾತ್ರ ನೀಡುತ್ತದೆ. ನೀವು ಒಂದು ಸಂಖ್ಯೆಯನ್ನು ಧನಾತ್ಮಕ (positive), ಋಣಾತ್ಮಕ (negative) ಅಥವಾ ಸೊನ್ನೆ ಎಂದು ವರ್ಗೀಕರಿಸಬೇಕಾಗಬಹುದು. ತೂಕದ ಆಧಾರದ ಮೇಲೆ ನೀವು ಶಿಪ್ಪಿಂಗ್ ದರವನ್ನು ನಿಗದಿಪಡಿಸಬಹುದು. ಕ್ರಮಬದ್ಧವಾದ ಬಹು ಹೋಲಿಕೆಗಳಿಗಾಗಿ else if ಬಳಸಿ.
if (x > 0) {
console.log("Positive");
} else if (x < 0) {
console.log("Negative");
} else {
console.log("Zero");
}
JavaScript ಇವುಗಳನ್ನು ಮೇಲಿನಿಂದ ಕೆಳಕ್ಕೆ ಮೌಲ್ಯಮಾಪನ ಮಾಡುತ್ತದೆ. ಒಂದು ಕಂಡೀಷನ್ ಪಾಸಾದ ತಕ್ಷಣ, ಅದು ಆ ಬ್ಲಾಕ್ ಅನ್ನು ಚಲಿಸುತ್ತದೆ ಮತ್ತು ಉಳಿದವುಗಳನ್ನು ನಿರ್ಲಕ್ಷಿಸುತ್ತದೆ. ಇಲ್ಲಿ ಕ್ರಮ (order) ಮುಖ್ಯವಾಗಿದೆ. ನೀವು x > 100 ಅನ್ನು ಪರಿಶೀಲಿಸಿದ ನಂತರ x > 0 ಅನ್ನು ಪರಿಶೀಲಿಸಿದರೆ, ಕಟ್ಟುನಿಟ್ಟಾದ ಪರಿಶೀಲನೆಯು ಎಂದಿಗೂ ನಡೆಯುವುದಿಲ್ಲ ಏಕೆಂದರೆ ಸಡಿಲವಾದ ಪರಿಶೀಲನೆಯು ಅದನ್ನು ಮೊದಲು ಹಿಡಿಯುತ್ತದೆ. else if ಅನ್ನು ಆದ್ಯತಾ ಪಟ್ಟಿಯಂತೆ (priority list) ಭಾವಿಸಿ.
switch ಸ್ಟೇಟ್ಮೆಂಟ್
ನೀವು ಒಂದು ಮೌಲ್ಯವನ್ನು ಅನೇಕ ವಿಭಿನ್ನ ಆಯ್ಕೆಗಳೊಂದಿಗೆ ಹೋಲಿಸಿದಾಗ, ಉದ್ದವಾದ else if ಸ್ಟೇಟ್ಮೆಂಟ್ಗಳ ಸರಪಳಿ ಪುನರಾವರ್ತಿತವಾಗಿ ಕಾಣಿಸಬಹುದು. switch ಸ್ಟೇಟ್ಮೆಂಟ್ ಅದನ್ನು ಸುಲಭಗೊಳಿಸುತ್ತದೆ. ಇದು ಒಂದು ಎಕ್ಸ್ಪ್ರೆಶನ್ ಅನ್ನು case ಕ್ಲಾಸ್ಗಳೊಂದಿಗೆ ಹೊಂದಿಸುತ್ತದೆ ಮತ್ತು ಹೊಂದಿಕೆಯಾಗುವ ಬ್ಲಾಕ್ ಅನ್ನು ಚಲಿಸುತ್ತದೆ.
switch (true) {
case marks >= 90:
Branch = "Computer science";
break;
case marks >= 80:
Branch = "Mechanical";
break;
default:
Branch = "Other";
}
ಈ ಉದಾಹರಣೆಯು ಬೂಲಿಯನ್ (boolean) ಕಂಡೀಷನ್ಗಳನ್ನು ನೇರವಾಗಿ ಮೌಲ್ಯಮಾಪನ ಮಾಡಲು switch(true) ಅನ್ನು ಬಳಸುತ್ತದೆ, ಇದು ನಿಮ್ಮ ಲಾಜಿಕ್ ನಿಖರವಾದ ಸಮಾನತೆಗಿಂತ ಹೆಚ್ಚಾಗಿ ವ್ಯಾಪ್ತಿಗಳ ಮೇಲೆ (ranges) ಅವಲಂಬಿತವಾಗಿದ್ದಾಗ ಬಳಸುವ ಸಾಮಾನ್ಯ JavaScript ಮಾದರಿಯಾಗಿದೆ. break ಕೀವರ್ಡ್ ಅತ್ಯಗತ್ಯ. ಇಲ್ಲದಿದ್ದರೆ, ಅದು ಹೊಂದಿಕೆಯಾಗಲಿ ಅಥವಾ ಇಲ್ಲದಿರಲಿ, ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯು ಮುಂದಿನ case ಗೆ ಹೋಗುತ್ತದೆ, ಇದು ನೀವು ಬಯಸುವ ವಿಷಯವಲ್ಲ. default ಕ್ಲಾಸ್ ಕೊನೆಯ else ನಂತೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಇದು ಹಿಂದಿನ case ಗಳಿಗೆ ಹೊಂದಿಕೆಯಾಗದ ಯಾವುದನ್ನಾದರೂ ಹಿಡಿಯುತ್ತದೆ.
ನಿಮಗೆ ಸ್ಪಷ್ಟವಾದ, ಸ್ಥಿರವಾದ ಆಯ್ಕೆಗಳಿದ್ದಾಗ switch ಅದ್ಭುತವಾಗಿ ಕೆಲಸ ಮಾಡುತ್ತದೆ. ವಿಶೇಷವಾಗಿ ಪ್ರತಿ ಬ್ರಾಂಚ್ ಸರಳವಾಗಿ ಒಂದು ಮೌಲ್ಯವನ್ನು ನಿಯೋಜಿಸಿದಾಗ ಅಥವಾ ಒಂದೇ ಫಂಕ್ಷನ್ ಅನ್ನು ಕರೆ ಮಾಡಿದಾಗ, ಇದು ಉದ್ದವಾದ else if ಬ್ಲಾಕ್ಗಳಿಗಿಂತ ಸ್ಕ್ಯಾನ್ ಮಾಡಲು ಸುಲಭವಾಗಿರುತ್ತದೆ.
ಟೆರ್ನರಿ ಆಪರೇಟರ್ (The Ternary Operator)
ಸಣ್ಣ ಬೈನರಿ ನಿರ್ಧಾರಗಳಿಗಾಗಿ, ಟೆರ್ನರಿ ಆಪರೇಟರ್ ವಿಷಯಗಳನ್ನು ಸಂಕ್ಷಿಪ್ತವಾಗಿಡುತ್ತದೆ. ಇದು ಮೂರು ಆಪರೆಂಡ್ಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ: ಒಂದು ಕಂಡೀಷನ್, ನಿಜವಾಗಿದ್ದರೆ ಒಂದು ಮೌಲ್ಯ ಮತ್ತು ಸುಳ್ಳಾಗಿದ್ದರೆ ಒಂದು ಮೌಲ್ಯ.
const result = (age >= 18) ? "Eligible" : "Not eligible";
ನೀವು ಇದನ್ನು ತ್ವರಿತ ನಿಯೋಜನೆಗಳು (assignments) ಅಥವಾ ಇನ್ಲೈನ್ ರಿಟರ್ನ್ಗಳಿಗಾಗಿ ಬಳಸಬಹುದು. ಫಲಿತಾಂಶವು ಸರಳ ಎಕ್ಸ್ಪ್ರೆಶನ್ ಆಗಿದ್ದಾಗ ಇದು ಚೆನ್ನಾಗಿ ಕೆಲಸ ಮಾಡುತ್ತದೆ. ಟೆರ್ನರಿಗಳನ್ನು ಮೂರು ಹಂತಗಳ ಆಳಕ್ಕೆ ನೆಸ್ಟಿಂಗ್ (nesting) ಮಾಡುವ ಆಸೆಯನ್ನು ತಡೆಯಿರಿ. ನೆಸ್ಟೆಡ್ ಟೆರ್ನರಿ ಸಾಲುಗಳನ್ನು ಉಳಿಸಬಹುದು, ಆದರೆ ಅದು ಓದುವಿಕೆಯನ್ನು (readability) ಕಡಿಮೆ ಮಾಡುತ್ತದೆ. ನಿಮ್ಮ ಲಾಜಿಕ್ ಬೆಳೆದಂತೆ, ಫೈಲ್ ತೆರೆಯುವ ಮುಂದಿನ ಡೆವಲಪರ್ಗೆ if-else ಬ್ಲಾಕ್ ಸಾಮಾನ್ಯವಾಗಿ ಹೆಚ್ಚು ಅನುಕೂಲಕರವಾಗಿರುತ್ತದೆ.
ನೆಸ್ಟೆಡ್ ನಿರ್ಧಾರಗಳು (Nested Decisions)
ಸಂಕೀರ್ಣ ತರ್ಕವು ಕೆಲವೊಮ್ಮೆ ಅನುಸರಣಾ ಪ್ರಶ್ನೆಗಳನ್ನು ಕೇಳುವ ಅಗತ್ಯವನ್ನು ಹೊಂದಿರುತ್ತದೆ. ನಿರ್ಧಾರವನ್ನು ಹೆಚ್ಚು ನಿಖರಗೊಳಿಸಲು ನೀವು ಒಂದು if ಅನ್ನು ಮತ್ತೊಂದು if ಒಳಗಡೆ ಬಳಸಬಹುದು.
if (weather === "sunny") {
if (temp > 30) {
console.log("