தருக்க ஆபரேட்டர்கள்

"வணக்கம், அமிகோ!"

"இப்போது லாஜிக்கல் ஆபரேட்டர்கள் பற்றிய ஒரு சிறிய பாடம் இருக்கும்."

"உங்களுக்கு என்ன லாஜிக்கல் ஆபரேட்டர்கள் தெரியும்?"

— அல்லது (||), மற்றும் (&&), இல்லை(!)

"ஆமாம். நல்ல வேலை. அவர்கள் எப்படி வேலை செய்கிறார்கள் என்பது உங்களுக்கு நினைவிருக்கிறதா?"

"ஆம்."

"அல்லது குறைந்த பட்சம் ஒரு செயலி உண்மையாக இருக்கும்போது உண்மையாக இருக்கும்."

"மற்றும் இரண்டு செயல்களும் உண்மையாக இருக்கும்போது உண்மையாக இருக்கும்."

"உண்மையை பொய்யாகவும், பொய்யை உண்மையாகவும் மாற்றாது."

"அது சரி. இந்த வெளிப்பாட்டில் ஆபரேட்டர்கள் எந்த வரிசையில் மதிப்பிடப்படுகிறார்கள்?"

boolean a = true;
boolean b = false;
boolean c = true;

boolean result = a && b || !c && b || !a;

"இது எல்லாம் மிகவும் எளிமையானது."

"முதலில், NOT (!), பின்னர் AND (&&), பின்னர் OR (||) இறுதியில்."

அடைப்புக்குறிகளைச் சேர்த்தால், நாம் பெறுவோம்:

boolean a = true;
boolean b = false;
boolean c = true;

boolean result = (a && b) || ((!c) && b) || (!a);

"அதெல்லாம் கரெக்ட், நல்லா இருக்கு. அதன் விளைவு என்ன?"

- 1) (a && b) == (உண்மை && பொய்) == பொய்

2) ((!c) && b) == (தவறான && பொய்) == பொய்

3) (!a) == பொய்

4) பொய் || பொய் || பொய் == பொய்

"முடிவு தவறானது."

"உனக்கு தலைப்பு கச்சிதமாகத் தெரியும் போலிருக்கிறது. பிறகு நான் உனக்கு இரண்டு சிறிய ரகசியங்களைச் சொல்கிறேன்."

"முதலில், தருக்க வெளிப்பாடுகள் இடமிருந்து வலமாக மதிப்பிடப்படுகின்றன."

"இரண்டாவது, குறுகிய-சுற்று மதிப்பீடு இங்கே பயன்படுத்தப்படுகிறது (தேவைப்பட்டால் மட்டுமே கணக்கீடுகள் செய்யப்படுகின்றன). வெளிப்பாட்டின் ஒரு பகுதியை மதிப்பிடுவதன் மூலம் இறுதி முடிவு ஏற்கனவே தெரிந்திருந்தால், மீதமுள்ள வெளிப்பாடு மதிப்பீடு செய்யப்படாது."

boolean result = (true && false) || (true && true) || (true && false);

"இந்த வெளிப்பாடு OR (||) ஆபரேட்டரால் பிரிக்கப்பட்ட மூன்று பகுதிகளாக பிரிக்கப்பட்டுள்ளது."

"குறைந்தது ஒரு பகுதியாவது உண்மையாக இருந்தால், பதில் உண்மையாக இருக்கும், வேறு எதையும் கருத்தில் கொள்ள வேண்டியதில்லை. அதன்படி, வெளிப்பாடு இப்படி மதிப்பிடப்படுகிறது:"

1)  முதல் பகுதியை மதிப்பிடுக:  (உண்மை && பொய்) == பொய்

2)  இரண்டாவது பகுதியை மதிப்பிடுக:  (உண்மை && உண்மை) == உண்மை

3) மூன்றாம் பகுதியை நாங்கள் மதிப்பிடவில்லை, ஏனெனில் பதில் உண்மையாக இருக்கும் என்பது ஏற்கனவே தெளிவாக உள்ளது .

"இந்த அணுகுமுறை சோம்பேறி மதிப்பீடு என்றும் அழைக்கப்படுகிறது."

"சரி. இதில் என்ன விசேஷம்?"

"ஒன்றுமில்லை- நீங்கள் வெளிப்பாட்டின் உள்ளே முறைகளை அழைக்கத் தொடங்கும் வரை. வெளிப்பாட்டின் ஒரு பகுதி தவிர்க்கப்பட்டால், தவிர்க்கப்பட்ட பகுதியில் உள்ள முறைகள் அழைக்கப்படாது."

"ஆனால் இந்த அணுகுமுறை மிகவும் பொதுவானதாகிவிட்டது. ஏன் என்பது இங்கே:"

Job job = null;

if (job != null && job.isDone())
{
…
}

"வெளிப்பாடு மதிப்பீடு செய்யப்படும்போது வேலை பூஜ்யமாக இருந்தால், job.isDone() அழைப்பு நடக்காது!"

"உண்மையில், வெளிப்பாட்டின் முதல் பகுதி தவறானது, அதைத் தொடர்ந்து AND (&&). எனவே, முழு வெளிப்பாடும் தவறானது என்று அறியப்படும், மேலும் இரண்டாவது பகுதி தேவையில்லை."

"சரியாக. இது ஒரு நல்ல நுட்பம், இல்லையா?"

"ஆமாம்."