ప్రతి ప్రోగ్రామ్ ప్రతిస్పందించాలి. ఒక యూజర్ బటన్‌ను క్లిక్ చేస్తారు. ఒక API డేటాను తిరిగి ఇస్తుంది. ఒక ఫారమ్ ఫీల్డ్ ఖాళీ అవుతుంది. బ్రాంచింగ్ (branching) చేసే విధానం లేకపోతే, అసలు ఏం జరుగుతున్నా సరే, మీ కోడ్ లైన్ బై లైన్ రన్ అవుతుంది. కండిషనల్స్ (Conditionals) జావాస్క్రిప్ట్‌కు ఎంచుకునే సామర్థ్యాన్ని ఇస్తాయి. అవి మీ ఫంక్షన్ల లోపల నిర్ణయాలు తీసుకునేవి, ఏది రన్ అవ్వాలి మరియు ఏది స్కిప్ అవ్వాలి అని నిర్ణయించే గేట్‌కీపర్లు. వాటిని ఎలా బాగా రాయాలో మీరు అర్థం చేసుకున్న తర్వాత, మీరు కేవలం రిజిడ్ స్క్రిప్ట్‌లను రాయడం మానేసి, నిజంగా స్పందించే సాఫ్ట్‌వేర్‌ను నిర్మించడం ప్రారంభిస్తారు.

కండిషనల్స్ ఎందుకు ముఖ్యం

కంట్రోల్ ఫ్లో (Control flow) అనేది లాజిక్‌కు వెన్నెముక వంటిది. సర్వర్‌కు పాస్‌వర్డ్‌లను పోస్ట్ చేసే ముందు వాటిని వాలిడేట్ చేయడానికి మీరు కండిషనల్స్‌ను ఉపయోగిస్తారు. టాక్స్ (tax) లెక్కించే ముందు షాపింగ్ కార్ట్ ఖాళీగా ఉందో లేదో మీరు తనిఖీ చేస్తారు. నెట్‌వర్క్ రిక్వెస్ట్ విఫలమైతే, ఖాళీ స్క్రీన్‌కు బదులుగా ఎర్రర్‌ను చూపించడానికి మీరు దానిని గుర్తిస్తారు. ఈ దృశ్యాలన్నీ ఒకే సాధారణ ఆలోచనపై ఆధారపడి ఉంటాయి: ఏదైనా ఒక దానిని మూల్యాంకనం (evaluate) చేయండి, ఆపై దానికి అనుగుణంగా స్పందించండి.

కండిషనల్స్ లేకపోతే, మీ అప్లికేషన్ సంభాషణలా కాకుండా ఒక మోనోలాగ్‌లా (monologue) ఉంటుంది. అది వివిధ డేటా పరిస్థితులను హ్యాండిల్ చేయలేదు, ఎర్రర్‌లను చక్కగా నిర్వహించలేదు లేదా యూజర్ చర్యలకు అర్థవంతమైన రీతిలో స్పందించలేదు. నిజ ప్రపంచంలోని అనిశ్చితిలో మీ ప్రోగ్రామ్ ఎలా రన్ అవ్వాలో అవి మీకు నియంత్రణను ఇస్తాయి.

బేసిక్ if స్టేట్‌మెంట్

ప్రారంభించడానికి అత్యంత సులభమైన మార్గం స్టాండ్‌అలోన్ if. ఇది, "ఒకవేళ ఇది నిజమైతే, ఈ పని చేయి" అని చెబుతుంది. అంతే. ఎటువంటి ఫాల్‌బ్యాక్ (fallback) లేదు, ప్రత్యామ్నాయ మార్గం లేదు.

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

ఈ స్నిప్పెట్‌లో, మోడ్యులస్ ఆపరేటర్ x రెండుతో నిశ్చయంగా భాగించబడుతుందో లేదో తనిఖీ చేస్తుంది. శేషం (remainder) సున్నా అయినప్పుడు, కన్సోల్ ఆ స్ట్రింగ్‌ను లాగ్ చేస్తుంది. x బేసి సంఖ్య (odd) అయితే, ఏమీ జరగదు. ఆ బ్లాక్ విస్మరించబడుతుంది మరియు ఎగ్జిక్యూషన్ కింద కొనసాగుతుంది.

ఆ నిశ్శబ్ద విస్మరణ (quiet ignore) ముఖ్యం. కొన్నిసార్లు మీరు కేవలం ఒకే ఒక చర్యను మాత్రమే రక్షించాలనుకుంటారు. బహుశా ఒక బటన్ యాక్టివ్‌గా ఉన్నప్పుడు మాత్రమే దానికి CSS క్లాస్‌ను జోడించాలనుకోవచ్చు, లేదా ఇన్‌పుట్ ఖాళీగా లేనప్పుడు మాత్రమే ఒక అర్రేకి (array) ఐటెమ్‌ను యాడ్ చేయాలనుకోవచ్చు. మీకు అవసరం లేని లాజిక్‌ను రాయాల్సిన అవసరం లేకుండానే ఒక సాధారణ if స్టేట్‌మెంట్ ఆ క్షణాలను హ్యాండిల్ చేస్తుంది.

