හැසිරීම තීරණය කිරීම සඳහා බූලියන් පරාමිතියක් භාවිතා කිරීම වැරදිද?

වරින් වර "වැරදි" යැයි හැඟෙන පුරුද්දක් මා දැක ඇත, නමුත් එහි වැරැද්ද කුමක්දැයි මට තරයේ ප්‍රකාශ කළ නොහැක. නැත්නම් සමහර විට එය මගේ අගතිය පමණයි. මෙන්න:

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

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

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

අනෙක් පෝස්ටර් සටහන් කර ඇති පරිදි සන්දර්භය සෑම දෙයක්ම වේ (එය එක් වර්‍ගයක් නම් හෝ පසුකාලීනව නැවත සාධනය කිරීම සඳහා හිතාමතාම තාක්ෂණික ණය ගෙවා ඇති බව පිළිගෙන තිබේ නම්) බරින් ඉදිරියට නොයන්න) නමුත් පරාමිතියක් සම්මත වී ඇත්නම් ක්‍රියාත්මක කිරීමට නිශ්චිත හැසිරීම් තෝරා ගන්නා ශ්‍රිතයක් තුළට, පසුව පියවරෙන් පියවර පිරිපහදු කිරීම අවශ්‍ය වේ; මෙම ශ්‍රිතය කුඩා ශ්‍රිතවලට කැඩීමෙන් වඩාත් සංයුක්ත ඒවා නිපදවනු ඇත.

ඉතින් ඉහළ සංයුක්ත කාර්යයක් යනු කුමක්ද?

එය එක් දෙයක් හා එක් දෙයක් පමණක් කරන ශ්‍රිතයකි.

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

ප්‍රවේශ පාලනයේ අවශ්‍යතා කාර්ය, ක්‍රියා හෝ විධානයන්ගෙන් වෙන් කිරීම වඩා හොඳය.

ඔබ දැනටමත් සඳහන් කර ඇති පරිදි, මෙම උත්සුකයන් අතරමැදි බැඳීමක් ඇති බව පෙනේ.

එබැවින්, සංයුක්තතාව පිළිබඳ සංකල්පය, ප්‍රශ්නයේ ක්‍රියාකාරිත්වය ඉහළ සංයුක්ත නොවන බවත්, වඩාත් සංයුක්ත ශ්‍රිත සමූහයක් බිහි කිරීම සඳහා කේතය ප්‍රතිනිර්මාණය කළ හැකි බවත් හඳුනා ගැනීමට අපට උපකාරී වේ.

එබැවින් ප්‍රශ්නය නැවත ඉදිරිපත් කළ හැකිය; චර්යාත්මක තේරීම් පරාමිතීන් සම්මත කිරීම අප සියලු දෙනා එකඟ වන හෙයින්, අපි කාරණා වැඩි දියුණු කරන්නේ කෙසේද?

මම පරාමිතිය සම්පූර්ණයෙන්ම ඉවත් කරමි. පරීක්ෂා කිරීම සඳහා පවා ප්‍රවේශ පාලනය අක්‍රිය කිරීමේ හැකියාව තිබීම ආරක්ෂක අවදානමකි. පරීක්ෂණ අරමුණු සඳහා මුරණ්ඩු හෝ සමච්චල් කරන්න අවසර දී ඇති ප්‍රවේශය සහ ප්‍රවේශය ප්‍රතික්ෂේප කළ අවස්ථා දෙකම පරීක්ෂා කිරීම සඳහා ප්‍රවේශ චෙක්පත කිරීම.

Ref: සහජීවනය (පරිගණක විද්‍යාව)

මම බොහෝ කලකට පෙර මෙම රටාව භාවිතා කිරීම නැවැත්තුවා, ඉතා සරල හේතුවක් නිසා; නඩත්තු පිරිවැය. කිහිප වතාවක්ම frobnicate(something, forwards_flag)මගේ කේතයේ බොහෝ වාර ගණනක් කැඳවනු ලැබූ යම් ක්‍රියාකාරිත්වයක් ඇති බව මට පෙනී ගිය අතර, අගයෙහි අගය falseලෙස සම්මත කළ කේතයේ සියලුම ස්ථාන සොයා ගැනීමට අවශ්‍ය විය forwards_flag. ඔබට ඒවා පහසුවෙන් සෙවිය නොහැක, එබැවින් මෙය නඩත්තු හිසරදයක් බවට පත්වේ. ඔබට එම සෑම වෙබ් අඩවියකම දෝෂ නිරාකරණය කිරීමට අවශ්‍ය නම්, ඔබට එකක් මග හැරුණහොත් ඔබට අවාසනාවන්ත ගැටළුවක් ඇතිවිය හැකිය.

