(වෙනත් නම්) හැසිරවීමට අලංකාර ක්‍රම

මෙය සුළු විකාරයකි, නමුත් සෑම විටම මට මේ වගේ දෙයක් කේත කිරීමට සිදු වූ විට, පුනරාවර්තනය මට කරදර කරයි, නමුත් විසඳුම් කිසිවක් නරක නොවන බව මට විශ්වාස නැත.

if(FileExists(file))
{
    contents = OpenFile(file); // <-- prevents inclusion in if
    if(SomeTest(contents))
    {
        DoSomething(contents);
    }
    else
    {
        DefaultAction();
    }
}
else
{
    DefaultAction();
}

• මේ ආකාරයේ තර්කනය සඳහා නමක් තිබේද?
• මමත් ඕසීඩී ද?

කුතුහලය නිසා පමණක් නම්, මම නපුරු කේත යෝජනා සඳහා විවෘතව සිටිමි ...

ශ්‍රිතය (ක්‍රමය) වෙන් කිරීම සඳහා එය උපුටා ගෙන returnප්‍රකාශය භාවිතා කරන්න :

if(FileExists(file))
{
    contents = OpenFile(file); // <-- prevents inclusion in if
    if(SomeTest(contents))
    {
        DoSomething(contents);
        return;
    }
}

DefaultAction();

නැතහොත්, වඩා හොඳ, වෙනම ලබා ගැනීමේ අන්තර්ගතයන් සහ එහි සැකසුම්:

contents_t get_contents(name_t file)
{
    if(!FileExists(file))
        return null;

    contents = OpenFile(file);
    if(!SomeTest(contents)) // like IsContentsValid
        return null;

    return contents;
}

...

contents = get_contents(file)
contents ? DoSomething(contents) : DefaultAction();

යාවත්කාලීන කිරීම:

ඇයි ව්‍යතිරේක, ඇයි OpenFileIO ව්‍යතිරේකය විසි නොකරන්නේ:
IO ගොනුව පිළිබඳ ප්‍රශ්නයට වඩා එය ඇත්තෙන්ම සාමාන්‍ය ප්‍රශ්නයක් යැයි මම සිතමි. වැනි නම් FileExists, OpenFileඅවුල් කළ හැක, නමුත් ඒවා වෙනුවට නම් Foo, Barආදිය, - එය බව පැහැදිලි වනු ඇත DefaultActionබොහෝ විට හැඳින්විය හැක DoSomething, ඒ නිසා-සුවිශේෂී නොවන නඩුව විය හැක. පීටර් ටෝක් ඔහුගේ පිළිතුර අවසානයේ මේ ගැන ලිවීය

2 වන ප්‍රභේදයේ ත්‍රිමාණ කොන්දේසි සහිත ක්‍රියාකරු සිටින්නේ ඇයි:
[C ++] ටැගය තිබේ නම්, මම එහි කොන්දේසි කොටස ifප්‍රකාශයට පත් කරමින් ප්‍රකාශයක් ලිව්වෙමි contents:

if(contents_t contents = get_contents(file))
    DoSomething(contents);
else
    DefaultAction();

නමුත් වෙනත් (සී-වැනි) භාෂාවන් සඳහා, if(contents) ...; else ...;ත්‍රිමාණ කොන්දේසි සහිත ක්‍රියාකරු සමඟ ප්‍රකාශන ප්‍රකාශයට සමාන වේ, නමුත් දිගු වේ. කේතයේ ප්‍රධාන කොටස get_contentsක්‍රියාකාරී වූ නිසා, මම කෙටි අනුවාදය භාවිතා කළෙමි (එසේම අතහැර දැමූ contentsවර්ගය). කෙසේ වෙතත්, එය මෙම ප්රශ්නයෙන් ඔබ්බට ය.

