స్విచ్ ఎక్స్‌ప్రెషన్ వర్సెస్ స్విచ్ స్టేట్‌మెంట్

చాలా షరతులతో కోడ్‌ను వ్రాసేటప్పుడు, ఖచ్చితంగా మీరు if-else లేదా స్విచ్ స్టేట్‌మెంట్‌ని ఉపయోగించారు. అయితే if-else కి ఈ ప్రత్యామ్నాయం లోపాలను కలిగి ఉంది. కొంతమంది వ్యక్తులు స్విచ్ స్టేట్‌మెంట్‌ను "యాంటీ ప్యాటర్న్" అని కూడా పిలుస్తారు .

కానీ శుభవార్త ఉంది: జావా యొక్క కొత్త సంస్కరణలు భాష యొక్క సింటాక్స్‌లో చాలా మార్పులను తీసుకువచ్చాయి మరియు ఆ మార్పులలో ఒకటి స్విచ్‌ని ప్రభావితం చేస్తుంది . ఆసక్తిగా ఉందా? అప్పుడు డైవ్ చేద్దాం.

ప్రారంభించడానికి, స్విచ్ ఎందుకు వ్యతిరేక నమూనా అని స్పష్టం చేయడం విలువ. కింది కోడ్‌ను పరిగణించండి:

switch (condition) {
    case "DECEMBER":
        seasonNumber = 1;
        break;
    case "JANUARY":
        seasonNumber = 1;
        break;
    case "FEBRUARY":
        seasonNumber = 1;
        break;
    default:
        seasonNumber = 0;
}

సరే, ఇది "యాంటీ ప్యాటర్న్" ఎందుకు అనేది ఇంకా పూర్తిగా స్పష్టంగా తెలియలేదు.

కానీ మనం మరిన్ని కేస్ బ్లాక్‌లను జోడించినట్లయితే మరియు ఇప్పుడు కోడ్ ఇలా కనిపిస్తుంది:

switch (condition) {
    case "DECEMBER":
        seasonNumber = 1;
        break;
    case "JANUARY":
        seasonNumber = 1;
        break;
    case "FEBRUARY":
        seasonNumber = 1;
        break;
    case “MARCH”:
        seasonNumber = 2;
        break;
    case “APRIL”:
        seasonNumber = 2;
        break;
    case “MAY”:
        seasonNumber = 2;
        break;
    default:
        seasonNumber = 0;
}

మరికొన్ని పంక్తులను జోడిద్దాం — కోడ్ పొడవుగా పెరుగుతుంది. తరువాత మనం మరిన్ని పంక్తులను జోడించవచ్చు మరియు దీన్ని చేయకుండా ఎవరూ మమ్మల్ని ఆపలేరు.

ఇది సమస్య యొక్క ప్రధాన అంశం: ప్రారంభంలో కాంపాక్ట్ స్విచ్ స్టేట్‌మెంట్‌ను సృష్టించిన తర్వాత, మేము దానికి మరింత ఎక్కువ కోడ్‌ని జోడిస్తాము, మరింత ఎక్కువ స్థలాన్ని తీసుకుంటాము - స్క్రీన్‌పై సరిపోయే దానికంటే ఎక్కువ - మరియు కోడ్‌ను చదవడానికి మరియు నిర్వహించడానికి అసౌకర్యంగా చేస్తుంది.

స్విచ్ స్టేట్‌మెంట్ మరియు స్విచ్ ఎక్స్‌ప్రెషన్ మధ్య వ్యత్యాసం

జావా 14 కొత్త మరియు మెరుగైన స్విచ్‌ని పరిచయం చేసింది. ఇది స్విచ్ స్టేట్‌మెంట్ కాదు , స్విచ్ ఎక్స్‌ప్రెషన్ .

తేడా ఏమిటి, మీరు అడగండి? వ్యత్యాసం ఏమిటంటే, స్టేట్‌మెంట్ అనేది నిర్దిష్ట కార్యకలాపాల సెట్‌ను చేసే సూచన, కానీ వ్యక్తీకరణ అనేది కొంత గణనను నిర్వహించి, ఫలితాన్ని అందించే కోడ్ ముక్క.

మరో మాటలో చెప్పాలంటే, ఇప్పుడు మీరు వేరియబుల్‌కు మారిన ఫలితాన్ని సేవ్ చేయవచ్చు .

మాట్లాడితే చాలు. ఇప్పుడు కొత్త స్విచ్ ఎలా ఉంటుందో చూద్దాం :

var result = switch(month) {
     case DECEMBER, JANUARY, FEBRUARY -> 1;
     case MARCH, APRIL, MAY -> 2;
    case JUNE, JULY, AUGUST -> 3;
    case SEPTEMBER, OCTOBER, NOVEMBER -> 4;
    default -> 0; 
};

కోడ్ ఎంత కాంపాక్ట్‌గా ఉందో మీ దృష్టిని ఆకర్షించే మొదటి విషయం. స్క్రీన్‌లో ఎక్కువ భాగం తీసుకునే కోడ్ ఇప్పుడు కొన్ని పంక్తులలో విస్తరించి, మరింత చదవగలిగేలా కనిపిస్తోంది.