නමුත් ප්‍රවේශය මූලික වශයෙන් වෙනස් නොකර මෙම විශේෂිත ගැටළුව පහසුවෙන් විසඳා ගත හැකිය:

enum FrobnicationDirection {
  FrobnicateForwards,
  FrobnicateBackwards;
};

void frobnicate(Object what, FrobnicationDirection direction);

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

කෙසේ වෙතත්, අවම වශයෙන් ප්‍රතිපත්තිමය වශයෙන් මේ ආකාරයෙන් ධජය පසුකර යාමේ තවත් ගැටළුවක් ඇත. මෙම සැලසුම ඇති සමහර (සමහර) පද්ධති කේතයේ ගැඹුරින් කැදැලි කොටසේ (ධජය භාවිතා කරන) පිටත ස්ථර වලට ක්‍රියාත්මක කිරීමේ තොරතුරු පිළිබඳ ඕනෑවට වඩා දැනුම නිරාවරණය කිරීම විය හැකිය (කුමන අගය පසු කළ යුතුද යන්න දැනගත යුතුය) මෙම ධජයේ). ලැරී කොන්ස්ටන්ටයින්ගේ පාරිභාෂිතය භාවිතා කිරීම සඳහා, මෙම සැලසුම සැකසුම්කරු සහ බූලියන් ධජයේ පරිශීලකයා අතර අධික ලෙස සම්බන්ධ වීමක් තිබිය හැකිය . කෝඩ්බේස් ගැන වැඩි යමක් නොදැන ෆ්‍රැන්කි මෙම ප්‍රශ්නය පිළිබඳව යම් තරමකින් නිශ්චිතව පැවසීම දුෂ්කර ය.

ඔබ ලබා දෙන නිශ්චිත උදාහරණ ආමන්ත්‍රණය කිරීම සඳහා, එක් එක් කාරණය සම්බන්ධයෙන් මට යම් තරමක සැලකිල්ලක් ඇති නමුත් ප්‍රධාන වශයෙන් අවදානම් / නිවැරදිභාවය පිළිබඳ හේතු නිසා ය. I.e. මෙම ශ්‍රිතය). යමෙකු පරාමිතිය පසු කිරීම අතහැර දමා ඇති නිසා ඔබට දෝෂයක් තිබේ.

සෑම කාර්යයක් සඳහාම පාහේ සම්මත කළ යුතු පද්ධති-රාජ්‍ය දර්ශකයක් ඇත්ත වශයෙන්ම ගෝලීය විචල්‍යයක් බව පිළිගැනීම වටී. ගෝලීය විචල්‍යයක අවාසි බොහෝමයක් අදාළ වේ. බොහෝ අවස්ථාවලදී එම දත්තවල පදනම මත නිවැරදිව ක්‍රියා කිරීම සඳහා වගකිව යුතු වස්තුවක් තුළ පද්ධති තත්වය (හෝ පරිශීලකයාගේ අක්තපත්‍ර හෝ පද්ධතියේ අනන්‍යතාවය) පිළිබඳ දැනුම සංයුක්ත කිරීම වඩා හොඳ පුරුද්දක් යැයි මම සිතමි. අමු දත්ත වලට පටහැනිව ඔබ එම වස්තුව පිළිබඳ සඳහනක් වටා ගමන් කරයි. මෙහි ඇති ප්‍රධාන සංකල්පය වන්නේ සංවෘත කිරීමයි.

මෙය අනිවාර්යයෙන්ම වැරදි නොවන නමුත් එයට කේත සුවඳක් නිරූපණය කළ හැකිය .

බූලියන් පරාමිතීන් සම්බන්ධයෙන් වැළකී සිටිය යුතු මූලික අවස්ථාව නම්:

public void foo(boolean flag) {
    doThis();
    if (flag)
        doThat();
}

එවිට කරන විට ඔබ සාමාන්යයෙන් කතා කියලා foo(false)සහ foo(true)ඔබට අවශ්ය තන්හි මත පදනම්ව.

මෙය සැබවින්ම ගැටළුවක් වන්නේ එය නරක සහජීවනය පිළිබඳ සිද්ධියක් වන බැවිනි. ඔබ සැබවින්ම අවශ්‍ය නොවන ක්‍රම අතර පරායත්තතාවයක් නිර්මාණය කරයි.

මෙම අවස්ථාවේ දී ඔබ කළ යුත්තේ ඉවත්ව යාම doThisසහ doThatවෙනම හා පොදු ක්‍රම ලෙස එසේ කිරීම ය:

doThis();
doThat();

හෝ

doThis();

එමඟින් ඔබ නිවැරදි තීරණය ඇමතුම වෙත තබයි (හරියටම ඔබ බූලියන් පරාමිතියක් පසුකරන්නාක් මෙන්) සම්බන්ධ කිරීම නිර්මාණය නොකර.

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

මෙය මා ලියූ උදාහරණ මත පදනම්ව මෙම ගැටළුව විසඳන්නේ කෙසේද යන්න පිළිබඳ එක් උදාහරණයක් පමණි. වෙනස් ප්‍රවේශයක් අවශ්‍ය වන වෙනත් අවස්ථා තිබේ.

මාටින් ෆෝලර්ගේ හොඳ ලිපියක් තවත් විස්තර වලින් එකම අදහස පැහැදිලි කරයි.

PS: fooසරල ක්‍රම දෙකක් ඇමතීම වෙනුවට ක්‍රමවේදය වඩාත් සංකීර්ණ ක්‍රියාත්මක කිරීමක් නම් ඔබ කළ යුත්තේ කුඩා ප්‍රතිචක්‍රීකරණ නිස්සාරණ ක්‍රමවේදයක් යෙදීම පමණි. එවිට ලැබෙන කේතය fooමා ලියූ ක්‍රියාවට සමාන වේ .

පළමුවෙන්ම: ක්‍රමලේඛනය කලාවක් තරම් විද්‍යාවක් නොවේ. එබැවින් ඉතා කලාතුරකින් "වැරදි" සහ "නිවැරදි" වැඩසටහනක් තිබේ. බොහෝ කේතීකරණ ප්‍රමිතීන් හුදෙක් සමහර ක්‍රමලේඛකයින් ප්‍රයෝජනවත් යැයි සලකන “මනාපයන්” ය; නමුත් අවසානයේ ඒවා තරමක් අත්තනෝමතික ය. එබැවින් පරාමිති තේරීමක් තමා තුළම සහ වැරදි යැයි මම කිසි විටෙකත් ලේබල් නොකරමි - නිසැකවම බූලියන් පරාමිතියක් තරම් සාමාන්‍ය හා ප්‍රයෝජනවත් දෙයක් නොවේ. තත්වය සංවර්‍ධනය කිරීම සඳහා boolean(හෝ ඒ intසඳහා) භාවිතා කිරීම බොහෝ අවස්ථාවන්හිදී යුක්ති සහගත ය.

කේතීකරණ තීරණ, මූලික වශයෙන් පදනම් විය යුත්තේ කාර්ය සාධනය සහ නඩත්තුව මත ය. කාර්ය සාධනය අවදානමට ලක් නොවන්නේ නම් (ඔබේ උදාහරණවල එය කෙසේ විය හැකිදැයි මට සිතාගත නොහැකිය), එවිට ඔබගේ ඊළඟ සලකා බැලීම විය යුත්තේ: මෙය මට (හෝ අනාගත ප්‍රතිනිර්මාණය කරන්නෙකුට) නඩත්තු කිරීම කොතරම් පහසු වේද? එය බුද්ධිමත් හා තේරුම්ගත හැකිද? එය හුදෙකලාද? ඔබ ඔබේ වෙනස් කිරීමට අදහස් කරන්නේ නම්: අසාත්මික ඇමතුම් ශ්රිතයක් ඔබේ උදාහරණයක් ඇත්ත මේ සම්බන්ධයෙන් හැකි භංගුර පෙනේ bIsUpකිරීමට bIsDownකේතය තවත් ස්ථාන ද වෙනස් කළ යුතු ආකාරය බොහෝ? එසේම, ඔබේ පරාමිති ලැයිස්තුව බැලූනයද? ඔබේ ශ්‍රිතයට පරාමිති 17 ක් තිබේ නම්, කියවීමේ හැකියාව ගැටළුවක් වන අතර, ඔබ වස්තු-නැඹුරු ගෘහ නිර්මාණ ශිල්පයේ ප්‍රතිලාභ අගය කරන්නේද යන්න නැවත සලකා බැලිය යුතුය.

මම හිතන්නේ රොබට් සී මාටින්ස් ක්ලීන් කෝඩ් ලිපියේ සඳහන් වන්නේ ඔබ ක්‍රමවේදයක් පෙන්වන විට හැකි සෑම තැනකම බූලියන් තර්ක ඉවත් කළ යුතු බවයි. ක්‍රමවේදයක් එක් දෙයක් කළ යුතු අතර එක් දෙයක් පමණක් ඔහුගේ ආදර්ශ පා o යක් යැයි මම සිතමි.

