ഓരോ പ്രോഗ്രാമിനും പ്രതികരിക്കേണ്ടതുണ്ട്. ഒരു ഉപയോക്താവ് ഒരു ബട്ടൺ ക്ലിക്ക് ചെയ്യുന്നു. ഒരു API ഡാറ്റ നൽകുന്നു. ഒരു ഫോം ഫീൽഡ് ശൂന്യമാകുന്നു. ശാഖകളായി (branch) തിരിയാനുള്ള ഒരു മാർഗ്ഗമില്ലെങ്കിൽ, യഥാർത്ഥത്തിൽ എന്ത് സംഭവിക്കുന്നു എന്നതിനെ പരിഗണിക്കാതെ തന്നെ നിങ്ങളുടെ കോഡ് ഓരോ വരിയായി പ്രവർത്തിച്ചുകൊണ്ടേയിരിക്കും. കണ്ടിഷണലുകൾ (Conditionals) ജാവാസ്ക്രിപ്റ്റിന് തിരഞ്ഞെടുക്കാനുള്ള ആ കഴിവ് നൽകുന്നു. അവ നിങ്ങളുടെ ഫംഗ്ഷനുകൾക്കുള്ളിലെ തീരുമാനങ്ങൾ എടുക്കുന്നവരും, ഏതാണ് പ്രവർത്തിക്കേണ്ടതെന്നും ഏതാണ് ഒഴിവാക്കേണ്ടതെന്നും തീരുമാനിക്കുന്ന കാവൽക്കാരും (gatekeepers) ആണ്. അവ എങ്ങനെ നന്നായി എഴുതാമെന്ന് നിങ്ങൾ മനസ്സിലാക്കിയാൽ, കടുപ്പമേറിയ സ്ക്രിപ്റ്റുകൾ എഴുതുന്നത് നിർത്തി യഥാർത്ഥത്തിൽ പ്രതികരിക്കുന്ന സോഫ്റ്റ്‌വെയറുകൾ നിർമ്മിക്കാൻ നിങ്ങൾ തുടങ്ങും.

എന്തുകൊണ്ടാണ് കണ്ടിഷണലുകൾ പ്രധാനമാകുന്നത്

കൺട്രോൾ ഫ്ലോ (Control flow) ആണ് ലോജിക്കിന്റെ നട്ടെല്ല്. ഒരു പാസ്‌വേഡ് സെർവറിലേക്ക് അയക്കുന്നതിന് മുമ്പ് അത് ശരിയാണോ എന്ന് പരിശോധിക്കാൻ നിങ്ങൾ കണ്ടിഷണലുകൾ ഉപയോഗിക്കുന്നു. ടാക്സ് കണക്കാക്കുന്നതിന് മുമ്പ് ഷോപ്പിംഗ് കാർട്ട് ശൂന്യമാണോ എന്ന് നിങ്ങൾ പരിശോധിക്കുന്നു. ഒരു നെറ്റ്‌വർക്ക് റിക്വസ്റ്റ് പരാജയപ്പെട്ടോ എന്ന് നിങ്ങൾ കണ്ടെത്തുന്നു, അങ്ങനെ ഒരു ശൂന്യമായ സ്ക്രീനിന് പകരം ഒരു എറർ മെസ്സേജ് കാണിക്കാൻ സാധിക്കുന്നു. ഈ സാഹചര്യങ്ങളെല്ലാം ഒരേ ലളിതമായ ആശയത്തെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്: എന്തെങ്കിലും ഒന്ന് വിലയിരുത്തുക (evaluate), തുടർന്ന് അതിനനുസരിച്ച് പ്രവർത്തിക്കുക.

