Every useful program eventually hits a decision point. Should this button submit the form or show an error? Does this us

ஒவ்வொரு பயனுள்ள நிரலும் இறுதியில் ஒரு முடிவு எடுக்கும் புள்ளியைச் சந்திக்கும். இந்த பட்டன் படிவத்தைச் சமர்ப்பிக்க வேண்டுமா அல்லது பிழையைக் காட்ட வேண்டுமா? இந்த பயனர் நிர்வாகத் தரவுப் பலகையைப் (admin dashboard) பார்க்க வேண்டுமா அல்லது விருந்தினர் பார்வையை (guest view) பார்க்க வேண்டுமா? JavaScript இந்த கேள்விகளுக்கு நிபந்தனை கூற்றுகள் (conditional statements) மூலம் பதிலளிக்கிறது. அவை உங்கள் குறியீட்டின் கட்டுப்பாட்டு வால்வுகள் போன்றவை: ஒரு பாதையைத் திறக்கின்றன, மற்றொன்றை மூடுகின்றன, இவை அனைத்தும் ஒரு வெளிப்பாடு உண்மை (true) அல்லது பொய் (false) என்று தீர்மானிக்கப்படுவதைப் பொறுத்தது. அவை இல்லையென்றால், உங்கள் ஸ்கிரிப்ட் அதைப் பயன்படுத்தும் நபரின் செயல்பாடுகளுக்குப் பதிலளிக்காமல், மேலிருந்து கீழாகத் தொடர்ந்து இயங்கிக்கொண்டே இருக்கும்.

மிக எளிமையான கிளை: if

if கூற்று என்பது நீங்கள் முதலில் கடந்து செல்லும் நுழைவாயில் போன்றது. நீங்கள் அடைப்புக்குறிக்குள் ஒரு நிபந்தனையை வைக்கிறீர்கள். அந்த நிபந்தனை true என்று தீர்மானிக்கப்பட்டால், அதற்கு கீழே உள்ள குறியீடு இயங்கும். அது false என்று தீர்மானிக்கப்பட்டால், JavaScript அந்தப் பகுதியைத் தவிர்த்துவிட்டு கோப்பின் அடுத்த பகுதிக்குச் செல்லும்.

இது எளிமையான, ஒருமுறை மட்டும் செய்யப்படும் சரிபார்ப்புகளுக்குத் துல்லியமாகத் தேவைப்படும் ஒன்று. ஒரு சர்வர் மூலம் எதையும் அனுப்புவதற்கு முன், ஒரு படிவத் தகவலைச் (form field) சரிபார்ப்பதாகக் கற்பனை செய்து பாருங்கள்:

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

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

email இல்லையென்றால், சமர்ப்பிக்க முடியாது. இந்தத் தர்க்கம் (logic) நேரடியானது மற்றும் தெளிவானது. ஒரு விசேஷமான நிகழ்வை மட்டும் தடுத்த நிறுத்த வேண்டும் மற்றும் மாற்று நடவடிக்கை தேவையில்லை எனும் போது if-ஐப் பயன்படுத்தவும்.

ஒன்று அல்லது இன்னொன்று: if...else

பெரும்பாலான நிஜ வாழ்க்கை முடிவுகள் இரண்டு பக்கங்களைக் கொண்டவை. if...else ஜோடி சரியாக அதைச் செய்கிறது. நிபந்தனை உண்மையாக இருக்கும்போது ஒரு பகுதி இயங்கும், அது பொய்யாக இருக்கும்போது மற்றொன்று இயங்கும். இந்த இரண்டு பாதைகளும் ஒன்றுக்கொன்று முரணானவை (mutually exclusive).

பக்கத்தைப் பதிவேற்றும் போது (page load) டார்க்-மோட் (dark-mode) சரிபார்ப்பைக் கற்பனை செய்து பாருங்கள்:

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

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

பிரவுசர் (browser) இரண்டு வகுப்புகளையும் (classes) சேர்த்துச் சேர்க்காது. அது ஒரு பாதையைத் தேர்ந்தெடுத்து, அதை இயக்கிவிட்டு அடுத்த நிலைக்குச் செல்லும். உங்கள் தர்க்கம் இரண்டு சாத்தியமான முடிவுகளாகத் தெளிவாகப் பிரியும் போதெல்லாம், இந்த அமைப்பைப் பயன்படுத்தலாம்.

பல வழிகள்: if...else if...else

ஒவ்வொரு பிரச்சனையும் இருமப் பண்பு (binary) கொண்டவை அல்ல. சில நேரங்களில் உங்களுக்குப் பல சாத்தியக்கூறுகளின் ஏணி தேவைப்படலாம். if...else if...else சங்கிலி வரிசையாகப் பல நிபந்தனைகளைச் சோதிக்க அனுமதிக்கிறது. JavaScript அவற்றை மேலிருந்து கீழாக மதிப்பீடு செய்து, எந்த நிபந்தனை முதன்முதலில் உண்மையாகத் தீர்மானிக்கப்படுகிறதோ, அந்தப் பகுதியை மட்டும் இயக்கும். அந்தப் பொருத்தம் கிடைத்த பிறகு, ஏணியின் மீதமுள்ள பகுதிகள் புறக்கணிக்கப்படும்.

மதிப்பெண்ணை எழுத்துத் தரமாக (letter grade) மாற்றுவது ஒரு சிறந்த உதாரணம்:

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

இங்கு வரிசைமுறை மிக முக்கியமானது. நீங்கள் score >= 90-க்கு முன்னால் score >= 70-ஐச் சோதித்தால், கிட்டத்தட்ட அனைத்துத் தேர்ச்சி பெற்ற மதிப்பெண்களும் C பிரிவிலேயே சிக்கிக்கொள்ளும், ஏனெனில் முதல் உண்மையான பொருத்தம் வெற்றி பெறும். உங்கள் நிபந்தனைகளை மிகவும் துல்லியமானவற்றிலிருந்து பொதுவானவை வரை வரிசைப்படுத்தவும், மேலும் எதையும் தவறவிடாமல் இருக்க எப்போதும் இறுதியில் ஒரு else-ஐச் சேர்க்கவும்.

நிலையான மதிப்புகளைப் பொருத்துதல்: switch

நீங்கள் ஒரு மாறியை (variable) தெரிந்த மாறிலிகளின் (constants) பட்டியலுடன் ஒப்பிடும்போது, நீண்ட if...else சங்கிலி குழப்பத்தை ஏற்படுத்தும். switch கூற்று விஷயங்களை எளிமையாக்குகிறது. இது ஒரு வெளிப்பாட்டை (expression) ஒருமுறை மதிப்பீடு செய்து, பின்னர் அதை 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)

டெர்னரி ஆபரேட்டர்—? : என எழுதப்படுகிறது—இது ஒரு வெளிப்பாடு (expression), கூற்று (statement) அல்ல. அந்த வேறுபாடு முக்கியமானது.