මම හිතන්නේ මෙහි වැදගත්ම දෙය ප්‍රායෝගික වීමයි.

බූලියන් සමස්ත හැසිරීම තීරණය කරන විට, දෙවන ක්‍රමයක් සාදන්න.

බූලියන් මැද හැසිරීම ටිකක් තීරණය කරන විට, කේත අනුපිටපත් කපා හැරීම සඳහා ඔබට එය එකක තබා ගැනීමට අවශ්‍ය විය හැකිය. හැකි සෑම අවස්ථාවකදීම ඔබට ක්‍රමවේදය තුනකට බෙදිය හැකිය: බූලියන් විකල්පය සඳහා ඇමතුම් ක්‍රම දෙකක් සහ වැඩවලින් වැඩි ප්‍රමාණයක් කරන ක්‍රමයක්.

උදාහරණයක් වශයෙන්:

private void FooInternal(bool flag)
{
  //do work
}

public void Foo1()
{
  FooInternal(true);
}

public void Foo2()
{
  FooInternal(false);
}

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

වෙනස් කළ නොහැකි අවස්ථාවන් නැවත ලබා දෙන තනන්නාගේ ක්‍රම මගින් හැසිරීම රිසිකරණය කිරීමේ ප්‍රවේශයට මම කැමතියි. ගුවාSplitter එය භාවිතා කරන ආකාරය මෙන්න :

private static final Splitter MY_SPLITTER = Splitter.on(',')
       .trimResults()
       .omitEmptyStrings();

MY_SPLITTER.split("one,,,,  two,three");

මෙහි ඇති වාසි:

• උසස් කියවීමේ හැකියාව
• වින්‍යාස එදිරිව ක්‍රියාකාරී ක්‍රම වෙන් කිරීම පැහැදිලි කරන්න
• වස්තුව යනු කුමක්ද, එය කළ යුතු හා නොකළ යුතු දේ ගැන සිතීමට ඔබට බල කිරීමෙන් සහජීවනය ප්‍රවර්ධනය කරයි. මෙම අවස්ථාවේ දී එය අ Splitter. ඔබ කිසි විටෙකත් someVaguelyStringRelatedOperation(List<Entity> myEntities)පන්තියකට ඇතුළත් කර නැත Splitter, නමුත් ඔබ එය StringUtilsපන්තියක ස්ථිතික ක්‍රමයක් ලෙස තැබීම ගැන සිතනු ඇත.
• අවස්ථා පූර්ව වින්‍යාස කර ඇති බැවින් පහසුවෙන් යැපීම-එන්නත් කළ හැකිය. සේවාදායකයාට සමත් විය යුතුද යන්න trueහෝ falseනිවැරදි හැසිරීම ලබා ගැනීම සඳහා ක්‍රමවේදයක් ගැන කරදර විය යුතු නැත .

අනිවාර්යයෙන්ම කේත සුවඳක් . එය තනි වගකීම් මූලධර්මය උල්ලං does නය නොකරන්නේ නම් එය බොහෝ විට කියන්න, අසන්න එපා . සලකා බලන්න:

• සංයෝජන (සහ, නමුත්, ආදිය) භාවිතා නොකර ඔබේ ක්‍රමය කරන්නේ කුමක්ද යන්න සාරාංශගත කළ හැකිද?
• ඔබේ ක්‍රමයේ උප කොටස් පහසුවෙන් වෙනත් කුඩා ක්‍රමයකට බෙදිය හැකිද? ( දේශීය විචල්‍යයක් නිර්මාණය කිරීම මෙයට ඇතුළත් වේ .)
• ඔබේ ධජය මඟින් පරාමිතියක් ඇමතිය යුතු ක්‍රමය තීරණය කරන්නේ නම්, ඔබේ පරාමිතිය ඕනෑවට වඩා කරන්නේද?
• මෙම ක්‍රමය ඔබගේ එක් පරාමිතියකට අයත්ද? (එය ඔබගේ පරාමිතියෙහි නිදර්ශන විචල්‍යයන් getters / setters භාවිතා කර තෝරා ගන්නේ නම් ඔබට පෙනෙනු ඇත.)

එම මූලධර්ම දෙකෙන් එකක් උල්ලං to නය නොකිරීමට නම්, ඔබ තවමත් එනුම් භාවිතා කළ යුතුය. බූලියන් ධජ යනු මැජික් අංකවලට සමාන බූලියන් ය . foo(false)තරම් අර්ථවත් කරයි bar(42). උපාය මාර්ග රටාව සඳහා එනූම්ස් ප්‍රයෝජනවත් විය හැකි අතර තවත් උපාය මාර්ගයක් එක් කිරීමට ඔබට ඉඩ සලසයි. ( ඒවා නිසි ලෙස නම් කිරීමට මතක තබා ගන්න .)

