ප්‍රතිලාභ අගය නොපවතින කාර්යයන් / ක්‍රම වලින් NULL හෝ හිස් අගයන් ආපසු ලබා දීම වඩා හොඳද?

මම මෙහි නිර්දේශයක් සොයමි. ප්‍රතිලාභ අගය නොමැති විට හෝ නිශ්චය කළ නොහැකි වූ විට NULL ආපසු ලබා දීම වඩා හොඳද නැතිනම් ක්‍රමයකින් හිස් වටිනාකමක් තිබේද යන්න සමඟ මම පොරබදමින් සිටිමි.

පහත දැක්වෙන ක්‍රම දෙක උදාහරණයක් ලෙස ගන්න:

string ReverseString(string stringToReverse) // takes a string and reverses it.
Person FindPerson(int personID)    // finds a Person with a matching personID.

දී ReverseString(), මම කියන්නේ හිස් නූලක් ආපසු එවන්න, මන්ද ආපසු එන වර්ගය නූල් බැවින් ඇමතුම්කරු එය අපේක්ෂා කරයි. එසේම, මේ ආකාරයෙන්, අමතන්නාට NULL ආපසු ලබා දී ඇත්දැයි පරීක්ෂා කිරීමට අවශ්‍ය නොවේ.

තුළ FindPerson(), NULL නැවත පැමිණීම වඩා සුදුසු යැයි පෙනේ. NULL හෝ හිස් පුද්ගල වස්තුවක් ( new Person()) ආපසු ලබා දුන්නද නැද්ද යන්න නොසලකා , ඇමතුම ලබා ගැනීමට පෙර පුද්ගල වස්තුව NULL හෝ හිස් දැයි බැලීමට සිදු වේ ( ඇමතුම වැනි UpdateName()). එහෙනම් ඇයි NULL මෙතනට එවන්නේ නැත්තේ, පසුව අමතන්නාට NULL සඳහා පමණක් පරීක්ෂා කළ යුතුය.

වෙන කවුරුහරි මේ සමඟ පොරබදිනවාද? ඕනෑම උදව්වක් හෝ තීක්ෂ්ණ බුද්ධියක් අගය කරනු ලැබේ.

මෙම ප්‍රශ්නෝත්තරයේදී මෙම නිශ්චිත මාතෘකාව පිළිබඳව StackOverflow හොඳ සාකච්ඡාවක් ඇත. ඉහළම ශ්‍රේණිගත කළ ප්‍රශ්නයේදී, ක්‍රොනොස් සටහන් කරන්නේ:

දත්ත නොමැති බව දැක්වීමට ඔබ අදහස් කරන්නේ නම්, ශුන්‍යය ආපසු ලබා දීම සාමාන්‍යයෙන් හොඳම අදහස වේ.

හිස් වස්තුවකින් ගම්‍ය වන්නේ දත්ත ආපසු ලබා දී ඇති අතර ශුන්‍යව ආපසු යාමෙන් පැහැදිලි වන්නේ කිසිවක් ආපසු ලබා දී නොමැති බවයි.

මීට අමතරව, ඔබ වස්තුවෙහි සාමාජිකයින්ට ප්‍රවේශ වීමට උත්සාහ කළහොත් එය ශුන්‍ය ව්‍යතිරේකයක් වනු ඇත, එය දෝෂ සහිත කේතය ඉස්මතු කිරීමට ප්‍රයෝජනවත් විය හැකිය - කිසිවක් නොමැති සාමාජිකයෙකුට ප්‍රවේශ වීමට උත්සාහ කිරීම තේරුමක් නැත. හිස් වස්තුවක සාමාජිකයින්ට ප්‍රවේශ වීම අසාර්ථක නොවනු ඇත, එයින් අදහස් වන්නේ දෝෂ සොයාගත නොහැකි බවයි.

පුද්ගලිකව, ක්‍රියාවට නැංවිය යුතු දෝෂ හැසිරවීමේ ප්‍රමාණය අවම කිරීම සඳහා නූල් නැවත ලබා දෙන කාර්යයන් සඳහා හිස් නූල් ආපසු දීමට මම කැමතියි. කෙසේ වෙතත්, ඔබ සමඟ වැඩ කරන කණ්ඩායම එකම සම්මුතියක් අනුගමනය කරන බවට ඔබ සහතික විය යුතුය - එසේ නොමැතිනම් මෙම තීරණයෙහි ප්‍රතිලාභ අත්කර ගත නොහැක.

කෙසේ වෙතත්, SO පිළිතුරෙහි ඇති පෝස්ටරයේ සඳහන් කර ඇති පරිදි, යම් වස්තුවක් අපේක්ෂා කරන්නේ නම් ශුන්‍යයන් ආපසු ලබා දිය යුතු අතර එමඟින් දත්ත ආපසු ලබා දෙන්නේද යන්න පිළිබඳ සැකයක් නැත.

අවසානයේදී, දේවල් කිරීමට හොඳම ක්‍රමයක් නොමැත. කණ්ඩායම් සම්මුතියක් ගොඩනැගීම අවසානයේ ඔබේ කණ්ඩායමේ හොඳම භාවිතයන් මෙහෙයවනු ඇත.

මා ලියන සෑම කේතයකම, මම nullශ්‍රිතයකින් ආපසු යාමෙන් වැළකී සිටිමි . මම එය පිරිසිදු කේතයෙන් කියෙව්වා .

භාවිතා කිරීමේ ගැටළුව nullනම්, අතුරු මුහුණත භාවිතා කරන පුද්ගලයා nullසිදුවිය හැකි ප්‍රති come ලයක් දැයි නොදැන සිටීම සහ ඔවුන් ඒ සඳහා පරික්ෂා කළ යුතුද යන්න not nullවිමර්ශන වර්ගයක් නොමැති නිසාය .

