లైఫ్ హ్యాక్స్: కోడ్‌ను మెరుగ్గా మరియు వేగంగా ఎలా వ్రాయాలి

1. వ్యక్తీకరణలు vs ప్రకటనలు

జావాలో, స్టేట్‌మెంట్‌లు మరియు ఎక్స్‌ప్రెషన్‌లు అనే రెండు వర్గాల మధ్య తేడాను గుర్తించడం సహాయపడుతుంది . ఒక ప్రకటన సాధారణంగా అమలు చేయబడుతుందని చెప్పబడుతుంది , అయితే ఒక వ్యక్తీకరణ మూల్యాంకనం చేయబడుతుంది . కానీ అది చాలా ముఖ్యమైన విషయం కాదు.

స్టేట్‌మెంట్ మరియు ఎక్స్‌ప్రెషన్ మధ్య ప్రధాన వ్యత్యాసం ఏమిటంటే, వ్యక్తీకరణను మూల్యాంకనం చేయడం వల్ల ఫలితం ఉంటుంది . మరియు ఈ ఫలితం ఒక రకాన్ని కలిగి ఉంటుంది మరియు ఇది వేరియబుల్‌కు కేటాయించబడుతుంది లేదా ఏదైనా ఇతర వ్యక్తీకరణలో ఉపయోగించబడుతుంది.

ఉదాహరణలు:

మరియు ఇది మనకు ఏమి ఇస్తుంది?

మొదట, అనేక ప్రకటనలు వాస్తవానికి వ్యక్తీకరణలు (అంటే అవి విలువకు మూల్యాంకనం చేస్తాయి) అనే వాస్తవాన్ని మనం సద్వినియోగం చేసుకోవచ్చు. ఉదాహరణకు, ఇలాంటి కోడ్ పని చేస్తుంది:

int x, y, z;
x = y = z = 1;

int x, y, z;
x = (y = (z = 1))

రెండవది, మనకు కావాలంటే, వ్యక్తీకరణను మూల్యాంకనం చేసే ఫలితాన్ని మనం విస్మరించవచ్చు.

int x = scanner.nextInt();

boolean m = (5 < 10);

scanner.nextInt();

(5 < 10);

వ్యక్తీకరణను మూల్యాంకనం చేసే ఫలితాన్ని మేము విస్మరిస్తాము, ఉదాహరణకు, వ్యక్తీకరణలో ఏదైనా ఉపయోగకరమైన పనిని కలిగి ఉంటే, మరియు ఈ చర్య మనకు ముఖ్యమైనది, ఫలితం కాదు.

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

ఈ లైఫ్ హ్యాక్ ఇప్పటికే మునుపటి కంటే మరింత ఆసక్తికరంగా ఉంది. జావాకు ప్రత్యేక టెర్నరీ ఆపరేటర్ ఉంది . దీని వాక్యనిర్మాణం స్టేట్‌మెంట్ కోసం వాక్యనిర్మాణానికి కొంతవరకు సమానంగా ఉంటుంది if-else:

Condition ? Expression 1 : Expression 2;

షరతు నిజమైతే , ఎక్స్‌ప్రెషన్ 1 మూల్యాంకనం చేయబడుతుంది, లేకుంటే ఎక్స్‌ప్రెషన్ 2 మూల్యాంకనం చేయబడుతుంది. షరతు తర్వాత ప్రశ్న గుర్తు ఉంటుంది మరియు రెండు వ్యక్తీకరణలు పెద్దప్రేగుతో వేరు చేయబడతాయి .

టెర్నరీ ఆపరేటర్ మరియు స్టేట్‌మెంట్ మధ్య ప్రధాన వ్యత్యాసం if-elseఏమిటంటే, టెర్నరీ ఆపరేటర్ అనేది ఒక వ్యక్తీకరణ, అంటే దాని ఫలితాన్ని మనం దేనికైనా కేటాయించవచ్చు.

