Every program needs to react. A user clicks a button. An API returns data. A form field goes blank. Without a way to bra

ஒவ்வொரு நிரலும் எதிர்வினையாற்ற வேண்டும். ஒரு பயனர் பொத்தானைக் கிளிக் செய்கிறார். ஒரு API தரவைத் திருப்பித் தருகிறது. ஒரு படிவத் தளம் (form field) காலியாகிறது. கிளைகளாகப் பிரிய ஒரு வழி இல்லையென்றால், உண்மையில் என்ன நடக்கிறது என்பதைப் பொருட்படுத்தாமல் உங்கள் குறியீடு வரி வரியாக இயங்கும். நிபந்தனைகள் (Conditionals) JavaScript-க்குத் தேர்ந்தெடுக்கும் திறனை வழங்குகின்றன. அவை உங்கள் செயல்பாடுகளுக்குள் (functions) முடிவெடுப்பவர்கள், எது இயங்க வேண்டும் மற்றும் எது தவிர்க்கப்பட வேண்டும் என்பதைத் தீர்மானிக்கும் வாயிற்காவலர்கள். அவற்றை எவ்வாறு சிறப்பாக எழுதுவது என்பதை நீங்கள் புரிந்து கொண்டால், நீங்கள் கடினமான ஸ்கிரிப்ட்களை எழுதுவதை நிறுத்திவிட்டு, உண்மையில் பதிலளிக்கும் மென்பொருள்களை உருவாக்கத் தொடங்குவீர்கள்.

நிபந்தனைகள் ஏன் முக்கியம்

கட்டுப்பாட்டு ஓட்டம் (Control flow) என்பது தர்க்கத்தின் முதுகெலும்பு. ஒரு கடவுச்சொல்லைச் சேவையகத்திற்கு (server) அனுப்புவதற்கு முன் அதைச் சரிபார்க்க நீங்கள் நிபந்தனைகளைப் பயன்படுத்துகிறீர்கள். வரி கணக்கிடுவதற்கு முன் ஷாப்பிங் கார்ட் காலியாக உள்ளதா என்று சரிபார்க்கிறீர்கள். ஒரு நெட்வொர்க் கோரிக்கை தோல்வியடைந்தால், காலியான திரைக்குப் பதிலாக ஒரு பிழையைக் காட்ட நீங்கள் அதைக் கண்டறிகிறீர்கள். இந்தச் சூழல்கள் அனைத்தும் ஒரே எளிய கருத்தை அடிப்படையாகக் கொண்டவை: ஒன்றை மதிப்பீடு செய்யுங்கள், பின்னர் அதற்கேற்ப செயல்படுங்கள்.

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

அடிப்படை if கூற்று

தொடங்குவதற்கு எளிமையான இடம் தனித்த if ஆகும். இது, "இந்த விஷயம் உண்மையாக இருந்தால், இந்த வேலையைச் செய்" என்று சொல்கிறது. அவ்வளவுதான். மாற்று வழி அல்லது மாற்றுப் பாதை எதுவும் இல்லை.

if (x % 2 === 0) {
    console.log("Even");
}

இந்தத் துண்டில் (snippet), மாடுலஸ் ஆபரேட்டர் (modulus operator) x இரண்டால் மீதியின்றி வகுபடுகிறதா என்று சரிபார்க்கிறது. மீதி பூஜ்ஜியமாக இருக்கும்போது, console அந்தத் தொடரை (string) பதிவு செய்கிறது. x ஒற்றைப்படை எண்ணாக இருந்தால், எதுவும் நடக்காது. அந்தத் தொகுதி (block) புறக்கணிக்கப்பட்டு, இயக்கம் கீழே தொடரும்.

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

if-else மூலம் ஒரு மாற்றத்தைச் சேர்த்தல்

உண்மையான முடிவுகள் பொதுவாக இரண்டு பக்கங்களைக் கொண்டிருக்கும். பயனருக்குத் தேவையான வயது இருக்கலாம் அல்லது இல்லாமலும் இருக்கலாம். பணம் செலுத்துதல் வெற்றியடைந்திருக்கலாம் அல்லது தோல்வியடைந்திருக்கலாம். if-else அமைப்பு இரண்டையும் உள்ளடக்கியது.

if (age >= 18) {
    console.log("Adult");
} else {
    console.log("Not an Adult");
}

முதல் நிபந்தனை நிராகரித்த அனைத்தையும் else தொகுதி பிடித்துக் கொள்கிறது. இது ஒரு தெளிவான இருமக் கிளையை (binary branch) உருவாக்குகிறது. இந்த முறை டாக்லர்கள் (toggles), அனுமதிகள் (permissions) மற்றும் அம்சம் கொடிகள் (feature flags) ஆகியவற்றிற்கு நன்றாகப் பொருந்தும். ஒவ்வொரு தொகுதியையும் உள்ளே இருக்கும் தர்க்கத்தைக் கவனமாக வைத்திருக்கவும். ஒரு கிளையில் நீங்கள் மிக அதிகமான பணிகளைச் சேர்க்கத் தொடங்கினால், அது வேலையைச் சிறிய செயல்பாடுகளாகப் பிரிக்க வேண்டியதற்கான அறிகுறியாகும்.