ඔබේ විශේෂ උදාහරණය විශේෂයෙන් මට කරදර කරයි. මෙම ධජය මෙතරම් ක්‍රම හරහා ගමන් කරන්නේ ඇයි? ඔබේ පරාමිතිය උප පංතිවලට බෙදීමට අවශ්‍ය බව පෙනේ.

ටීඑල්; ඩීආර්: බූලියන් තර්ක භාවිතා නොකරන්න.

පහත බලන්න ඇයි ඔවුන් නරක වන අතර, ඒ වෙනුවට ආකාරය (ඒමත).

බූලියන් තර්ක කියවීම ඉතා අසීරු වන අතර එමඟින් පවත්වා ගැනීමට අපහසු වේ. ප්‍රධාන ගැටළුව වන්නේ තර්කය නම් කර ඇති ක්‍රම අත්සන කියවන විට අරමුණ සාමාන්‍යයෙන් පැහැදිලි වීමයි. කෙසේ වෙතත්, බොහෝ භාෂාවල පරාමිතියක් නම් කිරීම සාමාන්‍යයෙන් අවශ්‍ය නොවේ. එම නිසා RSACryptoServiceProvider#encrypt(Byte[], Boolean)ශ්‍රිතයේදී කුමන ආකාරයේ සංකේතනයක් භාවිතා කළ යුතුද යන්න බූලියන් පරාමිතිය විසින් තීරණය කරනු ලබන ස්ථානය වැනි ප්‍රති-රටා ඔබට ඇත .

එබැවින් ඔබට මෙවැනි ඇමතුමක් ලැබෙනු ඇත:

rsaProvider.encrypt(data, true);

නිරයේ trueඇත්ත වශයෙන්ම අදහස් කරන්නේ කුමක්ද යන්න තීරණය කිරීම සඳහා පා the කයාට ක්‍රමයේ අත්සන සොයා බැලිය යුතුය . පූර්ණ සංඛ්‍යාවක් පසු කිරීම ඇත්තෙන්ම නරක ය:

rsaProvider.encrypt(data, 1);

ඔබට කියන තරමට - හෝ ඒ වෙනුවට: සුළු වශයෙන්. නිඛිල සඳහා භාවිතා කළ යුතු නියතයන් ඔබ අර්ථ දැක්වුවද, ශ්‍රිතය භාවිතා කරන්නන් ඒවා නොසලකා හැර වචනාර්ථයෙන් වටිනාකම් භාවිතා කරයි.

මෙය විසඳීමට ඇති හොඳම ක්‍රමය ගණනය කිරීමක් භාවිතා කිරීමයි . ඔබට RSAPaddingඅගයන් දෙකක් සහිත එනුම් එකක් සමත් විය යුතු නම් : OAEPනැතහොත් PKCS1_V1_5ඔබට වහාම කේතය කියවිය හැකිය:

rsaProvider.encrypt(data, RSAPadding.OAEP);

බූලියන්ට තිබිය හැක්කේ අගයන් දෙකක් පමණි. මෙයින් අදහස් කරන්නේ ඔබට තුන්වන විකල්පයක් තිබේ නම්, එවිට ඔබට ඔබේ අත්සන නැවත සකස් කළ යුතු බවයි. සාමාන්‍යයෙන් පසුපසට ගැළපීම ගැටළුවක් නම් මෙය පහසුවෙන් සිදු කළ නොහැක, එබැවින් ඔබට වෙනත් පොදු ක්‍රමයක් සමඟ ඕනෑම පොදු පන්තියක් දීර් extend කිරීමට සිදුවේ. ඔවුන් හඳුන්වා දුන් විට මයික්‍රොසොෆ්ට් අවසානයේ කළේ මෙයයිRSACryptoServiceProvider#encrypt(Byte[], RSAEncryptionPadding) විසින් බූලියන් වෙනුවට ගණන් කිරීමක් (හෝ අවම වශයෙන් ගණනය කිරීමක් අනුකරණය කරන පංතියක්) භාවිතා කළ ස්ථානය .

