லைஃப் ஹேக்ஸ்: குறியீட்டை சிறப்பாகவும் வேகமாகவும் எழுதுவது எப்படி

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");