കണ്ടിഷണലുകൾ ഇല്ലെങ്കിൽ, നിങ്ങളുടെ ആപ്ലിക്കേഷൻ ഒരു സംഭാഷണത്തിന് പകരം ഒരു ഏകപക്ഷീയമായ പ്രസംഗം (monologue) പോലെയാകും. വ്യത്യസ്ത ഡാറ്റാ സാഹചര്യങ്ങൾ കൈകാര്യം ചെയ്യാനോ, എററുകൾ കൃത്യമായി നിയന്ത്രിക്കാനോ, ഉപയോക്താവിന്റെ പ്രവർത്തനങ്ങളോട് അർത്ഥവത്തായ രീതിയിൽ പ്രതികരിക്കാനോ അതിന് കഴിയില്ല. യഥാർത്ഥ ലോകത്തിലെ അനിശ്ചിതത്വങ്ങൾക്കിടയിലും നിങ്ങളുടെ പ്രോഗ്രാം എങ്ങനെ പ്രവർത്തിക്കണം എന്ന് നിയന്ത്രിക്കാൻ അവ നിങ്ങളെ അനുവദിക്കുന്നു.

അടിസ്ഥാന if സ്റ്റേറ്റ്‌മെന്റ്

തുടങ്ങാൻ ഏറ്റവും ലളിതമായ മാർഗ്ഗം ഒറ്റപ്പെട്ട ഒരു if ആണ്. ഇത് പറയുന്നത്, "ഇത് ശരിയാണെങ്കിൽ, ഈ ജോലി ചെയ്യുക" എന്നാണ്. അത്രമാത്രം. മറ്റ് പകരക്കാരോ ബദൽ വഴികളോ ഇതിലില്ല.

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

ഈ സ്നിപ്പറ്റിൽ, മോഡുലസ് ഓപ്പറേറ്റർ (modulus operator) x-നെ രണ്ട് കൊണ്ട് കൃത്യമായി ഹരിക്കാൻ കഴിയുമോ എന്ന് പരിശോധിക്കുന്നു. ശിഷ്ടം പൂജ്യം ആണെങ്കിൽ, കോൺസോൾ ആ സ്ട്രിംഗ് പ്രിന്റ് ചെയ്യുന്നു. x ഒറ്റസംഖ്യയാണെങ്കിൽ ഒന്നും സംഭവിക്കില്ല. ആ ബ്ലോക്ക് അവഗണിക്കപ്പെടുകയും പ്രോഗ്രാം താഴേക്ക് തുടരുകയും ചെയ്യുന്നു.

ആ നിശബ്ദമായ അവഗണന പ്രധാനമാണ്. ചിലപ്പോൾ ഒരു പ്രത്യേക പ്രവർത്തനം മാത്രം നിയന്ത്രിക്കാൻ നിങ്ങൾ ആഗ്രഹിച്ചേക്കാം. ഒരു ബട്ടൺ ആക്റ്റീവ് ആണെങ്കിൽ മാത്രം അതിലേക്ക് ഒരു 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");
}

ജാവാസ്ക്രിറ്റ് ഇവ മുകളിൽ നിന്ന് താഴേക്ക് വിലയിരുത്തുന്നു. ഒരു കണ്ടീഷൻ ശരിയായാൽ ഉടൻ തന്നെ ആ ബ്ലോക്ക് പ്രവർത്തിപ്പിക്കുകയും ബാക്കിയുള്ളവ അവഗണിക്കുകയും ചെയ്യുന്നു. ഇവിടെ ക്രമം (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";
}