else if மூலம் பல பாதைகளைச் சரிபார்த்தல்

வாழ்க்கை அரிதாகவே இரண்டு தேர்வுகளை மட்டுமே வழங்குகிறது. ஒரு எண்ணை நேர்மறை, எதிர்மறை அல்லது பூஜ்ஜியம் என வகைப்படுத்த வேண்டியிருக்கலாம். எடையின் அடிப்படையில் நீங்கள் கப்பல் கட்டணத்தை ஒதுக்கலாம். வரிசைப்படுத்தப்பட்ட பல ஒப்பீடுகளுக்கு, else if-ஐப் பயன்படுத்தவும்.

if (x > 0) {
    console.log("Positive");
} else if (x < 0) {
    console.log("Negative");
} else {
    console.log("Zero");
}

JavaScript இவற்றை மேலிருந்து கீழாக மதிப்பீடு செய்கிறது. ஒரு நிபந்தனை நிறைவேறியவுடன், அது அந்தத் தொகுதியை இயக்கிவிட்டு மற்றவற்றைத் தவிர்க்கிறது. வரிசை முக்கியமானது. நீங்கள் x > 100-ஐச் சரிபார்த்த பிறகு x > 0-ஐச் சரிபார்த்தால், தளர்வான நிபந்தனை முதலில் அதைப் பிடித்துவிடும் என்பதால், கடுமையான நிபந்தனை ஒருபோதும் இயங்காது. else if-ஐ ஒரு முன்னுரிமைப் பட்டியலாகக் கருதவும்.

switch கூற்று

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

switch (true) {
    case marks >= 90:
        Branch = "Computer science";
        break;
    case marks >= 80:
        Branch = "Mechanical";
        break;
    default:
        Branch = "Other";
}

இந்த உதாரணம் பூலியன் (boolean) நிபந்தனைகளை நேரடியாக மதிப்பீடு செய்ய switch(true) ஐப் பயன்படுத்துகிறது, இது உங்கள் தர்க்கம் துல்லியமான சமநிலையை விட வரம்புகளைச் சார்ந்து இருக்கும்போது பயன்படுத்தப்படும் ஒரு பொதுவான JavaScript முறையாகும். break முக்கியச் சொல். அது இல்லையென்றால், அடுத்த case பொருந்துகிறதா இல்லையா என்பதைப் பொருட்படுத்தாமல் இயக்கம் அடுத்த பகுதிக்குச் செல்லும், இது நீங்கள் விரும்புவது அல்ல. default பிரிவு ஒரு இறுதி else போலச் செயல்பட்டு, முந்தைய பிரிவுகளில் பொருந்தாத எதையும் பிடித்துக் கொள்கிறது.

தெளிவான, நிலையான விருப்பங்கள் இருக்கும்போது switch சிறப்பாகச் செயல்படும். குறிப்பாக ஒவ்வொரு கிளையும் ஒரு மதிப்பை ஒதுக்குகிறது அல்லது ஒரு செயல்பாட்டை அழைக்கிறது என்றால், பல else if தொகுப்புகளை விட இதை எளிதாகப் பார்த்துப் புரிந்துகொள்ள முடியும்.

டெர்னரி ஆபரேட்டர் (Ternary Operator)

குறுகிய இரும முடிவுகளுக்கு, டெர்னரி ஆபரேட்டர் விஷயங்களைச் சுருக்கமாக வைத்திருக்கும். இது மூன்று செயல்பாட்டிகளைக் (operands) கொள்கிறது: ஒரு நிபந்தனை, உண்மையாக இருந்தால் ஒரு மதிப்பு, மற்றும் பொய்யாக இருந்தால் ஒரு மதிப்பு.

const result = (age >= 18) ? "Eligible" : "Not eligible";

இதை விரைவான ஒதுக்கீடுகளுக்கு அல்லது இன்லைன் ரிட்டர்ன்களுக்கு (inline returns) பயன்படுத்தலாம். இதன் முடிவு ஒரு எளிய வெளிப்பாடாக இருக்கும்போது இது நன்றாகச் செயல்படும். டெர்னரிகளை மூன்று நிலைகளுக்குத் தரம் இறக்கி (nesting) எழுத வேண்டாம். ஒரு நெஸ்டட் டெர்னரி வரிகளைக் குறைக்கலாம், ஆனால் அது வாசிப்புத் திறனை (readability) பாதிக்கும். உங்கள் தர்க்கம் வளரும்போது, கோப்பைத் திறக்கும் அடுத்த டெவலப்பருக்கு if-else தொகுதி பொதுவாக எளிதாக இருக்கும்.

நெஸ்டட் முடிவுகள் (Nested Decisions)

சிக்கலான தர்க்கத்திற்கு சில நேரங்களில் தொடர்ச்சியான கேள்விகளைக் கேட்க வேண்டியிருக்கும். ஒரு முடிவைச் செம்மைப்படுத்த, மற்றொரு if-க்குள் ஒரு if-ஐ நீங்கள் உள்ளமைக்கலாம்.

if (weather === "sunny") {
    if (temp > 30) {
        console.log("