F # හි ඔබට optionවර්ගයක් ආපසු ලබා දිය හැකිය , එය එසේ විය හැකිය, some(Person)නැතහොත් noneඇමතුම්කරුට ඔවුන් පරීක්ෂා කළ යුතු බව පැහැදිලිය.

ප්‍රතිසම C # (ප්‍රති-) රටාව Try...ක්‍රමයයි:

public bool TryFindPerson(int personId, out Person result);

නිමැවුම් පරාමිතියක් තිබීම පිරිසිදු ශ්‍රිතයක අදහස් බිඳ දැමූ නිසා ඔවුන් රටාවට වෛර කරන බව දැන් මම දනිමි Try..., නමුත් එය ඇත්ත වශයෙන්ම ඊට වඩා වෙනස් නොවේ:

class FindResult<T>
{
   public FindResult(bool found, T result)
   {
       this.Found = found;
       this.Result = result;
   }

   public bool Found { get; private set; }
   // Only valid if Found is true
   public T Result { get; private set;
}

public FindResult<Person> FindPerson(int personId);

... සහ අවංකව කිවහොත් සෑම .NET ක්‍රමලේඛකයෙකුම Try...රටාව ගැන දන්නා බව උපකල්පනය කළ හැකිය . එයින් අදහස් කරන්නේ එය කරන්නේ කුමක්ද යන්න තේරුම් ගැනීමට ඔවුන් ලියකියවිලි කියවිය යුතු නැති අතර එය කාර්යයන් පිළිබඳ සමහර පාරිශුද්ධවාදීන්ගේ දෘෂ්ටියට ඇලී සිටීමට වඩා මට වැදගත් ය ( resultඑය outපරාමිතියක් බව වටහා ගැනීම පරාමිතියක් නොවේ ref).

ඒ නිසා මම TryFindPersonඑය සොයා ගැනීමට නොහැකි වීම සාමාන්‍ය දෙයක් බව ඔබට පෙනෙන නිසා මම යන්නෙමි .

අනෙක් අතට, අමතන්නා කවදාවත් personIdනොපවතින දෙයක් ලබා දීමට තර්කානුකූල හේතුවක් නොමැති නම්, මම බොහෝ විට මෙය කරන්නෙමි:

public Person GetPerson(int personId);

... එවිට එය අවලංගු නම් මම ව්‍යතිරේකයක් විසි කරමි. මෙම Get...උපසර්ගය දුරකථන ඇමතුම එය සාර්ථක යුතු දන්නා බවයි.

ව්‍යවසාය යෙදුම් ගෘහ නිර්මාණ ශිල්පයේ පැටර්න්ස් වෙතින් ඔබට මාටින් ෆෝලර්ගේ විශේෂ සිද්ධි රටාව උත්සාහ කළ හැකිය :

වස්තු-නැඹුරු වැඩසටහන් වල ශුන්‍යයන් අමුතු දේවල් වන්නේ ඒවා බහුමාපකය පරාජය කරන බැවිනි. සාමාන්‍යයෙන් ඔබට අයිතමය නිශ්චිත වර්ගයද නැතහොත් උප පංතියක්ද යන්න ගැන කරදර නොවී යම් වර්ගයක විචල්‍ය යොමුවකට නිදහසේ ආරාධනා කළ හැකිය. තදින් ටයිප් කළ භාෂාවකින් ඔබට ඇමතුම නිවැරදි දැයි සම්පාදක පරීක්‍ෂා කළ හැකිය. කෙසේ වෙතත්, විචල්‍යයකට ශුන්‍ය විය හැකි බැවින්, ඔබට ශුන්‍ය පණිවිඩයක් යැවීමෙන් ධාවන කාල දෝෂයකට ගොදුරු විය හැකි අතර එමඟින් ඔබට හොඳ මිත්‍රශීලී තොගයක් ලැබෙනු ඇත.

විචල්‍යයක් ශුන්‍ය වීමට හැකි නම්, ඔබ එය ශුන්‍ය පරීක්ෂණ කේතයකින් වට කිරීමට මතක තබා ගත යුතුය, එවිට ශුන්‍යයක් තිබේ නම් ඔබ නිවැරදි දේ කරනු ඇත. බොහෝ විට නිවැරදි දෙය බොහෝ සන්දර්භයන්හි එක හා සමාන වේ, එබැවින් ඔබ බොහෝ ස්ථානවල සමාන කේතයක් ලිවීම අවසන් කරයි - කේත අනුපිටපත් කිරීමේ පාපය සිදු කරයි.

එවැනි ගැටළු වලට ශුන්‍යයන් පොදු උදාහරණයක් වන අතර අනෙක් අය නිතිපතා වගා කරති. සංඛ්‍යා පද්ධති වලදී ඔබට අනන්තය සමඟ ගනුදෙනු කළ යුතු අතර, තාත්වික සංඛ්‍යා වල සුපුරුදු වෙනස්වීම් බිඳ දැමීම එකතු කිරීම වැනි දේ සඳහා විශේෂ නීති ඇත. ව්‍යාපාර මෘදුකාංග පිළිබඳ මගේ මුල්ම අත්දැකීමක් වූයේ "පදිංචිකරුවෙකු" ලෙස හඳුන්වනු ලබන උපයෝගිතා ගනුදෙනුකරුවෙකු සමඟ ය. මේ සියල්ලම ගම්‍ය වන්නේ සුපුරුදු හැසිරීම වෙනස් කිරීමයි.

ශුන්‍ය හෝ කිසියම් අමුතු වටිනාකමක් ලබා දීම වෙනුවට, අමතන්නා අපේක්ෂා කරන දෙයට සමාන අතුරු මුහුණතක් ඇති විශේෂ නඩුවක් ආපසු එවන්න.

මම සිතන්නේ ReverseString()ආපසු හරවන ලද නූල නැවත ලබා දෙනු ඇති අතර එය IllegalArgumentExceptiona Null.

මම හිතන්නේ ඔබට සෑම විටම යමක් සොයාගත හැකි නම් FindPerson(), NullObject රටාව අනුගමනය කළ යුතුය .

ගනුදෙනු කිරීම Nullවැළැක්විය යුතු දෙයකි. සහිත Nullභාෂා දී කැඳවා තිබේ ඩොලර් බිලියනයක වැරැද්දක් එය විසින් නව නිපැයුම්කරු විසින්!

මම එය හඳුන්වන්නේ මගේ ඩොලර් බිලියනයක වැරැද්ද ලෙසයි. එය 1965 දී ශුන්‍ය යොමු කිරීම සොයා ගැනීමකි. එකල මම වස්තු දිශානත භාෂාවක (ALGOL W) යොමු කිරීම් සඳහා පළමු පුළුල් වර්ගයේ පද්ධතියක් නිර්මාණය කරමින් සිටියෙමි.

මගේ පරමාර්ථය වූයේ සම්පාදකයා විසින් ස්වයංක්‍රීයව පරීක්‍ෂා කිරීමත් සමඟ සියලු යොමු කිරීම් පරම ආරක්ෂිත බව සහතික කිරීමයි. නමුත් එය ක්‍රියාවට නැංවීම එතරම් පහසු නිසා හුදෙක් ශුන්‍ය සඳහනක් කිරීමට ඇති පෙළඹවීමට එරෙහි වීමට මට නොහැකි විය.

මෙය අසංඛ්‍යාත දෝෂ, අනාරක්‍ෂිතතා සහ පද්ධති බිඳවැටීම් වලට තුඩු දී ඇති අතර, පසුගිය වසර හතළිහ තුළ ඩොලර් බිලියනයක වේදනාවක් හා හානියක් සිදුවිය හැකිය.

මෑත වසරවලදී, මයික්‍රොසොෆ්ට් හි PREfix සහ PREfast වැනි වැඩසටහන් විශ්ලේෂක ගණනාවක් යොමු කිරීම් පරීක්ෂා කිරීම සඳහා භාවිතා කර ඇති අතර අවදානමක් ඇත්නම් ඒවා අවලංගු නොවන බවට අනතුරු ඇඟවීම් ලබා දේ. පිරිවිතර # වැනි වඩාත් මෑත ක්‍රමලේඛන භාෂාවන් විසින් ශුන්‍ය නොවන යොමු කිරීම් සඳහා ප්‍රකාශන හඳුන්වා දී ඇත. 1965 දී මා ප්‍රතික්ෂේප කළ විසඳුම මෙයයි.

ටෝනි හෝරේ

විකල්පයක් ආපසු එවන්න . NullPointerException හි අවදානමකින් තොරව වෙනත් අවලංගු අගයක් (ඔබේ එකතුවෙහි හිස් අගයන් තිබීම වැනි) ආපසු ලබා දීමේ සියලු වාසි.

මෙම තර්කයේ දෙපැත්තම මා දකින අතර, කේත පිරිසිදුව තබා ගැනීම, අමතර දෝෂ හැසිරවීමේ අවහිරතා වළක්වා ගැනීම සඳහා ශුන්‍ය ආපසු නොඑන ලෙස තරමක් ප්‍රබල හ o වල් (උදා: ෆවුලර්) උපදෙස් දෙන බව මම තේරුම් ගතිමි.

කෙසේ වෙතත්, මම ශුන්‍යව නැවත පැමිණීමේ යෝජනා කරන්නන් සමඟ නැඹුරු වෙමි. ක්‍රමවේදයක් ක්‍රියාත්මක කිරීමේදී වැදගත් වෙනසක් ඇති බව මට පෙනී යන අතර එයට ප්‍රතිචාර දැක්වීම මා සතුව කිසිදු දත්තයක් නොමැති අතර එයට ප්‍රතිචාර දක්වන්නේ මෙම හිස් නූලයි .

පුද්ගල පංතියක් ගැන සඳහන් කරන සමහර සාකච්ඡා මා දැක ඇති බැවින්, ඔබ පන්තියේ අවස්ථාවක් සොයා බැලීමට උත්සාහ කරන අවස්ථාව සලකා බලන්න. ඔබ කිසියම් සෙවුම් ගුණාංගයකින් (උදා: හැඳුනුම්පතක්) සමත් වුවහොත්, කිසිදු වටිනාකමක් සොයාගත නොහැකි දැයි බැලීමට සේවාදායකයෙකුට වහාම ශුන්‍යය පරීක්ෂා කළ හැකිය. මෙය අනිවාර්යයෙන්ම සුවිශේෂී නොවේ (එබැවින් ව්‍යතිරේක අවශ්‍ය නොවේ), නමුත් එය ද පැහැදිලිව ලේඛනගත කළ යුතුය. ඔව්, මේ සඳහා සේවාදායකයාගේ පැත්තෙන් යම් දැඩි බවක් අවශ්‍ය වන අතර, නැත, එය කිසිසේත් නරක දෙයක් යැයි මම නොසිතමි.

දැන් ඔබ වලංගු පුද්ගල වස්තුවක් ආපසු ලබා දෙන විකල්පය සලකා බලන්න ... එහි කිසිවක් නැත. ඔබ එහි සියලු අගයන් (නම, ලිපිනය, ප්‍රියතම ඩ්‍රින්ක්) වල ශුන්‍යයන් තබනවාද, නැතිනම් වලංගු නමුත් හිස් වස්තූන් ඇති අය දැන් ඔබ ජනප්‍රියද? සැබෑ පුද්ගලයෙකු හමු නොවූ බව ඔබේ සේවාදායකයා දැන් තීරණය කරන්නේ කෙසේද? නම ශුන්‍ය වෙනුවට හිස් නූලක් දැයි ඔවුන් පරීක්ෂා කළ යුතුද? මේ ආකාරයේ දෙයක් ඇත්ත වශයෙන්ම අප විසින් අවලංගු කර පරීක්ෂා කර බලා ඉදිරියට යනවාට වඩා වැඩි හෝ වැඩි කේත අවුල් සහගත කොන්දේසි සහිත ප්‍රකාශයකට තුඩු දෙන්නේ නැද්ද?

නැවතත්, මෙම තර්කයේ දෙපැත්තේම මට එකඟ විය හැකි කරුණු තිබේ, නමුත් මෙය බොහෝ මිනිසුන්ට වඩාත්ම අර්ථවත් බව මට පෙනේ (කේතය වඩාත් නඩත්තු කළ හැකි).

අයිතමය තිබේද නැද්ද යන්න දැන ගැනීමට අවශ්‍ය නම් ශුන්‍යය වෙත ආපසු යන්න. එසේ නොමැතිනම්, අපේක්ෂිත දත්ත වර්ගය නැවත ලබා දෙන්න. ඔබ අයිතම ලැයිස්තුවක් ආපසු එවන්නේ නම් මෙය විශේෂයෙන් සත්‍ය වේ. අමතන්නාට ලැයිස්තුවක් අවශ්‍ය යැයි උපකල්පනය කිරීම සාමාන්‍යයෙන් ආරක්ෂිතයි, ඔවුන්ට ලැයිස්තුව හරහා නැවත කියවීමට අවශ්‍ය වනු ඇත. බොහෝ (බොහෝ? සියල්ලම?) භාෂා අසාර්ථක වන්නේ ඔබ හිස් ලැයිස්තුවක් හරහා නැවත කියවීමට උත්සාහ කළත් නොවේ.

මේ වගේ කේත භාවිතා කිරීමට උත්සාහ කිරීම කලකිරීමට පත්වන බව මට පෙනේ, එය අසාර්ථක වීමට පමණි:

for thing in get_list_of_things() {
    do_something_clever(thing)
}

මට කිසිම ඇති විට මෙම නඩුව සඳහා විශේෂ අවස්ථාවක් එක් කිරීමට තිබිය යුතු නොවේ දේවල් .

එය ක්‍රමයේ අර්ථ නිරූපණය මත රඳා පවතී. ඔබට සමහර විට නියම කළ හැකිය, ඔබේ ක්‍රමය පිළිගන්නේ "ශුන්‍ය නොවේ" පමණි. ජාවා හි ඔබට සමහර පාර-දත්ත විවරණ භාවිතා කරමින් ප්‍රකාශ කළ හැකිය:

string ReverseString(@NotNull String stringToReverse)

ඔබ කෙසේ හෝ ප්‍රතිලාභ අගය සඳහන් කළ යුතුය. ඔබ ප්‍රකාශ කරන්නේ නම්, ඔබ පිළිගන්නේ NotNull අගයන් පමණි, ඔබ හිස් නූලක් ආපසු ලබා දීමට බැඳී සිටී (ආදානය හිස් නූලක් නම්).

දෙවන නඩුව එහි අර්ථකථනවල ටිකක් සංකීර්ණයි. මෙම ක්‍රමය යම් පුද්ගලයකුගේ මූලික යතුරෙන් ආපසු ලබා දීම නම් (සහ පුද්ගලයා පවතිනු ඇතැයි අපේක්ෂා කෙරේ), වඩා හොඳ ක්‍රමය වන්නේ ව්‍යතිරේකය විසි කිරීමයි.

Person FindPerson(int personID)

ඔබ අනුමාන කරන ලද යම් හැඳුනුම්පතකින් පුද්ගලයෙකුව සෙව්වොත් (එය මට අමුතු දෙයක් ලෙස පෙනේ), ඔබ එම ක්‍රමය ull අවලංගු ලෙස ප්‍රකාශ කිරීම හොඳය.

හැකි සෑම විටම ශුන්‍ය වස්තු රටාව භාවිතා කිරීමට මම නිර්දේශ කරමි. එය ඔබගේ ක්‍රම ඇමතීමේදී කේතය සරල කරයි, තවද ඔබට කැත කේත කියවීමට නොලැබේ

if (someObject != null && someObject.someMethod () != whateverValue)

නිදසුනක් වශයෙන්, කිසියම් රටාවකට ගැළපෙන වස්තු එකතුවක් යම් ක්‍රමයක් මඟින් ආපසු ලබා දෙන්නේ නම්, හිස් එකතුවක් ආපසු nullයැවීම නැවත පැමිණීමට වඩා අර්ථවත් වන අතර, මෙම හිස් එකතුවට නැවත යෙදීම මඟින් කාර්ය සාධන ද .ුවමක් නොලැබේ. තවත් කාරණයක් වනුයේ දත්ත ලොග් කිරීම සඳහා භාවිතා කරන පන්ති උදාහරණය නැවත ලබා දෙන ක්‍රමයක් nullවන අතර එය මගේ මතය අනුව වඩා ශුන්‍ය වස්තුවක් ආපසු ලබා දීම වඩා සුදුසුය. මන්දයත් පරිශීලකයන්ට නැවත යොමු කරන ලද යොමු දැයි පරීක්ෂා කර බැලීමට බල නොකෙරේ null.

නැවත පැමිණීම nullඅර්ථවත් වන අවස්ථාවන්හිදී ( findPerson ()උදාහරණයක් ලෙස ක්‍රමවේදය ඇමතීම ), මම අවම වශයෙන් වස්තුව තිබේ නම් නැවත පැමිණෙන ක්‍රමයක් ලබා දීමට උත්සාහ කරමි ( personExists (int personId)නිදසුනක් ලෙස), තවත් උදාහරණයක් ජාවාහි ඇති containsKey ()ක්‍රමයක් වේ Map). අපේක්ෂිත වස්තුව ලබා ගත නොහැකි වීමේ හැකියාවක් ඇති බව ඔබට පහසුවෙන් දැකිය හැකි බැවින් එය ඇමතුම්කරුවන්ගේ කේත පිරිසිදු කරයි (පුද්ගලයා නොපවතී, යතුර සිතියමේ නොමැත). nullමගේ මතය අනුව කේතය අපැහැදිලි දැයි නිරන්තරයෙන් පරීක්ෂා කිරීම .