if-else తో ప్రత్యామ్నాయాన్ని జోడించడం

నిజమైన నిర్ణయాలకు సాధారణంగా రెండు వైపులా ఉంటాయి. యూజర్ తగిన వయస్సు కలిగి ఉండవచ్చు లేదా ఉండకపోవచ్చు. పేమెంట్ విజయవంతమై ఉండవచ్చు లేదా విఫలమై ఉండవచ్చు. if-else నిర్మాణం రెండింటినీ కవర్ చేస్తుంది.

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

మొదటి కండిషన్ తిరస్కరించిన ప్రతిదాన్ని else బ్లాక్ పట్టుకుంటుంది. ఇది ఒక స్పష్టమైన బైనరీ బ్రాంచ్‌ను సృష్టిస్తుంది. ఈ ప్యాటర్న్ టోగుల్స్ (toggles), పర్మిషన్లు మరియు ఫీచర్ ఫ్లాగ్‌లకు బాగా పనిచేస్తుంది. ప్రతి బ్లాక్ లోపల లాజిక్‌ను కేవలం ఒకే విషయంపై దృష్టి సారించేలా ఉంచండి. ఒకే బ్రాంచ్‌లో మీరు చాలా పనులను పేరుకువేస్తున్నట్లు అనిపిస్తే, ఆ పనిని చిన్న ఫంక్షన్లుగా విభజించాల్సిన అవసరం ఉందని అర్థం.

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 తనిఖీ చేస్తే, కఠినమైన తనిఖీ (stricter check) ఎప్పటికీ రన్ కాదు, ఎందుకంటే తేలికపాటి తనిఖీ (looser check) దానిని ముందుగానే పట్టుకుంటుంది. 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) ఆధారపడినప్పుడు ఉపయోగించే సాధారణ జావాస్క్రిప్ట్ ప్యాటర్న్. break కీవర్డ్ చాలా ముఖ్యం. అది లేకపోతే, అది సరిపోలినా లేకపోయినా ఎగ్జిక్యూషన్ తదుపరి కేస్‌కు వెళ్ళిపోతుంది, ఇది మీరు కోరుకునేది కాదు. default క్లాజ్ చివరి else లాగా పనిచేస్తుంది, ఇది ముందరి కేస్‌లకు సరిపోని దేన్నైనా పట్టుకుంటుంది.

మీకు స్పష్టమైన, స్థిరమైన ఎంపికలు ఉన్నప్పుడు switch అద్భుతంగా పనిచేస్తుంది. ముఖ్యంగా ప్రతి బ్రాంచ్ కేవలం ఒక విలువను కేటాయించినప్పుడు లేదా ఒకే ఫంక్షన్‌ను కాల్ చేసినప్పుడు, ఇది పొడవైన else if బ్లాక్‌ల కంటే స్కాన్ చేయడానికి సులభంగా ఉంటుంది.

టెర్నరీ ఆపరేటర్ (Ternary Operator)

చిన్న బైనరీ నిర్ణయాల కోసం, టెర్నరీ ఆపరేటర్ విషయాలను సంక్షిప్తంగా ఉంచుతుంది. ఇది మూడు ఆపరేండ్‌లను తీసుకుంటుంది: ఒక కండిషన్, నిజమైతే ఒక విలువ, మరియు అబద్ధమైతే (false) మరొక విలువ.

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

మీరు దీనిని వేగవంతమైన అసైన్‌మెంట్‌లు లేదా ఇన్‌లైన్ రిటర్న్‌ల కోసం ఉపయోగించవచ్చు. ఫలితం ఒక సాధారణ ఎక్స్‌ప్రెషన్ అయినప్పుడు ఇది బాగా పనిచేస్తుంది. టెర్నరీలను మూడు స్థాయిల లోతు వరకు నెస్టెడ్ (nested) చేయాలనే కోరికను అదుపులో ఉంచుకోండి. నెస్టెడ్ టెర్నరీ లైన్లను ఆదా చేయవచ్చు, కానీ అది రీడబిలిటీని (readability) తగ్గిస్తుంది. మీ లాజిక్ పెరిగే కొద్దీ, ఫైల్‌ను ఓపెన్ చేసే తదుపరి డెవలపర్‌కు if-else బ్లాక్ సాధారణంగా సులభంగా ఉంటుంది.

నెస్టెడ్ నిర్ణయాలు (Nested Decisions)

సంక్లిష్టమైన లాజిక్ కోసం కొన్నిసార్లు తదుపరి ప్రశ్నలను అడగాల్సి ఉంటుంది. ఒక నిర్ణయాన్ని మరింత ఖచ్చితంగా తీసుకోడానికి మీరు ఒక if లోపల మరొక if ని ఉంచవచ్చు (nest చేయవచ్చు).

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