ඔබ භාවිතා කරන ක්‍රමලේඛන භාෂාව (0) කෙටි පරිපථ ද්විමය සැසඳීම් (එනම් අසත්‍ය SomeTestනම් FileExistsආපසු නොඑන්නේ නම් ) සහ (1) පැවරුම මඟින් වටිනාකමක් ලබා දෙයි ( ප්‍රති result OpenFileලය පවරා ඇති contentsඅතර එම අගය තර්කයක් ලෙස සම්මත වේ වෙත SomeTest), ඔබට පහත සඳහන් දෑ වැනි දෙයක් භාවිතා කළ හැකිය, නමුත් කේතය අදහස් දැක්වීමට ඔබට තවමත් උපදෙස් දෙනු =ලැබේ.

if( FileExists(file) && SomeTest(contents = OpenFile(file)) )
{
    DoSomething(contents);
}
else
{
    DefaultAction();
}

එසේ නම් එය කෙතරම් සංකෝචනය වී ඇත්ද යන්න මත පදනම්ව, ධජ විචල්‍යයක් තිබීම වඩා හොඳ විය හැකිය ( DefaultActionමෙම අවස්ථාවේ දී දෝෂය හසුරුවන කේතය සමඟ සාර්ථක / අසාර්ථක තත්වයන් පරීක්ෂා කිරීම වෙන් කරයි )

DefaultAction වෙත ඇමතුම පුනරාවර්තනය කිරීමට වඩා බරපතල වන්නේ ශෛලියම වන බැවින් කේතය විකලාංග නොවන ලෙස ලියා ඇත ( විකලාංග ලිවීමට හොඳ හේතු සඳහා මෙම පිළිතුර බලන්න ).

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

if(FileExists(file))
{
    if(! OnNetworkDisk(file))
    {
        contents = OpenFile(file); // <-- prevents inclusion in if
        if(SomeTest(contents))
        {
            DoSomething(contents);
        }
        else
        {
            DefaultAction();
        }
    }
    else
    {
        DefaultAction();
    }
}
else
{
    DefaultAction();
}

නමුත් 2Gb ට වඩා විශාල ලිපිගොනු විවෘත නොකළ යුතු බවට කොන්දේසියක් ද ඇත. හොඳයි, අපි නැවත යාවත්කාලීන කරමු:

if(FileExists(file))
{
    if(LessThan2Gb(file))
    {
        if(! OnNetworkDisk(file))
        {
            contents = OpenFile(file); // <-- prevents inclusion in if
            if(SomeTest(contents))
            {
                DoSomething(contents);
            }
            else
            {
                DefaultAction();
            }
        }
        else
        {
            DefaultAction();
        }
    else
    {
        DefaultAction();
    }
}
else
{
    DefaultAction();
}

එවැනි කේත ශෛලිය විශාල නඩත්තු වේදනාවක් වනු ඇති බව ඉතා පැහැදිලිය.

නිසියාකාරව විකලාංග ලෙස ලියා ඇති පිළිතුරු අතර ඇබික්ස්ගේ දෙවන උදාහරණය සහ ජෑන් හුඩෙක්ගේ පිළිතුර ඇත , එබැවින් මම එය නැවත නොකියමි , එම පිළිතුරු වල අවශ්‍යතා දෙක එකතු කිරීම පමණක් වනු ඇති බව පෙන්වා දෙන්න

if(! LessThan2Gb(file))
    return null;

if(OnNetworkDisk(file))
    return null;

(හෝ goto notexists;ඒ වෙනුවට return null;), එකතු කළ රේඛා හැර වෙනත් කේතයකට බලපාන්නේ නැත . උදා: විකලාංග.

පරීක්ෂා කිරීමේදී, සාමාන්‍ය රීතිය විය යුත්තේ ව්‍යතිරේක පරීක්ෂා කිරීම මිස සාමාන්‍ය අවස්ථාව නොවේ .

නිසැකවම:

Whatever(Arguments)
{
    if(!FileExists(file))
        goto notexists;
    contents = OpenFile(file); // <-- prevents inclusion in if
    if(!SomeTest(contents))
        goto notexists;
    DoSomething(contents);
    return;
notexists:
    DefaultAction();
}

ඔබ කිව්වේ ඔබ නපුරු විසඳුම් සඳහා පවා විවෘත බවයි, එබැවින් නපුරු ගොටෝ ගණන් භාවිතා කරමින්, නැත?

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

ඔබට ව්‍යතිරේක ඇති විට, ඒවා කියවීමට පහසු වනු ඇත, විශේෂයෙන් ඔබට OpenFile සහ DoSomething ලබා ගත හැකි නම් කොන්දේසි සෑහීමකට පත් නොවන්නේ නම් ව්‍යතිරේකය විසි කරන්න, එබැවින් ඔබට පැහැදිලි චෙක්පත් අවශ්‍ය නොවේ. C ++ හි අනෙක් අතට, ජාවා සහ සී # ව්‍යතිරේකය විසි කිරීම මන්දගාමී මෙහෙයුමකි, එබැවින් කාර්ය සාධන ලක්ෂ්‍යයේ සිට ගෝටෝ තවමත් වඩාත් යෝග්‍ය වේ.

"නපුර" පිළිබඳ සටහන: C ++ නිති අසන ප්‍රශ්න 6.15 "නපුර" ලෙස අර්ථ දක්වන්නේ:

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

එය gotoමෙම සන්දර්භය තුළ අදාළ වේ . ව්‍යුහාත්මක ප්‍රවාහ පාලන ඉදිකිරීම් බොහෝ විට වඩා හොඳය, නමුත් ඔබ ඔවුන්ගේම නපුරුකම් රාශියක් රැස් කර ගන්නා තත්වයට පත්වන විට, තත්වයට පැවරීම, මට්ටම් 3 කට වඩා ගැඹුරට කැදැල්ල, අනුපිටපත් කේතය හෝ දිගු කොන්දේසි වැනි දේ gotoඅවසන් විය හැකිය. අඩු නපුරක් වීම.

function FileContentsExists(file) {
    return FileExists(file) ? OpenFile(file) : null;
}

...

contents = FileContentExists(file);
if(contents && SomeTest(contents))
{
    DoSomething(contents);
}
else
{
    DefaultAction();
}

එක් හැකියාවක්:

boolean handled = false;

if(FileExists(file))
{
    contents = OpenFile(file); // <-- prevents inclusion in if
    if(SomeTest(contents))
    {
        DoSomething(contents);
        handled = true;
    }
}
if (!handled)
{
    DefaultAction();
}

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

වෙනස් ප්‍රවේශයක් වනුයේ ව්‍යතිරේක භාවිතා කිරීමයි, උදා:

try
{
    contents = OpenFile(file); // throws IO exception if file not found
    DoSomething(contents); // calls SomeTest() and throws exception on failure
}
catch(Exception e)
{
    DefaultAction();
    // and the exception should be at least logged...
}

මෙය සරල බව පෙනේ, කෙසේ වෙතත් එය අදාළ වන්නේ නම් පමණි

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

මෙය වියුක්ත කිරීමේ ඉහළ මට්ටමක පවතී:

if (WeCanDoSomething(file))
{
   DoSomething(contents);
}
else
{
   DefaultAction();
} 

මෙය විස්තර පුරවයි.

boolean WeCanDoSomething(file)
{
    if FileExists(file)
    {
        contents = OpenFile(file);
        return (SomeTest(contents));
    }
    else
    {
        return FALSE;
    }
}

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

සමහර අය එම ප්‍රවේශය මඳක් අන්තයට ගියත් එය ඉතා පිරිසිදුයි. පයිතන්හි නිදර්ශනය කිරීමට මට ඉඩ දෙන්න:

def processFile(self):
    if self.fileMeetsTest():
        self.doSomething()
    else:
        self.defaultAction()

def fileMeetsTest(self):
    return os.path.exists(self.path) and self.contentsTest()

def contentsTest(self):
    with open(self.path) as file:
        line = file.readline()
        return self.firstLineTest(line)

කාර්යයන් එක් දෙයක් කළ යුතු යැයි ඔහු පවසන විට, ඔහු අදහස් කරන්නේ එක් දෙයක්. processFile()පරීක්ෂණයක ප්‍රති result ලය මත පදනම් වූ ක්‍රියාවක් තෝරා ගනී, එපමණයි. fileMeetsTest()පරීක්ෂණයේ සියලුම කොන්දේසි ඒකාබද්ධ කරයි, එපමණයි. contentsTest()පළමු පේළිය වෙත මාරු කරයි firstLineTest(), එපමණයි.

එය බොහෝ කාර්යයන් මෙන් පෙනේ, නමුත් එය ප්‍රායෝගිකව සෘජු ඉංග්‍රීසි මෙන් කියවයි:

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

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

මෙය හැඳින්වෙන දේ සම්බන්ධයෙන්, ඔබේ කේතය වැඩි අවශ්‍යතා සපුරාලීම සඳහා වර්ධනය වන විට එය පහසුවෙන් ඊතල විරෝධී රටාව දක්වා වර්ධනය විය හැකිය ( https://softwareengineering.stackexchange.com/a/122625/33922 හි දක්වා ඇති පිළිතුරෙන් පෙන්වා ඇති පරිදි ) සහ ඊතලයකට සමාන වන කූඩු කොන්දේසි සහිත ප්‍රකාශ සහිත කේත විශාල ප්‍රමාණයක් තිබීමේ උගුලට වැටේ.

වැනි සබැඳි බලන්න;

http://codinghorror.com/blog/2006/01/flattening-arrow-code.html

http://lostechies.com/chrismissal/2009/05/27/anti-patterns-and-worst-practices-the-arrowhead-anti-pattern/

මේ පිළිබඳ තවත් බොහෝ දේ සහ වෙනත් ප්‍රති-රටා ගූගල් හි සොයාගත හැකිය.

මේ සම්බන්ධයෙන් ජෙෆ් සිය බ්ලොග් අඩවියේ සපයන විශිෂ්ට උපදෙස් කිහිපයක්;

1) ආරක්ෂක වගන්ති සමඟ කොන්දේසි ප්රතිස්ථාපනය කරන්න.

2) කොන්දේසි සහිත කොටස් වෙන් වෙන් ශ්‍රිත වලට දිරාපත් කරන්න.