පහත දැක්වෙන කොන්දේසි අදාළ වන්නේ නම් පමණක් ආපසු පැමිණිය හැකි හොඳම දේ ශුන්‍යය:

• සාමාන්‍ය ක්‍රියාකාරිත්වයේ දී ශුන්‍ය ප්‍රති result ලය අපේක්ෂා කෙරේ . සමහර සාධාරණ තත්වයන් යටතේ ඔබට පුද්ගලයෙකු සොයා ගැනීමට නොහැකි වනු ඇතැයි අපේක්ෂා කළ හැකිය, එබැවින් සොයා ගන්න පුද්ගල () ශුන්‍ය ආපසු පැමිණීම හොඳයි. කෙසේ වෙතත් එය අව්‍යාජ අනපේක්ෂිත අසාර්ථකත්වයක් නම් (උදා: saveMyImportantData () නම් ශ්‍රිතයක) ඔබ ව්‍යතිරේකයක් විසි කළ යුතුය. නමේ ඉඟියක් ඇත - ව්‍යතිරේක යනු සුවිශේෂී තත්වයන් සඳහා ය!
• null භාවිතා කරනුයේ "සොයාගත නොහැකි / වටිනාකමක් නැත" යන්නයි . ඔබ වෙනත් දෙයක් අදහස් කරන්නේ නම්, වෙනත් දෙයක් ආපසු දෙන්න! හොඳ උදාහරණ වනුයේ පාවෙන ලක්ෂ්‍ය මෙහෙයුම් ඉන්ෆිනිටි හෝ නාඑන් වෙත ආපසු යාමයි - මේවා නිශ්චිත අර්ථයන් සහිත අගයන් වන බැවින් ඔබ මෙහි ශුන්‍ය ලෙස ආපසු පැමිණියහොත් එය ව්‍යාකූල වනු ඇත.
• ශ්‍රිතය යනු findPerson () වැනි තනි අගයක් ලබා දීමයි. එය එකතුවක් ආපසු ලබා දීම සඳහා නිර්මාණය කර ඇත්නම් උදා: findAllOldPeople () නම් හිස් එකතුවක් වඩාත් සුදුසුය. මෙහි සහසම්බන්ධය නම්, එකතුවක් ආපසු ලබා දෙන ශ්‍රිතයක් කිසි විටෙකත් ශුන්‍ය නොවිය යුතුය .