සම්පූර්ණ වස්තුවක් හෝ අතුරු මුහුණතක් භාවිතා කිරීම පවා පහසු විය හැකියපරාමිතිය පරාමිතිකරණය කිරීමට අවශ්‍ය පරාමිතිය ලෙස විය හැකිය. ඉහත උදාහරණයේ දී OAEP පෑඩින් අභ්‍යන්තරව භාවිතා කිරීම සඳහා හැෂ් අගය සමඟ පරාමිතිකරණය කළ හැකිය. දැන් SHA-2 හැෂ් ඇල්ගොරිතම 6 ක් සහ SHA-3 හැෂ් ඇල්ගොරිතම 4 ක් ඇති බව සලකන්න, එබැවින් ඔබ පරාමිතීන් වෙනුවට තනි ගණන් කිරීමක් පමණක් භාවිතා කරන්නේ නම් ගණන් කිරීමේ අගයන් ගණන පුපුරා යා හැකිය (මෙය මයික්‍රොසොෆ්ට් විසින් සොයා ගැනීමට යන ඊළඟ කාරණය විය හැකිය ).

බූලියන් පරාමිතීන් මඟින් ක්‍රමය හෝ පන්තිය හොඳින් සැලසුම් කර නොමැති බව පෙන්නුම් කරයි. ඉහත උදාහරණයේ දී මෙන්: .NET හැරුණු විට වෙනත් ගුප්ත ලේඛන පුස්තකාලයක් ක්‍රම අත්සනෙහි පෑඩිං කොඩියක් භාවිතා නොකරයි.

මා කැමති සියලුම මෘදුකාංග ගුරුවරුන් පාහේ බූලියන් තර්ක වලට එරෙහිව අනතුරු අඟවයි. නිදසුනක් වශයෙන්, යෝෂුවා බ්ලොච් ඔවුන්ට එරෙහිව ඉතා අගය කරන ලද “ective ලදායී ජාවා” පොතේ අනතුරු අඟවයි. පොදුවේ ඒවා සරලව භාවිතා නොකළ යුතුය. තේරුම් ගැනීමට පහසු එක් පරාමිතියක් තිබේ නම් ඒවා භාවිතා කළ හැකි යැයි ඔබට තර්ක කළ හැකිය. නමුත් එසේ වුවද: ක්‍රම දෙකක්Bit.set(boolean) භාවිතයෙන් වඩා හොඳින් ක්‍රියාත්මක වේ : සහBit.set()Bit.unset() .

ඔබට කේතය සෘජුවම ප්‍රතිනිර්මාණය කළ නොහැකි නම්, නියතයන් අවම වශයෙන් ඒවා කියවිය හැකි පරිදි අර්ථ දැක්විය හැකිය :

const boolean ENCRYPT = true;
const boolean DECRYPT = false;

...

cipher.init(key, ENCRYPT);

වඩා කියවිය හැකි:

cipher.init(key, true);

ඔබට අවශ්‍ය වුවත්:

cipher.initForEncryption(key);
cipher.initForDecryption(key);

වෙනුවට.

කිසිවෙකු පුදුම -නම්-පරාමිතීන් සඳහන් නොකිරීම මට පුදුමයකි .

බූලියන් ධජ සමඟ මා දකින ගැටලුව නම් ඒවා කියවීමේ හැකියාව රිදවීමයි. උදාහරණයක් ලෙස, මොනවාද කරන්නේ? trueතුළ

myObject.UpdateTimestamps(true);

කරන්න? මට අදහසක් නැහැ. නමුත් කුමක් ගැනද:

myObject.UpdateTimestamps(saveChanges: true);

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

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

//Enum used
double a = Math.Round(b, MidpointRounding.AwayFromZero);

//Two separate methods used
IEnumerable<Stuff> ascendingList = c.OrderBy(o => o.Key);
IEnumerable<Stuff> descendingList = c.OrderByDescending(o => o.Key); 

එහි වැරැද්ද කුමක්දැයි මට තරයේ ප්‍රකාශ කළ නොහැක.

එය කේත සුවඳක් මෙන් පෙනේ නම්, කේත සුවඳක් මෙන් දැනේ නම් සහ - හොඳින් - කේත සුවඳක් මෙන් දැනේ නම්, එය බොහෝ විට කේත සුවඳකි.

ඔබට කිරීමට අවශ්‍ය වන්නේ:

1) අතුරු ආබාධ ඇති ක්‍රම වලින් වළකින්න.

2) අවශ්‍ය රාජ්‍යයන් මධ්‍යම, විධිමත් රාජ්‍ය යන්ත්‍රයක් සමඟ හසුරුවන්න ( මේ වගේ ).