3) negative ණාත්මක චෙක්පත් ධනාත්මක චෙක්පත් බවට පරිවර්තනය කරන්න

4) සෑම විටම අවස්ථාවාදී ලෙස ශ්‍රිතයෙන් ආපසු එන්න.

මුල් ප්‍රතිලාභ පිළිබඳ ස්ටීව් මැක්කොනෙල්ස් යෝජනා සම්බන්ධයෙන් ජෙෆ්ගේ බ්ලොග් අඩවියේ අදහස් කිහිපයක් බලන්න;

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

...

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

අවුරුදු 15 ක් හෝ ඊට පෙර මට ඉගැන්වූ දේ නිසා මම සෑම විටම ක්‍රියාකාරී න්‍යායකට 1 ප්‍රවේශය / පිටවීම සඳහා දායක වී සිටිමි. මට හැඟෙන්නේ මෙය කේතය කියවීමට පහසු වන අතර ඔබ සඳහන් කළ පරිදි වඩා නඩත්තු කළ හැකි බවයි

මෙය ඩ්‍රයි, ගොටෝ සහ නො-බහුවිධ ප්‍රතිලාභ රීති වලට අනුකූල වන අතර එය පරිමාණය කළ හැකි සහ මගේ මතය අනුව කියවිය හැකිය:

success = FileExists(file);
if (success)
{
    contents = OpenFile(file);
    success = SomeTest(contents);
}
if (success)
{
    DoSomething(contents);
}
else
{
    DefaultAction();
}

මම එය වෙනම ක්‍රමයකට උපුටා ගෙන පසුව:

if(!FileExists(file))
{
    DefaultAction();
    return;
}

contents = OpenFile(file);
if(!SomeTest(contents))
{
    DefaultAction();
    return;
}

DoSomething(contents);

එය ද ඉඩ දෙයි

if(!FileExists(file))
{
    DefaultAction();
    return Result.FileNotFound;
}

contents = OpenFile(file);
if(!SomeTest(contents))
{
    DefaultAction();
    return Result.TestFailed;
}

DoSomething(contents);
return Result.Success;            

එවිට ඔබට DefaultActionඇමතුම් ඉවත් DefaultActionකර ඇමතුම ක්‍රියාත්මක කිරීම අතහැර දැමිය හැකිය :