ഈ ഉദാഹരണത്തിൽ ബൂളിയൻ കണ്ടീഷനുകൾ നേരിട്ട് വിലയിരുത്താൻ switch(true) ഉപയോഗിക്കുന്നു. കൃത്യമായ തുല്യതയേക്കാൾ (exact equality) പരിധിയിലുള്ള (ranges) ലോജിക്കാണ് നിങ്ങളുടെ പ്രോഗ്രാം ഉപയോഗിക്കുന്നതെങ്കിൽ ഇത് ജാവാസ്ക്രിപ്റ്റിലെ ഒരു സാധാരണ രീതിയാണ്. break കീവേഡ് അത്യാവശ്യമാണ്. അത് ഇല്ലെങ്കിൽ, കണ്ടീഷൻ ശരിയാണോ അല്ലയോ എന്ന് നോക്കാതെ തന്നെ അടുത്ത കേസിലേക്ക് പ്രോഗ്രാം പോകും, ഇത് സാധാരണയായി നമ്മൾ ആഗ്രഹിക്കുന്നതല്ല. default ക്ലോസ് ഒരു അവസാന else പോലെ പ്രവർത്തിക്കുന്നു, മുൻപത്തെ കേസുകളിൽ ഉൾപ്പെടാത്തവയെ ഇത് പിടിച്ചെടുക്കുന്നു.

വ്യക്തവും നിശ്ചിതവുമായ ഓപ്ഷനുകൾ ഉള്ളപ്പോൾ switch മികച്ചതാണ്. ഒരുപാട് else if ബ്ലോക്കുകൾ നോക്കുന്നതിനേക്കാൾ എളുപ്പത്തിൽ ഇത് മനസ്സിലാക്കാം, പ്രത്യേകിച്ച് ഓരോ ശാഖയും ഒരു മൂല്യം നൽകുകയോ അല്ലെങ്കിൽ ഒരു ഫംഗ്ഷൻ വിളിക്കുകയോ മാത്രമാണ് ചെയ്യുന്നതെങ്കിൽ.

ടെർണറി ഓപ്പറേറ്റർ (Ternary Operator)

ചെറിയ ബൈനറി തീരുമാനങ്ങൾക്ക് ടെർണറി ഓപ്പറേറ്റർ കാര്യങ്ങൾ ലളിതമാക്കുന്നു. ഇതിന് മൂന്ന് ഓപ്പറന്റുകൾ ആവശ്യമാണ്: ഒരു കണ്ടീഷൻ, കണ്ടീഷൻ ശരിയാണെങ്കിൽ നൽകേണ്ട മൂല്യം, കണ്ടീഷൻ തെറ്റാണെങ്കിൽ നൽകേണ്ട മൂല്യം.

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

വേഗത്തിലുള്ള അസൈൻമെന്റുകൾക്കോ (assignments) ഇൻലൈൻ റിട്ടേണുകൾക്കോ (inline returns) ഇത് ഉപയോഗിക്കാം. ഫലം ഒരു ലളിതമായ എക്സ്പ്രഷൻ ആണെങ്കിൽ ഇത് നന്നായി പ്രവർത്തിക്കും. ടെർണറികൾ ഒന്നിലധികം തവണ അടുക്കിവെച്ച് (nesting) ഉപയോഗിക്കരുത്. ഒരു നെസ്റ്റഡ് ടെർണറി വരികൾ ലാഭിച്ചേക്കാം, പക്ഷേ അത് കോഡിന്റെ വായനാക്ഷമത (readability) കുറയ്ക്കും. നിങ്ങളുടെ ലോജിക് സങ്കീർണ്ണമാകുമ്പോൾ, ഫയൽ തുറക്കുന്ന അടുത്ത ഡെവലപ്പർക്ക് ഒരു if-else ബ്ലോക്ക് ഉപയോഗിക്കുന്നതാണ് എപ്പോഴും നല്ലത്.

നെസ്റ്റഡ് തീരുമാനങ്ങൾ (Nested Decisions)

സങ്കീർണ്ണമായ ലോജിക് ചിലപ്പോൾ തുടർചോദ്യങ്ങൾ ചോദിക്കേണ്ട സാഹചര്യം ഉണ്ടാക്കിയേക്കാം. ഒരു തീരുമാനം കൂടുതൽ കൃത്യമാക്കുന്നതിനായി നിങ്ങൾക്ക് ഒരു if-നുള്ളിൽ മറ്റൊരു if ഉപയോഗിക്കാം.

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