කාර්ය සාධනය තීරණය නොකිරීමට බූලියන් පරාමිතීන් භාවිතා කිරීමේ සියලු උත්සුකයන් සමඟ මම එකඟ වෙමි; වැඩිදියුණු කිරීම, කියවීමේ හැකියාව, විශ්වසනීයත්වය, සංකීර්ණතාව අඩු කිරීම, දුර්වල එන්කැප්සුලේෂන් සහ සහජීවනයෙන් අවදානම් අඩු කිරීම සහ නඩත්තු කිරීමේ හැකියාව සහිත හිමිකාරීත්වයේ මුළු පිරිවැය අඩු කිරීම.

70 දශකයේ මැද භාගයේ දී මම දෘඩාංග සැලසුම් කිරීම ආරම්භ කළෙමි. ඒවා දැන් අපි SCADA (අධීක්ෂණ පාලනය සහ දත්ත ලබා ගැනීම) ලෙස හඳුන්වන්නෙමු. මේවා EPROM හි මැක්‍රෝ දුරස්ථ පාලක සහ අධිවේගී දත්ත එක්රැස් කිරීම සඳහා යන්ත්‍ර කේත සහිත මනාව සකස් කරන ලද දෘඩාංග වේ.

තර්කනය මීලි සහ මුවර් යන්ත්‍ර ලෙස හැඳින්වෙන අතර එය දැන් අපි හඳුන්වන්නේ සීමිත රාජ්‍ය යන්ත්‍ර ලෙස ය . මේවා ද ක්‍රියාත්මක කළ යුතු කාල නියමයක් සහිත තථ්‍ය කාල යන්ත්‍රයක් මිස, ඒ සඳහා කෙටිමං කළ යුතුය.

දත්ත සමමුහුර්ත නමුත් විධාන අසමමුහුර්ත වන අතර විධාන තර්කනය මතක රහිත බූලියන් තර්කනය අනුගමනය කරයි, නමුත් පෙර, වර්තමාන සහ අපේක්ෂිත ඊළඟ තත්වයේ මතකය මත පදනම් වූ අනුක්‍රමික විධානයන් සමඟ. එය වඩාත් කාර්යක්ෂම යන්ත්‍ර භාෂාවෙන් (64kB පමණක්) ක්‍රියාත්මක වීම සඳහා, සෑම ක්‍රියාවලියක්ම විචක්ෂණශීලී IBM HIPO විලාසිතාවකින් අර්ථ දැක්වීමට විශාල සැලකිල්ලක් දැක්වීය. සමහර විට එයින් අදහස් කළේ බූලියන් විචල්‍යයන් පසුකර සුචිගත කළ ශාඛා කිරීමයි.

නමුත් දැන් OOK හි මතකය සහ පහසුව සමඟින්, එන්කැප්සුලේෂන් අද අත්‍යවශ්‍ය අංගයක් වන නමුත් තථ්‍ය කාලය සහ SCADA යන්ත්‍ර කේතය සඳහා බයිට් වලින් කේතය ගණනය කළ විට ද penalty ුවමක් ..

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

මෙය ක්‍රම කිහිපයකින් පැහැදිලි කර උපකාරී වේ.

ආයාචනා ප්‍රකාශය කියවන ඕනෑම කෙනෙකුට පරිශීලකයා මත පදනම්ව ප්‍රති result ලය වෙනස් වන බව වැටහෙනු ඇත.

අවසාන වශයෙන් හැඳින්වෙන ශ්‍රිතයේ දී ඔබට වඩාත් සංකීර්ණ ව්‍යාපාරික නීති පහසුවෙන් ක්‍රියාත්මක කළ හැකිය, මන්ද ඔබට ඕනෑම පරිශීලක ගුණාංගයකට ප්‍රවේශ විය හැකිය.

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

බොහෝ විට, මම මෙම නරක කේතනය සලකා බලමි. කෙසේ වෙතත්, මෙය හොඳ පුරුද්දක් විය හැකි අවස්ථා දෙකක් ගැන මට සිතිය හැකිය. එය නරක ඇයි කියා දැනටමත් පිළිතුරු රාශියක් ඇති බැවින්, එය හොඳ විය හැකි අවස්ථා දෙකක් මම ඉදිරිපත් කරමි:

පළමුවැන්න නම්, අනුපිළිවෙලෙහි ඇති සෑම ඇමතුමක්ම තමන්ගේම අර්ථයෙන් අර්ථවත් කරන්නේ නම්. එය ඉල්ලා කේතය නම් තේරුමක් ඇත හැකි සැබෑ සැබෑ, ව්යාජ හෝ බොරු වෙනස් කළ හෝ හඳුන්වන ක්රමය නම් විය ඒ වෙනුවට එය මත පසුකර වඩා සෘජුවම වීජ පරාමිතිය භාවිතා කිරීමට වෙනස් කළ යුතු ය. එකවර එවැනි ඇමතුම් දහයක සම්භාවිතාව කුඩා වන නමුත් එය සිදුවිය හැකි අතර එය එසේ වූයේ නම් එය හොඳ ක්‍රමලේඛ පුහුණුවක් වනු ඇත.