ඊට අමතරව, ශ්‍රිතය ශුන්‍ය විය හැකි බව ඔබ ලේඛනගත කිරීමට වග බලා ගන්න .

ඔබ මෙම නීති අනුගමනය කරන්නේ නම්, ශුන්‍යයන් බොහෝ දුරට හානිකර නොවේ. ඔබ ශුන්‍යය පරීක්ෂා කිරීමට අමතක කළහොත්, සාමාන්‍යයෙන් ඔබට වහාම වහාම NullPointerException එකක් ලැබෙනු ඇති අතර එය සාමාන්‍යයෙන් නිවැරදි කිරීමට පහසු දෝෂයකි. ව්‍යතිරේකයකින් තොරව ඔබේ පද්ධතිය වටා නිහ ly ව ප්‍රචාරය වන දත්ත දූෂිත විය හැකි ව්‍යාජ ප්‍රතිලාභ අගයක් (උදා: හිස් නූලක්) තිබීමට වඩා මෙම අසාර්ථක වේගවත් ප්‍රවේශය වඩා හොඳය .

අවසාන වශයෙන්, ඔබ මෙම රීති ප්‍රශ්නයේ ලැයිස්තුගත කර ඇති කාර්යයන් දෙකට අදාළ කරන්නේ නම්:

• FindPerson - පුද්ගලයා සොයාගත නොහැකි නම් මෙම ශ්‍රිතය අහෝසි වීම සුදුසුය
• ReverseString - නූලක් සම්මත කළහොත් එය කිසි විටෙකත් ප්‍රති result ලයක් සොයා ගැනීමට අසමත් නොවන බවක් පෙනේ (හිස් නූල් ද ඇතුළුව සියලු නූල් ආපසු හැරවිය හැකි බැවින්). එබැවින් එය කිසි විටෙකත් ශුන්‍ය නොවිය යුතුය. යමක් වැරදුනහොත් (මතකයෙන් බැහැරද?) එය ව්‍යතිරේකයක් විසි කළ යුතුය.

වර්ගය සාදන්නා ගැන මිනිසුන් දැනටමත් පවසා ඇති දේට එකතු කිරීම Maybe:

එන්පීඊ අවදානමට ලක් නොවී තවත් විශාල වාසියක් වන්නේ අර්ථකථනයයි. ක්‍රියාකාරී ලෝකයේ, අප පිරිසිදු කාර්යයන් සමඟ කටයුතු කරන විට, ක්‍රියාවට නැංවීමේදී ඒවායේ ප්‍රතිලාභ වටිනාකමට සමාන වන කාර්යයන් කිරීමට අපි කැමතියි . පහත දැක්වෙන කාරණය සලකා බලන්න String.reverse(): මෙය එක්තරා නූලක් ලබා දුන් ශ්‍රිතයක් එම නූලෙහි ප්‍රතිලෝම අනුවාදය නියෝජනය කරයි. සෑම නූලක්ම ආපසු හැරවිය හැකි නිසා මෙම නූල් පවතින බව අපි දනිමු (නූල් මූලික වශයෙන් ඇණවුම් කරන ලද අක්ෂර කට්ටල).