Result OurMethod(file)
{
    if(!FileExists(file))
    {
        return Result.FileNotFound;
    }

    contents = OpenFile(file);
    if(!SomeTest(contents))
    {
        return Result.TestFailed;
    }

    DoSomething(contents);
    return Result.Success;            
}

void Caller()
{
    // something, something...

    var result = OurMethod(file);
    // if (result == Result.FileNotFound || result == Result.TestFailed), or just
    if (result != Result.Success)        
    {
        DefaultAction();
    }
}

මම ජීන් පින්ඩාර්ගේ ප්‍රවේශයටද කැමතියි .

මෙම විශේෂිත අවස්ථාව සඳහා, පිළිතුර ප්‍රමාණවත් තරම් පහසුය ...

FileExistsසහ අතර ධාවන තත්වයක් ඇත OpenFile: ගොනුව ඉවත් කළහොත් කුමක් සිදුවේද?

මෙම විශේෂිත නඩුව සමඟ කටයුතු කිරීමට ඇති එකම හොඳ ක්‍රමය මඟ හැරීමයි FileExists:

contents = OpenFile(file);
if (!contents) // open failed
    DefaultAction();
else (SomeTest(contents))
    DoSomething(contents);

මෙම පිළිවෙලට මෙම ගැටලුව විශ්වාසනීය වෙනස හා කේතය පිරිසිදු කරයි.

පොදුවේ: ගැටලුව ගැන නැවත සිතා බැලීමට උත්සාහ කරන්න.

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

මේ අනුව ඔබේ ආදර්ශය මෙසේ විය හැකිය:

void DoABunchOfStuff()
{
    if(FileExists(file))
    {
        DoSomethingWithFileContent(file);
        return;
    }

    DefaultAction();
}

void DoSomethingWithFileContent(file)
{        
    var contents = GetFileContents(file)

    if(SomeTest(contents))
    {
        DoSomething(contents);
        return;
    }

    DefaultAction();
}

AReturnType GetFileContents(file)
{
    return OpenFile(file);
}

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

නියැදි කේතයේ පෙන්වා ඇති නඩුව සාමාන්‍යයෙන් තනි ifප්‍රකාශයක් දක්වා අඩු කළ හැකිය . බොහෝ පද්ධති වල, ගොනුව දැනටමත් නොපවතී නම් ගොනු විවෘත ශ්‍රිතය අවලංගු අගයක් ලබා දෙනු ඇත. සමහර විට මෙය පෙරනිමි හැසිරීමයි; වෙනත් වේලාවක එය තර්කයක් හරහා නියම කළ යුතුය. මෙයින් අදහස් කරන්නේ FileExistsපරීක්ෂණය අතහැර දැමිය හැකි අතර, පැවැත්මේ පරීක්ෂණය සහ ගොනු විවෘත කිරීම අතර ගොනු මකාදැමීමේ ප්‍රති race ලයක් ලෙස ධාවන තත්වයන්ටද එය උපකාරී වේ.

file = OpenFile(path);
if(isValidFileHandle(file) && SomeTest(file)) {
    DoSomething(file);
} else {
    DefaultAction();
}

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

OpenFileIfSomething(path:String) : FileHandle {
    file = OpenFile(path);
    if (file && SomeTest(file)) {
        return file;
    }
    return null;
}

...

if ((file = OpenFileIfSomething(path))) {
    DoSomething(file);
} else {
    DefaultAction();
}

මම ශීත කළ කොයි සමඟ එකඟ වෙමි, කෙසේ වෙතත්, සී # සඳහා කෙසේ වෙතත්, ට්‍රයිපාර්ස් ක්‍රමයේ වාක්‍ය ඛණ්ඩය අනුගමනය කිරීමට එය උපකාරී වනු ඇතැයි මම සිතුවෙමි.

if(FileExists(file) && TryOpenFile(file, out contents))
    DoSomething(contents);
else
    DefaultAction();

bool TryOpenFile(object file, out object contents)
{
    try{
        contents = OpenFile(file);
    }
    catch{
        //something bad happened, computer probably exploded
        return false;
    }
    return true;
}