-> ఆపరేటర్

మీరు -> ఆపరేటర్ (బాణం ఆపరేటర్) ని కూడా గమనించాలి . మీకు లాంబ్డా ఎక్స్‌ప్రెషన్స్‌తో అనుభవం ఉన్నట్లయితే, మీకు ఇది ఇప్పటికే తెలిసి ఉండవచ్చు.

అంటే ఇప్పుడు మీరు లాంబ్డా స్టేట్‌మెంట్ శైలిలో కూల్-లుకింగ్ స్విచ్‌ని వ్రాయవచ్చు. బాణం ఆపరేటర్ కంపైలర్ తదుపరి కేస్ ఎక్స్‌ప్రెషన్‌కి వెళ్లదని సూచిస్తుంది (ప్రస్తుత కేస్ బ్లాక్‌లో బ్రేక్ లేదా రిటర్న్ స్టేట్‌మెంట్ లేకుంటే), బదులుగా మీకు బాణం కుడి వైపున ఉన్న వ్యక్తీకరణ విలువను ఇస్తుంది.

మీరు వ్యక్తీకరణ కాని కోడ్‌ని కూడా వ్రాయవచ్చు మరియు ఏదైనా తిరిగి ఇచ్చే బదులు నిర్దిష్ట చర్యలను చేయవచ్చు:

switch(condition) {
    case TRUE, FALSE -> System.out.println("True/false");
  
    default -> System.out.println("Another");
}

స్విచ్ ఇకపై బ్రేక్ స్టేట్‌మెంట్‌ను కలిగి ఉండదని గమనించండి . ఇది జావా 13లో తీసివేయబడింది మరియు దిగుబడితో భర్తీ చేయబడింది .

దిగుబడి అంటే ఏమిటి మరియు దానిని ఎక్కడ ఉపయోగించవచ్చు?

స్విచ్ ఒకే లైన్‌ను కలిగి ఉన్నప్పుడు , -> ఆపరేటర్ స్వయంగా విలువను అందిస్తుంది. అయితే మనకు ఒకటి కాకపోయినా, అనేక పంక్తులు కోడ్ ఉంటే? అటువంటి సందర్భాలలో, బాణం ఆపరేటర్ ఒక విలువను అందించదు, ఎందుకంటే అనేక పంక్తులు ఉన్నాయి, ఒకటి కాదు.

బహుశా మనం రిటర్న్‌ని ఉపయోగించవచ్చా ? అన్నింటికంటే, ఇది జావాలో విలువలను తిరిగి ఇవ్వడానికి ఉపయోగించబడుతుంది. అయ్యో, లేదు, రిటర్న్ స్విచ్‌తో పని చేయదు. కాబట్టి మనం ఏమి ఉపయోగించవచ్చు? ఒకప్పుడు విరామం ఉండేది , కానీ అది జావా 13లో తీసివేయబడింది. కానీ దాని స్థానంలో ఇప్పుడు మేము దిగుబడిని కలిగి ఉన్నాము - స్విచ్ నుండి విలువను తిరిగి ఇవ్వడంలో మీకు సహాయపడే కొత్త కీవర్డ్. మెథడ్స్‌లో స్టేట్‌మెంట్‌లను రిటర్న్ చేయడం సాదృశ్యం .

var result = switch(condition) {
//…
case "Hi" -> "greeting"
//…
};  

ఈ కోడ్ ఒకే పంక్తిని కలిగి ఉంటుంది మరియు -> ఆపరేటర్ "గ్రీటింగ్"ని అందిస్తుంది.

కానీ మనకు కోడ్ బ్లాక్ ఉన్నప్పుడు:

var result = switch(condition) {
//…
case "Hi" -> {
// Your code
 Here you need to return "greeting"
	}
};  

విలువను తిరిగి ఇవ్వడంలో మీకు సహాయపడే కీవర్డ్ దిగుబడి :

var result = switch(condition) {
//…
case "Hi" -> {
// Your code
 yield "greeting";

	}
};

మేము ఒక కేస్ బ్లాక్‌లో ఒకటి కంటే ఎక్కువ లైన్ కోడ్‌లను కలిగి ఉన్న సందర్భాల్లో జావా 13లో ఈల్డ్ జోడించబడింది మరియు మేము ఫలితాన్ని అందించాలి.

మీరు బహుశా మీ కోడ్‌లోని కొత్త స్విచ్‌ని ప్రయత్నించడానికి ఆసక్తిగా ఉన్నారు , కానీ దీన్ని చేయడానికి మీకు Java 14 లేదా అంతకంటే ఎక్కువ అవసరం అని గుర్తుంచుకోండి. మునుపటి సంస్కరణలతో, మీరు కమాండ్ లైన్‌లో "--enable-preview" ఫ్లాగ్‌ను పేర్కొన్నట్లయితే మాత్రమే ఈ స్విచ్ అందుబాటులో ఉంటుంది, ఎందుకంటే వెర్షన్ 14కి ముందు ఇది సాంకేతిక పరిదృశ్యంలో భాగం, భాష యొక్క పూర్తి స్థాయి భాగం కాదు.

ఇప్పటికి ఇంతే! మళ్ళి కలుద్దాం!