දැන්, කුමක් ගැනද findCustomer(int id)? මෙම ශ්‍රිතය මඟින් ලබා දී ඇති හැඳුනුම්පත ඇති පාරිභෝගිකයා නියෝජනය කරයි. මෙය පැවතිය හැකි හෝ නොවිය හැකි දෙයකි. නමුත් මතක තබා ගන්න, ශ්‍රිතයන්ට තනි ප්‍රතිලාභ අගයක් ඇත, එබැවින් ඔබට සැබවින්ම පැවසිය නොහැක “මෙම ශ්‍රිතය පාරිභෝගිකයෙකුට ලබා දී ඇති හැඳුනුම්පත හෝ ආපසු ලබා දෙයි null.

nullශුන්‍ය වස්තුවක් ආපසු ලබා දීම සහ ආපසු ලබා දීම යන මගේ ප්‍රධාන ගැටළුව මෙයයි . ඔවුන් නොමඟ යවන සුළුය. nullගනුදෙනුකරුවෙකු නොවන අතර එය ඇත්ත වශයෙන්ම "ගනුදෙනුකරුවෙකු නොමැතිවීම" ද නොවේ. එය කිසිවක් නොමැති වීමයි. එය කිසිවක් සඳහා යතුරු රහිත දර්ශකයක් පමණි. ඉතා පහත් මට්ටමේ සහ ඉතා කැත සහ ඉතා දෝෂ සහිත. ශුන්‍ය වස්තුවක් ද මෙහි නොමඟ යවන සුළුය. ශුන්‍ය ගනුදෙනුකරුවෙක් ගනුදෙනුකරුවෙකි. එය එකක් නොමැති වීම නොවේ, ඉල්ලූ හැඳුනුම්පත ඇති පාරිභෝගිකයා නොවේ, එබැවින් එය ආපසු ලබා දීම වැරදිය. මෙය මා ඉල්ලා සිටි පාරිභෝගිකයා නොවේ, නමුත් තවමත් ඔබ කියා සිටින්නේ ඔබ ගනුදෙනුකරුවෙකු ආපසු ලබා දුන් බවයි. එහි වැරදි හැඳුනුම්පතක් ඇත, පැහැදිලිවම මෙය දෝෂයකි. එය ක්‍රමයේ නම සහ අත්සන මගින් යෝජනා කරන ලද කොන්ත්‍රාත්තුව බිඳ දමයි. ඔබේ සැලසුම පිළිබඳ දේවල් උපකල්පනය කිරීමට හෝ ප්‍රලේඛන කියවීමට සේවාදායක කේතය අවශ්‍ය වේ.

මෙම ගැටළු දෙකම විසඳනු ලබන්නේ a Maybe Customer. හදිසියේම, අපි නොකියන්නේ "මෙම ශ්‍රිතය පාරිභෝගිකයා ලබා දී ඇති හැඳුනුම්පත සමඟ නිරූපණය කරයි". අපි කියන්නේ "මෙම ශ්‍රිතය පාරිභෝගිකයා ලබා දී ඇති හැඳුනුම්පත තිබේ නම් එය නිරූපණය කරයි . එය දැන් කරන්නේ කුමක්ද යන්න පිළිබඳව ඉතා පැහැදිලිව හා පැහැදිලිව පෙනේ. ඔබ දැනට නොමැති හැඳුනුම්පතක් සමඟ ගනුදෙනුකරුගෙන් ඉල්ලුවොත් ඔබට ලැබෙනු ඇත Nothing. මෙය වඩා හොඳ වන්නේ කෙසේද? වඩා null? එන්පීඊ අවදානම සඳහා පමණක් නොව, වර්ගය Nothingපමණක් නොවන Maybeනිසා ය Maybe Customer. එය අර්ථකථන අර්ථයක් ඇත.එය විශේෂයෙන් අදහස් කරන්නේ "ගනුදෙනුකරුවෙකු නොමැතිවීම", එවැනි ගනුදෙනුකරුවෙකු නොපවතින බව අඟවයි.

ශුන්‍යය සමඟ ඇති තවත් ගැටළුවක් නම් එය අපැහැදිලි වීමයි. ඔබ ගනුදෙනුකරු සොයා නොගත්තේද, නැතහොත් ඩීබී සම්බන්ධතා දෝෂයක් තිබේද? නැතහොත් එම ගනුදෙනුකරු බැලීමට මට අවසර නොමැතිද?

ඔබට හැසිරවීමට මෙවැනි දෝෂ අවස්ථා කිහිපයක් තිබේ නම්, ඔබට එම අනුවාදයන් සඳහා ව්‍යතිරේකයන් විසි කළ හැකිය (නැතහොත් මම මේ ආකාරයට කැමතියි) ඔබට නැවත පැමිණිය හැකිය Either CustomerLoadError Customer, එය වැරදුණු දෙයක් හෝ ආපසු පැමිණි පාරිභෝගිකයා නියෝජනය කරයි. එහි සියලු වාසි ඇති Maybe Customerඅතර වැරැද්ද කුමක් දැයි නියම කිරීමට ඔබට ඉඩ සලසයි.