ඔබ එක් ශ්‍රිතයක් තුළ ඕනෑවට වඩා කරන නිසා ඔබේ කේතය කැතයි. ඔබට ගොනුව සැකසීමට හෝ පෙරනිමි ක්‍රියාමාර්ග ගැනීමට අවශ්‍යය, එබැවින් මෙසේ කියමින් ආරම්භ කරන්න:

if (!ProcessFile(file)) { 
  DefaultAction(); 
}

පර්ල් සහ රූබි ක්‍රමලේඛකයින් ලියයි processFile(file) || defaultAction()

දැන් ගොස් ProcessFile ලියන්න:

if (FileExists(file)) { 
  contents = OpenFile(file);
  if (SomeTest(contents)) {
    processContents(contents);
    return true;
  }
}
return false;

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

interface File<T> {
    function isOK():Bool;
    function getData():T;
}

var appleFile:File<Apple> = appleStorage.get(fileURI);
if (appleFile.isOK())
    eat(file.getData());
else
    cry();

ඔබට අතිරේක පෙරහන් අවශ්‍ය විය හැකිය. ඉන්පසු මෙය කරන්න:

var appleFile = appleStorage.get(fileURI, isEdible);
//isEdible is of type Apple->Bool and will be used internally to answer to the isOK call
if (appleFile.isOK())
    eat(file.getData());
else
    cry();

මෙයද අර්ථවත් වුවද:

function eat(apple:Apple) {
     if (isEdible(apple)) 
         digest(apple);
     else
         die();
}
var appleFile = appleStorage.get(fileURI);
if (appleFile.isOK())
    eat(appleFile.getData());
else
    cry();

හොඳම දේ කුමක්ද? එය රඳා පවතින්නේ ඔබ මුහුණ දෙන සැබෑ ලෝක ගැටලුව මත ය .
නමුත් ඉවතට ගත යුතු දෙය නම්: ඔබට සංයුතිය හා බහුමාපකය සමඟ බොහෝ දේ කළ හැකිය.

පැහැදිලිව පෙනෙන දේ වැරදියි

if(!FileExists(file)) {
    DefaultAction();
    return;
}
contents = OpenFile(file);
if(!SomeTest(contents))
{
    DefaultAction();
    return;
}        
DoSomething(contents);

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

මෙය පැරණි ප්‍රශ්නයක් බව මට වැටහී ඇත, නමුත් සඳහන් නොකළ රටාවක් මම දුටුවෙමි; ප්‍රධාන වශයෙන්, ඔබ ඇමතීමට කැමති ක්‍රමය / ක්‍රම පසුව තීරණය කිරීම සඳහා විචල්‍යයක් සැකසීම (එසේ නම් ... වෙනත් ...).

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

ක්‍රමයේ සියලුම සඳහන් කිරීම් ප්‍රතිස්ථාපනය කිරීමට වඩා (සමහර විට සමහර අවස්ථා මඟ හැරී ඇත), ඒවා සියල්ලම ලැයිස්තුගත කර ඇත්තේ if ... else ... අවහිර කර කියවීමට හා වෙනස් කිරීමට පහසුය. උදාහරණයක් ලෙස ක්‍රම කිහිපයක් කැඳවිය හැකි නමුත් මම කැදැල්ල තුළ නම් ... වෙනත් නම් ... තරඟ කිහිපයකදී ක්‍රමයක් හැඳින්විය හැක.

ඔබ රාජ්‍යය නිර්වචනය කරන විචල්‍යයක් සකසන්නේ නම්, ඔබට බොහෝ ගැඹුරින් කැදැලි විකල්ප තිබිය හැකි අතර යමක් සිදු කළ යුතු විට (හෝ නොකළ යුතු) තත්වය යාවත්කාලීන කරන්න.

'DoSomething' සිදුවී ඇත්දැයි අප පරික්ෂා කරන ප්‍රශ්නයේදී ඇසූ උදාහරණයේ දී මෙන් මෙය භාවිතා කළ හැකි අතර එසේ නොවේ නම් පෙරනිමි ක්‍රියාව සිදු කරන්න. නැතහොත් ඔබට ඇමතීමට අවශ්‍ය සෑම ක්‍රමයක් සඳහාම රාජ්‍යයක් තිබිය හැකිය, අදාළ වන විට සකසා, පසුව ... ... ට පිටතින් අදාළ ක්‍රමය අමතන්න ...

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

