టెర్నరీ ఆపరేటర్

హాయ్! నేటి పాఠం చాలా పొడవుగా ఉండదు, కానీ ఇది ఖచ్చితంగా ఉపయోగకరంగా ఉంటుంది :) మేము టెర్నరీ ఆపరేటర్ అని పిలవబడే దాని గురించి మాట్లాడబోతున్నాము . టెర్నరీ అంటే " మూడు భాగాలతో కూడినది ". if-elseమీరు ఇప్పటికే కలుసుకున్న నియంత్రణ ప్రవాహ ప్రకటనకు ఇది ప్రత్యామ్నాయం . ఒక ఉదాహరణ ఇద్దాం. ఎవరైనా R- రేటెడ్ మూవీకి వెళ్లాలని నిర్ణయించుకున్నారని అనుకుందాం (17 ఏళ్లలోపు వారితో పాటు తల్లిదండ్రులు లేదా పెద్దల సంరక్షకుడు అవసరం). అషర్ తలుపు వద్ద అతని వయస్సును తనిఖీ చేస్తాడు: అతను వయస్సు తనిఖీని ఆమోదించినట్లయితే, అతను ప్రవేశించడానికి అనుమతించబడతాడు; లేని పక్షంలో ఇంటికి పంపిస్తారు. క్లాస్‌ని డిక్లేర్ చేసి Person, స్టేట్‌మెంట్‌ని ఉపయోగించి దీన్ని చెక్ చేద్దాం if-else:

public class Person {

   private int age;

   public Person(int age) {
       this.age = age;
   }

   public int getAge() {
       return age;
   }

   public void setAge(int age) {
       this.age = age;
   }

   public static void main(String[] args) {

       Person person = new Person(22);

       String usherResponse;

       if (person.getAge() >= 18) {
           usherResponse = "Everything is in order. Come in!";
       } else {
           usherResponse = "This film is not suitable for your age!";
       }

       System.out.println(usherResponse);

   }
}

కన్సోల్ అవుట్‌పుట్:

"Everything is in order. Come in!"

మేము కన్సోల్ అవుట్‌పుట్‌ను తీసివేస్తే, మా చెక్ ఇలా కనిపిస్తుంది:

if (person.getAge() >= 18) {
           usherResponse = "Everything is in order. Come in!";
       } else {
           usherResponse = "This film is not suitable for your age!";
       }

ఇక్కడ లాజిక్ చాలా సులభం: ఒక షరతు తనిఖీ చేయబడింది (వయస్సు >= 18) ఫలితం ఆధారంగా, usherResponseఅషర్ ప్రతిస్పందనతో వేరియబుల్ రెండు స్ట్రింగ్‌లలో ఒకటి కేటాయించబడుతుంది. ఇటువంటి పరిస్థితులు ("ఒక షరతు - రెండు సాధ్యమయ్యే ఫలితాలు") ప్రోగ్రామింగ్‌లో చాలా సాధారణం. మరియు అందుకే టెర్నరీ ఆపరేటర్ సృష్టించబడింది. మేము మా చెక్‌ను ఒకే లైన్ కోడ్‌కి సరళీకృతం చేయడానికి దీన్ని ఉపయోగించవచ్చు:

public static void main(String[] args) {

   Person person = new Person(22);

   String usherResponse = (person.getAge() > 18) ? "Everything is in order. Come in!" : "This film is not suitable for your age!";

   System.out.println(usherResponse);

}

ఈ ఆపరేటర్ ఎలా పని చేస్తుందో ఇక్కడ ఉంది. దీనిని టెర్నరీ ఆపరేటర్ అని పిలుస్తారు, ఎందుకంటే ఇది 3 భాగాలను కలిగి ఉంటుంది:

• ఒక షరతు ( person.getAge() > 18)
• రెండు సాధ్యమయ్యే ఫలితాలు ( "అంతా సక్రమంగా ఉంది. రండి!" మరియు "ఈ చిత్రం మీ వయస్సుకి తగినది కాదు!" )

మొదట, మేము షరతును వ్రాస్తాము, తరువాత ప్రశ్న గుర్తు.

person.getAge() > 18 ?

"ఈ వ్యక్తి వయస్సు 18 కంటే ఎక్కువ ఉందా?" అప్పుడు మేము మొదటి విలువను వ్రాస్తాము . షరతు మూల్యాంకనం చేస్తేtrue ఈ విలువ ఉపయోగించబడుతుంది :

String usherResponse = person.getAge() > 18 ? "Everything is in order. Come in!"

ఈ వ్యక్తి వయస్సు 18 కంటే ఎక్కువ ఉందా? అవును అయితే, వేరియబుల్‌ని usherResponse " అంతా క్రమంలో ఉంది. లోపలికి రండి!" తర్వాత " :" గుర్తు మరియు రెండవ విలువ వస్తుంది . షరతు మూల్యాంకనం చేస్తేfalse ఈ విలువ ఉపయోగించబడుతుంది :

String usherResponse = person.getAge() > 18 ? "Everything is in order. Come in!" : "This film is not suitable for your age!";