මා පසුපස ඇති ප්‍රධානතම දෙය නම් එහි අත්සනෙහි ශ්‍රිතයේ කොන්ත්‍රාත්තුව අල්ලා ගැනීමයි. දේවල් උපකල්පනය නොකරන්න, නොවරදින සම්මුතීන් මත රඳා නොසිටින්න, පැහැදිලි වන්න.

මගේ මතය අනුව NULL නැවත පැමිණීම, යම් හිස් ප්‍රති result ලයක් ලබා දීම (උදා: හිස් නූල හෝ හිස් ලැයිස්තුවක්) සහ ව්‍යතිරේකයක් විසි කිරීම අතර වෙනසක් ඇත.

මම සාමාන්‍යයෙන් පහත දැක්වෙන ප්‍රවේශය ගන්නෙමි. ශ්‍රිතයක් හෝ ක්‍රමයක් f (v1, ..., vn) ඇමතුම ශ්‍රිතයක යෙදුම ලෙස මම සලකමි

f : S x T1 x ... x Tn -> T

එහිදී S එය "ලෝකයේ තත්වය" T1, ..., Tn යනු ආදාන පරාමිතීන් වන අතර T යනු ආපසු එන වර්ගයයි.

මම මුලින්ම උත්සාහ කරන්නේ මෙම ශ්‍රිතය අර්ථ දැක්වීමටයි. ශ්‍රිතය අර්ධ නම් (එනම් එය අර්ථ දක්වා නොමැති ආදාන අගයන් කිහිපයක් තිබේ) මෙය සං signal ා කිරීම සඳහා මම NULL නැවත ලබා දෙමි. මෙයට හේතුව ගණනය කිරීම සාමාන්‍යයෙන් අවසන් කිරීමට මට අවශ්‍ය නිසා සහ මා ඉල්ලා ඇති ශ්‍රිතය ලබා දී ඇති යෙදවුම් මත අර්ථ දක්වා නොමැති බවයි. ආදාන මත ශ්‍රිතය අර්ථ දක්වා ඇති නිසාත්, හිස් නූල නිවැරදි ප්‍රති .ලය නිසාත්, උදා: ප්‍රතිලාභ අගයක් ලෙස හිස් නූලක් භාවිතා කිරීම අපැහැදිලි ය.

මම කරන මා ෙවත පවරා කේතය දී NULL පහිටුම් දක්වනය සඳහා අමතර චෙක්පත හිතන්නේ අවශ්ය ඔබ අර්ධ කාර්යය අයදුම් කර ඇති අතර එය ලබා දී ආදානය සඳහා අර්ථ දක්වා නැත නම්, ඔබ නම් ශ්රිතය කියන්න හඳුන්වන ක්රමය කර්තව්යය නිසා.

ගණනය කිරීම සිදු කිරීමට ඉඩ නොදෙන දෝෂ සඳහා ව්‍යතිරේක භාවිතා කිරීමට මම කැමැත්තෙමි (එනම් පිළිතුරක් සොයා ගැනීමට නොහැකි විය).

උදාහරණයක් ලෙස, මට පන්තියේ ගනුදෙනුකරුවෙකු සිටින අතර මට ක්‍රමයක් ක්‍රියාත්මක කිරීමට අවශ්‍ය යැයි සිතමු

Customer findCustomer(String customerCode)

යෙදුම් දත්ත ගබඩාවේ ගනුදෙනුකරුවෙකු එහි කේතය මගින් සෙවීමට. මෙම ක්රමය තුළ, මම කැමතියි

• විමසුම සාර්ථක නම් පන්ති පාරිභෝගිකයාගේ වස්තුවක් ආපසු එවන්න,
• විමසුමේ කිසිදු ගනුදෙනුකරුවෙකු සොයාගත නොහැකි නම් ශුන්‍යය වෙත ආපසු යන්න.
• දත්ත සමුදායට සම්බන්ධ වීමට නොහැකි නම් ව්‍යතිරේකයක් විසි කරන්න.

ශුන්‍ය සඳහා අමතර චෙක්පත්, උදා

Customer customer = findCustomer("...");
if (customer != null && customer.getOrders() > 0)
{
    ...
}

මම කරන දෙයෙහි අර්ථකථනයේ කොටසක් වන අතර කේතය වඩා හොඳින් කියවීම සඳහා මම "ඒවා මඟහරින්නේ" නැත. කේතය සරල කිරීම සඳහා ගැටලුවේ අර්ථ නිරූපණය සරල කිරීම හොඳ පුරුද්දක් යැයි මම නොසිතමි.

ඇත්ත වශයෙන්ම, ශුන්‍යය පරීක්ෂා කිරීම බොහෝ විට සිදුවන බැවින් භාෂාව ඒ සඳහා විශේෂ සින්ටැක්ස් සඳහා සහය දක්වන්නේ නම් හොඳයි.