දෙවෙනි සිද්ධිය නම් අපි බූලියන් සමඟ ගනුදෙනු කරන බවයි. නමුත් වැඩසටහනට බහු නූල් හෝ සිදුවීම් තිබේ නම්, සම්මත පරාමිතීන් යනු නූල් / සිදුවීම් විශේෂිත දත්ත සොයා ගැනීමට ඇති සරලම ක්‍රමයයි. උදාහරණයක් ලෙස, වැඩසටහනකට සොකට් දෙකකින් හෝ වැඩි ගණනකින් ආදානය ලබා ගත හැකිය. එක් සොකට් එකක් සඳහා ධාවනය වන කේතයට අනතුරු ඇඟවීමේ පණිවිඩ නිපදවීමට අවශ්‍ය විය හැකි අතර, තවත් එකක් ධාවනය වන විට එසේ නොවිය හැකිය. අනතුරු ඇඟවීමේ පණිවිඩ ජනනය කළ හැකි ස්ථාන වෙත බොහෝ ක්‍රම ඇමතුම් හරහා යෑමට ඉතා ඉහළ මට්ටමක ඇති බූලියන් කට්ටලයක් පසුව (වර්ග කිරීම) අර්ථවත් කරයි. ඕනෑම ආකාරයක ගෝලීය වශයෙන් දත්ත සුරැකිය නොහැක (විශාල දුෂ්කරතාවයකින් හැර), මන්ද බහු නූල් හෝ අන්තර් සම්බන්ධිත සිදුවීම් එක් එක් ඒවායේ වටිනාකම අවශ්‍ය වන බැවිනි.

නිසැකවම, අවසාන අවස්ථාවේ දී මම බොහෝ විට පංතියක් / ව්‍යුහයක් නිර්මාණය කර ඇති අතර එහි එකම අන්තර්ගතය බූලියන් වන අතර ඒ වෙනුවට එය පසුකර යන්නෙමි . බොහෝ කලකට පෙර මට වෙනත් ක්ෂේත්‍ර අවශ්‍ය බව මට විශ්වාසයි - උදාහරණයක් ලෙස අනතුරු ඇඟවීමේ පණිවිඩ යැවිය යුත්තේ කොතැනටද යන්න.

සන්දර්භය වැදගත් ය. එවැනි ක්‍රම iOS හි බහුලව දක්නට ලැබේ. බොහෝ විට භාවිතා වන එක් උදාහරණයක් ලෙස, UINavigationController මෙම ක්‍රමය සපයන -pushViewController:animated:අතර animatedපරාමිතිය BOOL වේ. මෙම ක්‍රමය මූලික වශයෙන් එකම ආකාරයකින් දෙයාකාරයකින්ම ක්‍රියා කරයි, නමුත් ඔබ ඔව් තුළ සමත් වුවහොත් එය එක් දර්ශන පාලකයක සිට තවත් දර්ශනයකට මාරුවීම සජීවිකරණය කරයි, ඔබ සමත් නොවන්නේ නම් එය සිදු නොවේ. මෙය මුළුමනින්ම සාධාරණ බව පෙනේ; සජීවිකරණය භාවිතා කළ යුතුද නැද්ද යන්න ඔබට තීරණය කළ හැකි වන පරිදි මේ වෙනුවට ක්‍රම දෙකක් ලබා දීම මෝඩකමක් වනු ඇත.

Objective-C හි මෙවැනි දේ සාධාරණීකරණය කිරීම පහසු විය හැකිය, එහිදී ක්‍රමවේදය නම් කිරීමේ වාක්‍ය ඛණ්ඩය ඔබ C සහ Java වැනි භාෂාවලින් ලබා ගන්නා ප්‍රමාණයට වඩා එක් එක් පරාමිතීන් සඳහා වැඩි සන්දර්භයක් සපයයි. එසේ වුවද, තනි පරාමිතියක් ගන්නා ක්‍රමයක් පහසුවෙන් බූලියන් ගත හැකි අතර තවමත් අර්ථවත් වනු ඇතැයි මම සිතමි.

file.saveWithEncryption(false);    // is there any doubt about the meaning of 'false' here?