ఈ వ్యక్తి వయస్సు 18 కంటే ఎక్కువ ఉందా? అవును అయితే, వేరియబుల్‌ని usherResponse " అంతా క్రమంలో ఉంది. లోపలికి రండి!" . కాకపోతే, వేరియబుల్‌ని usherResponse " ఈ చిత్రం మీ వయస్సుకి సరిపోదు!" సాధారణంగా, టెర్నరీ ఆపరేటర్ యొక్క లాజిక్ ఎలా ఉంటుందో ఇక్కడ ఉంది. పరిస్థితి ? ఫలితం 1 : ఫలితం 2 ద్వారా, షరతు చుట్టూ కుండలీకరణాలు అవసరం లేదు: ఎక్కువ చదవడానికి మేము వాటిని జోడించాము. ఇది అవి లేకుండా కూడా పనిచేస్తుంది:

public static void main(String[] args) {

   Person person = new Person(22);

   String usherResponse = person.getAge() > 18 ? "Everything is in order. Come in!" : "This film is not suitable for your age!";

   System.out.println(usherResponse);

}

కాబట్టి మీరు ఏమి ఉపయోగించాలి? ఒక if-elseప్రకటన లేదా టెర్నరీ ఆపరేటర్? పనితీరు పరంగా, తేడా లేదు. మరింత ఖచ్చితంగా, బహుశా ఉండవచ్చు, కానీ అది చాలా తక్కువ. మీ కోడ్ యొక్క రీడబిలిటీ ఇక్కడ అతిపెద్ద పరిశీలన. మీరు వ్రాసే కోడ్ సరిగ్గా పని చేయడమే కాకుండా చదవడానికి సులభంగా ఉండాలి . అన్నింటికంటే, ఇది ఇతర ప్రోగ్రామర్లు, మీ సహోద్యోగుల ద్వారా "వారసత్వం" కావచ్చు! అర్థం చేసుకోవడం కష్టంగా ఉంటే, అది వారి పనిని మరియు మీ పనిని క్లిష్టతరం చేస్తుంది (వారు ప్రతి 5 నిమిషాలకు వివరణల కోసం మీ వద్దకు పరుగెత్తుతారు). సాధారణ సిఫార్సు ఇది: పరిస్థితి సరళంగా మరియు సులభంగా ధృవీకరించబడితే, మీరు హాని లేకుండా టెర్నరీ ఆపరేటర్‌ను ఉపయోగించవచ్చు. ఇది కోడ్ మొత్తాన్ని మరియు సంఖ్యను తగ్గించడానికి మిమ్మల్ని అనుమతిస్తుందిif-elseప్రకటనలు (మరియు ఇప్పటికే వాటిలో చాలా ఉండవచ్చు). if-elseకానీ పరిస్థితి సంక్లిష్టంగా మరియు అనేక దశలను కలిగి ఉన్నట్లయితే, ఒక ప్రకటనను ఉపయోగించడం మంచిది . ఉదాహరణకు, టెర్నరీ ఆపరేటర్‌ని ఉపయోగించడం ఈ సందర్భంలో చెడ్డ ఆలోచన అవుతుంది:

String usherResponse = (person.getAge() > 18 && (person.hasTicket() || person.hasCoupon()) && !person.hasChild()) ? "Come in!" : "You can't come in!";

ఇక్కడ ఏమి జరుగుతుందో వెంటనే స్పష్టంగా కనిపించదు! కోడ్ చదవడం చాలా కష్టంగా మారింది. మరియు అన్ని సంక్లిష్ట పరిస్థితి కారణంగా:

• ఎవరైనా 18 సంవత్సరాల కంటే ఎక్కువ వయస్సు కలిగి ఉంటే, టిక్కెట్ (లేదా ఉచిత పాస్) కలిగి ఉంటే మరియు చిన్న పిల్లలు లేకుంటే, అతను లోపలికి రావచ్చు.
• షరతులో ఒక భాగం కూడా తప్పు అయితే, అతను చేయలేడు.

ఇక్కడ స్పష్టంగా ఉపయోగించడం మంచిది if-else. అవును, మా కోడ్ పెద్దదిగా ఉంటుంది, కానీ అది చాలా ఎక్కువ చదవగలిగేలా ఉంటుంది. మరియు మీ సహోద్యోగులు ఈ కోడ్‌ను వారసత్వంగా పొందినట్లయితే వారు అరచేతిలో పడరు :) చివరగా, నేను మీకు మంచిని సిఫార్సు చేయగలను. మేము పాఠం సమయంలో కోడ్ రీడబిలిటీని టచ్ చేసాము. క్లాసిక్‌గా మారిన రాబర్ట్ మార్టిన్ పుస్తకం "క్లీన్ కోడ్" ఈ అంశానికి అంకితం చేయబడింది. ఇది ప్రోగ్రామర్‌ల కోసం ఉత్తమ అభ్యాసాలు మరియు సిఫార్సులను కలిపిస్తుంది, ఇది మీకు ఫంక్షనల్‌గా మాత్రమే కాకుండా సులభంగా చదవగలిగే కోడ్‌ను వ్రాయడంలో సహాయపడుతుంది.