පංතියක ශූන්‍ය වස්තුව අනෙක් සියලුම වස්තූන්ගෙන් වෙන්කර හඳුනාගත හැකි තාක් කල් (ශුන්‍ය වස්තු රටාව (ලාෆ් විසින් යෝජනා කරන පරිදි) භාවිතා කිරීම ගැන ද මම සලකා බලමි.

එකතු කිරීම් ආපසු ලබා දෙන ක්‍රම හිස්ව තිබිය යුතු නමුත් අනෙක් ඒවාට ශුන්‍යව ආපසු යා හැකිය, මන්ද එකතු කිරීම් සඳහා එය සිදුවිය හැකි නිසා ඔබට වස්තුවක් ඇති නමුත් එහි කිසිදු අංගයක් නොමැති බැවින් ඇමතුම්කරු ප්‍රමාණාත්මකව දෙකටම වලංගු වේ.

මට මෙහි නඩු දෙකක් තිබේ. ඔබ යම් ආකාරයක ලැයිස්තුවක් ආපසු එවන්නේ නම්, ඔබ කුමක් වුවත් ලැයිස්තුව සෑම විටම ආපසු එවිය යුතුය, ඔබට එය දැමීමට කිසිවක් නොමැති නම් හිස්ය.

ඕනෑම විවාදයක් මා දකින එකම අවස්ථාව වන්නේ ඔබ තනි අයිතමයක් ආපසු ලබා දෙන විටය. එවැනි තත්වයන් අසාර්ථක වුවහොත් එය ඉක්මණින් අසාර්ථක වීමට හේතු වන පරිදි නැවත පැමිණීමට මම කැමැත්තෙමි.

ඔබ ශුන්‍ය වස්තුවක් ආපසු ලබා දෙන්නේ නම් සහ අමතන්නාට සැබෑ වස්තුවක් අවශ්‍ය නම් ඔවුන් ඉදිරියට ගොස් අනපේක්ෂිත හැසිරීම් ඇති කරන ශුන්‍ය වස්තුව භාවිතා කිරීමට උත්සාහ කළ හැකිය. මම හිතන්නේ ඔවුන් තත්වය සමඟ කටයුතු කිරීමට අමතක කළහොත් පුරුද්දට යාම හොඳය. යමක් වැරදියි නම් මට ASAP ව්‍යතිරේකයක් අවශ්‍යයි. ඔබ මේ ආකාරයෙන් දෝෂයක් යැවීමට ඇති ඉඩකඩ අඩුය.

1) ශ්‍රිතයේ අර්ථකථනය නම් එයට කිසිවක් ආපසු ලබා දිය නොහැකි නම්, අමතන්නා ඒ සඳහා පරීක්‍ෂා කළ යුතුය, එසේ නොමැතිනම් ඔහු උදා. ඔබේ මුදල් ගෙන එය කිසිවෙකුට දෙන්න.

2) අර්ථයෙන් සෑම විටම යමක් ආපසු ලබා දෙන (හෝ විසි කරන) කාර්යයන් කිරීම හොඳය.

ල log ු- සටහනක් සමඟ , කිසිදු ලොගර් අර්ථ දක්වා නොමැති නම් ලොග් නොවන ලොගර් නැවත ලබා දීම අර්ථවත් කරයි. එකතු කිරීම ආපසු ලබා දෙන විට, කිසිවක් ආපසු ලබා දීම කිසිසේත්ම අර්ථවත් නොවේ (“ප්‍රමාණවත් තරම් අඩු මට්ටමක” හැර, එකතුව යනු දත්ත මිස එහි අඩංගු දේ නොවේ) කිසිවක් ආපසු ලබා නොදීම, මන්ද හිස් කට්ටලයක් යනු කට්ටලයක් මිස කිසිවක් නොවේ.

පුද්ගල නිදසුනක් සමඟ , මම "ශිශිර" මාර්ගයට යන්නෙමි (එදිරිව බර පැටවීම, IIRC, නමුත් කම්මැලි පැටවීම සඳහා ප්‍රොක්සි වස්තූන් විසින් එය සංකීර්ණ කර ඇත) කාර්යයන් දෙකක් ඇති අතර, එකක් ශුන්‍ය වන අතර දෙවනුව විසි කරයි.

• යෙදුම දත්ත ලබා ගත හැකි යැයි අපේක්ෂා කරන නමුත් දත්ත ලබා ගත නොහැකි නම් NULL ආපසු ලබා දිය යුතුය. නිදසුනක් ලෙස, නගරය සොයාගත නොහැකි නම්, සිප් කේතය මත පදනම්ව නගරය නැවත ලබා දෙන සේවාවක් අහෝසි විය යුතුය. එවිට අමතන්නාට ශුන්‍යය හැසිරවීමට හෝ පුපුරවා හැරීමට තීරණය කළ හැකිය.

• හැකියාවන් දෙකක් තිබේ නම් හිස් ලැයිස්තුව ආපසු ලබා දිය යුතුය. දත්ත තිබේ හෝ දත්ත නොමැත. උදාහරණයක් ලෙස ජනගහනය නිශ්චිත සංඛ්‍යාවට වඩා වැඩි නම් CITY (ය) ආපසු ලබා දෙන සේවාවක්. දී ඇති නිර්ණායකයන් සපුරාලන දත්ත නොමැති නම් එයට හිස් ලැයිස්තුවක් ආපසු ලබා දිය හැකිය.

වස්තු-නැඹුරු ලෝකයේ NULL නැවත පැමිණීම භයානක නිර්මාණයකි . කෙටියෙන් කිවහොත්, NULL භාවිතය පහත පරිදි වේ:

• තාවකාලික දෝෂ හැසිරවීම (ව්‍යතිරේක වෙනුවට)
• නොපැහැදිලි අර්ථකථනය
• වේගයෙන් අසමත් වීම වෙනුවට මන්දගාමී වේ
• පරිගණක චින්තනය එදිරිව වස්තු චින්තනය
• විකෘති සහ අසම්පූර්ණ වස්තු

සවිස්තරාත්මක පැහැදිලි කිරීමක් සඳහා මෙම බ්ලොග් සටහන පරීක්ෂා කරන්න: http://www.yegor256.com/2014/05/13/why-null-is-bad.html