ఉదాహరణకు, మనం కనీసం రెండు సంఖ్యలను లెక్కించాలనుకుంటున్నాము. టెర్నరీ ఆపరేటర్‌ని ఉపయోగించి, ఈ కోడ్ ఇలా కనిపిస్తుంది:

int a = 2;
int b = 3;
int min = a < b ?  a : b;

లేదా, మీరు కొన్ని షరతులను బట్టి వేరియబుల్‌కు వేర్వేరు విలువలను కేటాయించాలని అనుకుందాం. మీరు అది ఎలా చేశారు?

ప్రకటనను ఉపయోగించడం ఒక ఎంపిక if-else:

int age = 25;
int money;
if (age > 30)
   money = 100;
else
   money = 50;

రెండవ ఎంపిక టెర్నరీ ఆపరేటర్‌ని ఉపయోగించడం , అంటే if-elseస్టేట్‌మెంట్ కోసం షార్ట్‌హ్యాండ్:

int age = 25;
int money = age > 30 ? 100 : 50;

కాబట్టి ఏది ఉపయోగించడం మంచిది — if-elseస్టేట్‌మెంట్ లేదా టెర్నరీ ఆపరేటర్ ? అమలు వేగం పరంగా, చాలా తేడా లేదు. ఇది కోడ్ రీడబిలిటీకి సంబంధించినది. మరియు ఇది చాలా ముఖ్యమైన అంశం: కోడ్ సరిగ్గా పని చేయడమే కాకుండా, ఇతర ప్రోగ్రామర్లు చదవడానికి సులభంగా ఉండాలి.

సరళమైన నియమం ఇది: కోడ్ ఒక లైన్‌లో సరిపోతుంటే , టెర్నరీ ఆపరేటర్‌ని ఉపయోగించండి ; కానీ అది ఒక లైన్‌లో సరిపోకపోతే , స్టేట్‌మెంట్‌ను ఉపయోగించడం మంచిది if-else.

3. వాస్తవ సంఖ్యలను పోల్చడం

ముందే చెప్పినట్లుగా, మీరు వాస్తవ సంఖ్యలను పట్టుకుని వాటిని సరిపోల్చలేరు. కొన్ని ముఖ్యమైన అంకెలు విస్మరించబడే అవకాశం ఎల్లప్పుడూ ఉంటుంది, ఇది ఊహించని దుష్ప్రభావాలను కలిగిస్తుంది.

అందుకే సమయం పరీక్షించిన విధానం ఉంది. రెండు వాస్తవ సంఖ్యలు చాలా చిన్న విలువతో విభేదిస్తే, వాటిని సమానంగా పరిగణించవచ్చు. ఉదాహరణ:

double a = 1.000001;
double b = 1.000002;
if ( (b - a) < 0.0001 )
   System.out.println("The numbers are equal");
else
   System.out.println("The numbers are not equal");

సంఖ్యల మధ్య వ్యత్యాసం ప్రతికూలంగా మారవచ్చు కాబట్టి మనం ఆందోళన చెందాల్సిన అవసరం అంతా ఇంతా కాదు. కాబట్టి ఈ విధానం పని చేయడానికి, మీరు సంఖ్యల మధ్య వ్యత్యాసాన్ని మాత్రమే కాకుండా, సంఖ్యల మధ్య వ్యత్యాసం యొక్క సంపూర్ణ విలువను సరిపోల్చాలి:|a-b|

సంఖ్య యొక్క సంపూర్ణ విలువను లెక్కించడానికి జావా ఒక పద్ధతిని కలిగి ఉంది: Math.abs():

int m = Math.abs(value);

ఫలితంగా, పైన ఉన్న మా ఉదాహరణ యొక్క సరిదిద్దబడిన సంస్కరణ ఇలా కనిపిస్తుంది:

double a = 1.000001;
double b = 1.000002;

if ( Math.abs(b - a) < 0.0001 )
   System.out.println("The numbers are equal");
else
   System.out.println("The numbers are not equal");