bool ActionDone = false;

if (Method_1(object_A)) // Test 1
{
    result_A = Method_2(object_A); // Result 1

    if (Method_3(result_A)) // Test 2
    {
        Method_4(result_A); // Action 1
        ActionDone = true;
    }
}

if (!ActionDone)
{
    Method_5(); // Default Action
}

කැදැලි IF අඩු කිරීම සඳහා:

1 / මුල් ආපසු;

2 / සංයුක්ත ප්‍රකාශනය (කෙටි පරිපථ දැනුවත් කිරීම)

එබැවින්, ඔබේ උදාහරණය මේ ආකාරයට ප්‍රතිනිර්මාණය කළ හැකිය:

if( FileExists(file) && SomeTest(contents = OpenFile(file)) )
{
    DoSomething(contents);
    return;
}
DefaultAction();

"නැවත පැමිණීම" සමඟ මම බොහෝ උදාහරණ දුටුවෙමි, නමුත් සමහර විට මට අවශ්‍ය වන්නේ නව කාර්යයන් නිර්මාණය කිරීමෙන් වැළකී ඒ වෙනුවට ලූපයක් භාවිතා කිරීමයි:

while (1) {
    if (FileExists(file)) {
        contents = OpenFile(file);
        if (SomeTest(contents)) {
           DoSomething(contents);
           break;
        } 
    }
    DefaultAction();
    break;
}

ඔබට අඩු රේඛා ලිවීමට අවශ්‍ය නම් හෝ මා මෙන් අනන්ත ලූපවලට ඔබ වෛර කරන්නේ නම්, ඔබට ලූප් වර්ගය "කරන්න ... අතර (0)" ලෙස වෙනස් කර අවසන් "විවේකය" වළක්වා ගත හැකිය.

මෙම විසඳුම ගැන කෙසේද:

content = NULL; //I presume OpenFile returns a pointer 
if(FileExists(file))
    contents = OpenFile(file);
if(content != NULL && SomeTest(contents))
    DoSomething(contents);
else
    DefaultAction();

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

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

පැහැදිලිවම, වඩාත්ම අලංකාර හා සංක්ෂිප්ත විසඳුම වන්නේ පෙර සැකසුම් සාර්ව භාවිතා කිරීමයි.

#define DOUBLE_ELSE(CODE) else { CODE } } else { CODE }

මේ වගේ ලස්සන කේත ලිවීමට ඔබට ඉඩ සලසයි:

if(FileExists(file))
{
    contents = OpenFile(file);
    if(SomeTest(contents))
    {
        DoSomething(contents);
    }
    DOUBLE_ELSE(DefaultAction();)

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

ඔබ කුතුහලයෙන් ඇසූ නිසාත්, ඔබේ ප්‍රශ්නය නිශ්චිත භාෂාවක් සමඟ ටැග් කර නොමැති නිසාත් (ඔබේ මනසෙහි අත්‍යවශ්‍ය භාෂාවන් ඇති බව පැහැදිලිය), කම්මැලි ඇගයීමට සහාය වන භාෂාවන් සම්පූර්ණයෙන්ම වෙනස් ප්‍රවේශයකට ඉඩ දීම එකතු කිරීම වටී. එම භාෂාවල, ප්‍රකාශන ඇගයීමට ලක් වන්නේ අවශ්‍ය විටදී පමණි, එබැවින් ඔබට "විචල්‍යයන්" නිර්වචනය කළ හැකි අතර ඒවා භාවිතා කිරීම අර්ථවත් වූ විට පමණක් භාවිතා කළ හැකිය. උදාහරණයක් ලෙස, කම්මැලි let/ inව්‍යුහයන් සහිත ප්‍රබන්ධ භාෂාවක ඔබට ප්‍රවාහ පාලනය අමතක කර ලියන්න:

let
  contents = ReadFile(file)
in
  if FileExists(file) && SomeTest(contents) 
    DoSomething(contents)
  else 
    DefaultAction()