කැරලි වරහන් ඔවුන්ගේම රේඛාවෙන් දිස්විය යුතුද? [වසා ඇත]

කැරලි වරහන් ඔවුන්ගේම රේඛාවෙන් තිබිය යුතුද නැද්ද? ඔබ ඒ ගැන සිතන්නේ කුමක්ද?

if (you.hasAnswer()) {
    you.postAnswer();
} else {
    you.doSomething();
}

නැත්නම් එය එසේ විය යුතුයි

if (you.hasAnswer())
{
    you.postAnswer();
}
else
{
    you.doSomething();
}

හෝ පවා

if (you.hasAnswer())
    you.postAnswer();
else
    you.doSomething();

කරුණාකර නිර්මාණාත්මක වන්න! එයට හේතුව පැහැදිලි කරන්න, අත්දැකීම් බෙදාගන්න, කරුණු සහ යොමු කිරීම් සමඟ එය උපස්ථ කරන්න.

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

නමුත් විශාල යෙදුම් කේතනය කිරීමේදී, වරහන් පමණක් ඇති සමහර රේඛාවලට ඉඩ දීම දැරිය හැකි අතර, එය ලබා දෙන 'කණ්ඩායම්කරණය' හැඟීම සැලකිල්ලට ගනී.

ඔබ කුමන ශෛලියක් තෝරා ගත්තද, අනුකූල වන්න, එවිට ඔබේ මොළයට අදාළ කේත කැබලි වල විවිධ මෝස්තර සැකසීම පොදු කාර්යයක් නොවනු ඇත . විවිධ අවස්ථා වලදී (ඉහත වැනි) විවිධ මෝස්තර භාවිතා කිරීම සුදුසු යැයි මම කියමි, ඉහළ මට්ටමක 'සන්දර්භය මාරු කිරීම' පහසුය.

ඔබ කිසි විටෙකත් 3 වන ක්‍රමය නොකළ යුතුය.

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

ඔබගේ කේතය වෙනත් පුද්ගලයින් සඳහා ලියන්න.

දීර් choice කාලයක් තිස්සේ මම තර්ක කළේ ඒවා සමාන වටිනාකමක් ඇති බවයි, නැතහොත් සමාන වීමට ඉතා ආසන්න බැවින් නිවැරදි තේරීමක් කිරීමෙන් ලබා ගත හැකි ලාභය ඒ ගැන වාද කිරීමේ පිරිවැයට වඩා බෙහෙවින් අඩු ය.

කෙසේවෙතත්, ස්ථාවරව සිටීම වැදගත්ය . ඉතින් මම කිව්වා අපි කාසියක් පෙරළා කේත ලිවීමට යමු.

ක්‍රමලේඛකයින් මීට පෙර මෙවැනි වෙනසකට විරුද්ධ වන බව මම දැක ඇත්තෙමි. එය ඉක්මවා යන්න! මම මගේ වෘත්තීය ජීවිතයේ බොහෝ වාරයක් මාරු වී සිටිමි. මගේ පවර්ෂෙල් වලට වඩා මගේ සී # හි විවිධ මෝස්තර භාවිතා කරමි.

මීට වසර කිහිපයකට පෙර මම කණ්ඩායමක් (~ 20 සංවර්ධකයින්) සමඟ වැඩ කරමින් සිටියදී ආදානය ඉල්ලීමට තීරණය කර තීරණයක් ගෙන පසුව සියලු කේත පදනම හරහා එය ක්‍රියාත්මක කරමි. අපට තීරණය කිරීමට සති 1 ක් ඇත.

කෙඳිරිගෑම සහ ඇස් පෙරළීම. ගොඩක් "මම මගේ ක්‍රමයට කැමතියි, එය වඩා හොඳ නිසා" නමුත් කිසිදු සාරයක් නොමැත.

අප ප්‍රශ්නයේ සියුම් කරුණු අධ්‍යයනය කරමින් සිටියදී, යමෙකු මෙම ප්‍රශ්නය සමඟ එකම රේඛා ශෛලියකින් කටයුතු කරන්නේ කෙසේදැයි විමසීය:

void MyFunction(
    int parameterOne,
    int parameterTwo) {
    int localOne,
    int localTwo
}

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

void MyFunction(
    int parameterOne,
    int parameterTwo) 
{
    int localOne,
    int localTwo
}

ලොව පුරා සිටින ජනයා මෙම ගැටලුව සමඟ කටයුතු කළ ආකාරය පිළිබඳව අපි යම් කියවීමක් කළ අතර විවෘත වරහනෙන් පසු හිස් රේඛාවක් එකතු කිරීමේ රටාව සොයා ගතිමු:

void MyFunction(
    int parameterOne,
    int parameterTwo) {

    int localOne,
    int localTwo
}

ඔබ දෘශ්‍ය විවේකයක් ලබා ගැනීමට යන්නේ නම්, ඔබට එය වරහනකින් කළ හැකිය. එවිට ඔබේ දෘශ්‍ය විවේකයද ස්ථාවර වේ.

සංස්කරණය කරන්න : කේ ඇන්ඩ් ආර් භාවිතා කරන විට 'අමතර හිස් රේඛාව' විසඳුමට විකල්ප දෙකක්:

1 / ශ්‍රිත තර්ක ශ්‍රිත ශරීරයට වඩා වෙනස් ලෙස ඇතුල් කරන්න

2 / පළමු තර්කය ශ්‍රිත නාමයට සමාන රේඛාවක් මත තබා නව රේඛා මත තවත් තර්ක එම පළමු තර්කයට පෙළගස්වන්න

උදාහරණ:

1 /

void MyFunction(
        int parameterOne,
        int parameterTwo) {
    int localOne,
    int localTwo
}

2 /

void MyFunction(int parameterOne,
                int parameterTwo) {
    int localOne,
    int localTwo
}

/සංස්කරණය කරන්න

අනෙක් කරුණු වලට වඩා අනුකූලතාව වැදගත් යැයි මම තවමත් තර්ක කරමි, නමුත් අපට ස්ථාපිත පූර්වාදර්ශයක් නොමැති නම් , ඊළඟට යා යුතු මාර්ගය වන්නේ වරහනයි.

ප්‍රධාන නීති:

1. ව්‍යාපෘතියේ පවතින කේතීකරණ ප්‍රමිතිය අනුගමනය කරන්න.
2. කේතීකරණ ප්‍රමිතියක් නොමැති නම් සහ ඔබ වෙනත් කෙනෙකුට අයත් කේත කේතයක් සංස්කරණය කරන්නේ නම් - ඔබ කොතරම් කැමති / අකමැති වුවද, පවතින කේතයේ ශෛලියට අනුකූල වන්න.
3. ඔබ හරිත-ක්ෂේත්‍ර ව්‍යාපෘතියක වැඩ කරන්නේ නම් - අනෙක් කණ්ඩායම් සාමාජිකයන් සමඟ සාකච්ඡා කර විධිමත් හෝ අවිධිමත් කේතීකරණ ප්‍රමිතියක් පිළිබඳ එකඟතාවයකට පැමිණෙන්න.
4. ඔබ එකම සංවර්ධකයා ලෙස හරිත-ක්ෂේත්‍ර ව්‍යාපෘතියක වැඩ කරන්නේ නම් - ඔබේ මනස සකසාගෙන නිර්දය ලෙස අනුකූල වන්න .

ඔබට බාහිර සීමාවන් නොමැති වුවද, දැනට පවතින (පුළුල් ලෙස භාවිතා වන) කේතීකරණ ප්‍රමිතියක් හෝ විලාසිතාවේ මාර්ගෝපදේශයක් සොයා බැලීම වඩාත් සුදුසුය (IMO), එය උත්සාහ කර අනුගමනය කරන්න. ඔබ ඔබේම ශෛලිය රෝල් කළහොත්, වසර කිහිපයකින් ඔබ ඒ ගැන පසුතැවෙන්නට හොඳ අවස්ථාවක් තිබේ.

අවසාන වශයෙන්, පවත්නා ශෛලීය පරීක්ෂකවරුන් සහ කේත ආකෘති භාවිතා කරමින් ක්‍රියාත්මක කළ හැකි / ක්‍රියාත්මක කළ හැකි ශෛලියක් අතින් “බලාත්මක” කළ යුතු එකකට වඩා හොඳය.

පළමු ක්‍රමයේ ඇති වාසිය නම් එය වඩාත් සිරස් අතට සංයුක්ත වීමයි, එබැවින් ඔබට ඔබේ තිරය මත වැඩි කේතයක් සවි කළ හැකි අතර ඒ නිසා මම එයට කැමැත්තෙමි. දෙවන ක්‍රමයට පක්ෂව මා අසා ඇති එකම තර්කය නම් එය විවෘත හා වසා දැමීමේ වරහන් යුගල කිරීම පහසු කරයි, නමුත් බොහෝ IDE හි යතුරුපුවරු කෙටිමඟක් ඇති අතර එය ඇත්ත වශයෙන්ම සාවද්‍ය ප්‍රකාශයකි - ආරම්භක වරහන වසා දැමීම වෙනුවට යුගල කිරීම වෙනුවට වරහන ඔබට එකම අවහිරතා මට්ටමින් "වාරණ ආරම්භය" ප්‍රකාශනයට (එසේ නම්, එසේ නම්) වසා දැමීමේ වරහනක් යුගලනය කළ හැකිය, එබැවින් වාරණයේ ආරම්භය කොතැනද යන්න තීරණය කිරීම පහසුය.

ඉදි කිරීමට පෙර / සිටියදී / නම් දැනටමත් දෘශ්‍යමය වශයෙන් වාරණයක ආරම්භය පෙන්නුම් කරන විට වරහනක් සඳහා සම්පූර්ණ රේඛාවක්ම නාස්ති කිරීමට කිසිදු හේතුවක් මා දකින්නේ නැත.

එයින් කියැවෙන්නේ, වසා දැමීමේ වරහන එහි රේඛාවෙහි තිබිය යුතු යැයි මම විශ්වාස කරමි, මන්ද අපට කොටසක අවසානය සහ එහි ඉන්ඩෙන්ටේෂන් ව්‍යුහය දෘශ්‍යමාන ආකාරයකින් දැක්වීමට යමක් අවශ්‍ය වන බැවිනි.

මම කැමතියි

if (you.hasAnswer())
{
    you.postAnswer();
}
else
{
    you.doSomething();
}

ඉවරයි

if (you.hasAnswer()) {
    you.postAnswer();
} else {
    you.doSomething();
}

you.postAnswer();බැලූ බැල්මට පේළිය කියවීමට හා සොයා ගැනීමට පහසු නිසා. දෙවන ආකාරයෙන්, එය ඊට ඉහළින් ඇති රේඛාව සමඟ මුසු වේ ( you.hasAnswer()) එය කියවීමට මගේ ඇස්වලට වැඩි අවධානයක් යොමු කළ යුතුය.

මම පළමු ක්‍රමයට කැමතියි. වරහන් මුළුමනින්ම වෙනම රේඛාවක් වටින්නේ නැත.

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

භාෂා ඇත (පයිතන්, හැස්කෙල්, රූබි) වරහන් නොමැතිව කිසිසේත් හරි නැත. මෙය සනාථ කරන්නේ වරහන් කුණු කසළ පමණක් වන අතර හැකි සෑම විටම ඒවා සඳහා රේඛාවක් ලැබිය යුතු නොවේ:

if (you.hasAnswer()){
    you.postAnswer();
}else{
    you.doSomething();
}

පයිතන් භාවිතා කර තර්කය සම්පූර්ණයෙන්ම පසෙකට දමන්න.

කැරලි වරහන් වල පිහිටීම විය යුතුය

මෙටා දත්ත

ක්‍රමලේඛකයා විසින් IDE තුළ වින්‍යාසගත කළ හැකිය. ඒ ආකාරයෙන්, කතුවරයා කුමක් වුවත්, සියලු කේතවල ඇති කරදරකාරී වරහන් එක හා සමානයි.

එය රඳා පවතියි.

මම Javascript හෝ jQuery හි කේත කරන්නේ නම්, මම පළමු පෝරමය භාවිතා කරමි:

jQuery(function($) { 
    if ($ instanceOf jQuery) { 
        alert("$ is the jQuery object!"); 
    } 
}); 

නමුත් මම C # හි කේත කරන්නේ නම්, මම දෙවන ආකෘතිය භාවිතා කරමි, මන්ද එය C # හි කළ හැකි කැනොනිකල් ක්‍රමයයි.

public int CalculateAge(DateTime birthDate, DateTime now) 
{ 
    int age = now.Year - birthDate.Year; 
    if (now.Month < birthDate.Month 
        || (now.Month == birthDate.Month && now.Day < birthDate.Day)) 
        age--; 
    return age; 
} 

ඔබේ උදාහරණය ලිවිය හැකි බව සලකන්න

if (you.hasAnswer())
    you.postAnswer();
else
    you.doSomething();

සී # හි.

මම පළමුවැන්නාට වඩා කැමතියි මෙම උදාහරණයේ වැරැද්ද දැකීම මට අපහසු නිසා.

if (value > maximum);
{
    dosomething();
}

එය මෙම උදාහරණයේ ඇතිවාට වඩා

if (value > maximum); {
    dosomething();
}

මෙම ; {සමඟ අවසන් වන රේඛාව වඩා මට වැඩි වැරදි පමණක් පෙනුම ;මම ඒ සල්ලි ඇති ඉඩකඩ වැඩි වෙනවා ඒ නිසා.

මම 1 හි සුළු ප්‍රභේදයකට කැමතියි

if (you.hasAnswer()) {
    you.postAnswer();
} // note the break here
else {
    you.doSomething();
}

මන්ද?

• මම හිතන්නේ සෑම විටම තමන්ගේම රේඛාවට වරහන් දැමීමෙන් කියවීමේ හැකියාව අඩු වේ. මට මගේ තිරයේ යම් ප්‍රභව කේත ප්‍රමාණයක් පමණක් සවි කළ හැකිය. වරහන් ශෛලිය 2) වේදනාකාරී ලෙස දිගු කැදැලි සහිත ලූප සහ කොන්දේසි සහිත ඇල්ගොරිතම සාදයි.

• කෙසේ වෙතත්, මට ඕන elseනිසා නව පිලිවෙත ආරම්භ කිරීමට ifහා elseදෘශ්ය, එකට අයිති. ඉදිරිපිට වරහනක් තිබේ නම් else, අයිති දේ හඳුනා ගැනීම වඩා දුෂ්කර ය.

• 3) නුසුදුස්සකු වීම. ඔබ වරහන් අතහැර ඒ ගැන අමතක කළහොත් සිදුවිය හැකි නරක දේ අපි කවුරුත් දනිමු.

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

if (you.hasAnswer())
{
    you.postAnswer();
}
else
{
    you.doSomething();
}

නමුත් ඔවුන්ගේ ප්‍රකාශකයාගෙන් ඇති අවකාශය නිසා ඔවුන්ට මෙය භාවිතා කිරීමට සිදුවිය.

if (you.hasAnswer()) {
    you.postAnswer();
} else {
    you.doSomething();
}

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

පුද්ගලික මට්ටමින් මම වෙනම පේළියක වරහන් වලට කැමතියි:

අ) ඔවුන් නව විෂය පථයක් දක්වයි
ආ) ඔබට නොගැලපීමක් ඇති වූ විට හඳුනා ගැනීම පහසුය (මෙය IDE හි ඇති ගැටලුවට වඩා අඩු වුවද ඔබ වෙනුවෙන් දෝෂ ඉස්මතු කරයි).

අහ්, එක් සැබෑ බ්‍රේස් විලාසිතාව .

ශුද්ධ වූ මාර්ගයක් සඳහා සෑම දෙයක්ම එහි තිබේ - අනාගතවක්තෘවරයකු පවා (රිචඩ් "මගේ මාර්ගය හෝ අධිවේගී මාර්ගය" ස්ටෝල්මන්).

මිනිහා ගොඩක් දේවල් ගැන ගොඩක් වැරදියි, නමුත් වරහන් ගැන කතා කරන විට GNU එක තැනට එනවා.

[යාවත්කාලීන කරන්න] මම ආලෝකය දුටුවෙමි, දැන් ඕල්මන්ට නමස්කාර කරන්න

දෙවන උදාහරණය, ​​කියවීමේ හැකියාව පිළිබඳ මම ඉතා විශාලය. වෙනත් මාර්ගයක් අවහිර කරන්නේ දැයි බැලීමට මට නොහැකිය = (

සරල පිළිතුර: නිදොස් කිරීමට පහසු වන්නේ කුමක්ද?

// Case 1:
void dummyFunction() {
  for (i = 0; i != 10; ++i) {
    if (i <= 10)
      std::cout << "i is: " << i << "\n";
      std::cout << 10 - i << " steps remaining\n";

      // Some hard work here
      // which is really hard
      // and does take some screen estate
    }
    else
      std::cout << "We'll never get there";
  }
} // COMPILER ERROR HERE


// Case 2:
void dummyFunction()
{
  for (i = 0; i != 10; ++i)

    if (i <= 10)
    {
      std::cout << "i is: " << i << "\n";
      std::cout << 10 - i << " steps remaining\n";

      // Some hard work here
      // which is really hard
      // and does take some screen estate
    }
    else
      std::cout << "We'll never get there\n";
  }
} // COMPILER ERROR HERE

ඔබ මුලින්ම ගැටලුව හඳුනාගත්තේ කුමන අවස්ථාවේදීද?

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

"අපද්‍රව්‍ය අවකාශය" තර්කය සම්බන්ධයෙන්, මම එය මිලට ගන්නේ නැත: වැඩසටහන වඩාත් පැහැදිලි කිරීම සඳහා මම කෙසේ හෝ තාර්කික කණ්ඩායම් අතර හිස් රේඛා එක් කිරීමට නැඹුරු වෙමි ...

කිසිවෙකු නොදකින බව නොවේ, නමුත් කොන්දේසි සහිත කොන්දේසිවලට සමාන වරහන් අයත් වන්නේ මේ නිසාය (ඉතා දිගු කොන්දේසි හැර, නමුත් එය අද්දර නඩුවකි):

C හි, මෙය වලංගු ඉදිකිරීමකි:

අතර (සත්‍ය);
{
    char c;
    getchar (); // ආදානය සඳහා රැඳී සිටින්න
}

ඉක්මන්! මෙම කේතය කරන්නේ කුමක්ද? ඔබ "ආදානය ඉල්ලා අසීමිත පුඩුවක්" යනුවෙන් පිළිතුරු දුන්නේ නම්, ඔබ වැරදියි! එය ආදානයට පවා නොලැබේ. ඒක අහුවෙනවා while(true). අර්ධ සළකුණ අවසානයේ ඇති බව සැලකිල්ලට ගන්න. මෙම රටාව ඇත්ත වශයෙන්ම වඩාත් පොදු වන්නේ එය විය යුතු යැයි පෙනේ; බ්ලොක් එකක ආරම්භයේ දී ඔබේ විචල්‍යයන් ප්‍රකාශ කිරීමට සී ඔබට අවශ්‍ය වේ, එබැවින් නව එකක් ආරම්භ කරන ලදී.

කේත රේඛාවක් යනු සිතුවිල්ලකි. වරහන් යනු කොන්දේසි සහිත හෝ ලූප අඩංගු චින්තනයේ කොටසකි. එබැවින් ඒවා එකම රේඛාවකට අයත් වේ .

මම පළමු ක්‍රමයට කැමතියි. එය ඉතා හොඳ IMO ලෙස පෙනේ, එය වඩාත් සංයුක්ත වේ, මම කැමතියි.

සංස්කරණය කරන්න: අහ්, තුනෙන් එකක්. හැකි සෑම විටම මම එයට කැමතියි, එය ඊටත් වඩා කුඩා / පිළිවෙලට.

ඔබට එය ලිවිය හැකිය:

you.hasAnswer() ? you.postAnswer() : you.doSomething();

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

මෙහි ඇති ප්‍රතිචාර සියල්ලම පාහේ "ඔබ කුමක් කළත්, එකක් හෝ දෙකක් සමඟ රැඳී සිටින්න" යන්නෙහි යම් වෙනසක් පවසයි.

ඒ නිසා මම ඒ ගැන මොහොතකට කල්පනා කළ අතර, එය එතරම් වැදගත් දෙයක් ලෙස මා නොදකින බව පිළිගැනීමට සිදුවිය. පහත සඳහන් දෑ අනුගමනය කිරීම දුෂ්කර බව කිසිවෙකුට අවංකව මට පැවසිය හැකිද?

int foo(int a, Bar b) {
    int c = 0;
    while(a != c)
    {
        if(b.value[a] == c) {
            c = CONST_A;
        }
        c++;
    }
    return c;
}

වෙනත් කිසිවෙකු ගැන මට විශ්වාස නැත ... නමුත් විලාසයන් අතර මානසිකව පෙරළීම හා වෙනස් කිරීම මට කිසිසේත්ම ශුන්‍ය ගැටළු ඇත. කේතය කළේ කුමක්දැයි වටහා ගැනීමට මට මිනිත්තු කිහිපයක් ගත විය, නමුත් එය අහඹු ලෙස සී වැනි වාක්‍ය ඛණ්ඩය ටයිප් කිරීමේ ප්‍රති result ලයකි. :)

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

FWIW, අපගේ කේතීකරණ ශෛලීන් තරමක් ව්‍යුහාත්මක ආකෘති 1 සහ වෙනස් කළ ආකෘති 3 භාවිතා කරයි. (C ++)

            // blank line is required here
if (x) {
            //This blank line is required
   y = z;
}
            // blank line is required here too, unless this line is only another '}'

if (x) y = z; //allowed

if (x)
    y = z;  // forbidden

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

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

වරහන් එකම තීරුවකින් සහ ඒවායේ රේඛාවෙන් ආරම්භ වන විට සහ අවසන් වන විට, ඔබට ආන්තිකයෙන් හෝ 0 තීරුවේ කර්සරය සමඟ තෝරා ගත හැකිය. මෙය සාමාන්‍යයෙන් මූසික තේරීම සමඟ වඩා ත්‍යාගශීලී ප්‍රදේශයකට හෝ යතුරුපුවරු තේරීම සමඟ යතුරු එබීම් අඩු වේ.

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

මම පෞද්ගලිකව දෙවන ක්‍රමයට කැමතියි.

කෙසේ වෙතත්, මම නිරූපණය කිරීමට යන ආකාරය මගේ මතය අනුව හොඳම වන්නේ එය විශාලතම රැකියා සුරක්‍ෂිතතාවයට හේතු වන බැවිනි! මගේ විශ්ව විද්‍යාලයේ සෙසු සිසුවෙක් ඔහුගේ ගෙදර වැඩ සඳහා උදව් ඉල්ලා සිටි අතර ඔහුගේ කේතය කෙබඳුද? සම්පූර්ණ වැඩසටහන එක තනි බ්ලොක් එකක් වගේ. සිත්ගන්නා කරුණ නම් ඔහු විසින් සාදන ලද වැඩසටහනේ දෝෂ වලින් 95% ක්ම නොගැලපෙන වරහන් වලින් පැමිණීමයි. වරහන් ගැලපෙන විට අනෙක් 5% පැහැදිලිව පෙනෙන්නට තිබුණි.

while(1){
i=0;
printf("Enter coded text:\n");
while((s=getchar())!='\n'){
         if(i%1==0){
            start=(char*)realloc(input,(i+1)*sizeof(char));
if(start==NULL){
printf("Memory allocation failed!");
exit(1);}
input=start;}
      input[i++]=s;}
start=(char*)realloc(input,(i+1)*sizeof(char));
if(start==NULL){
printf("Memory allocation failed!!!");
exit(1);}
input=start;
input[i]='\0';
                puts(input);

මගේ පුද්ගලික මනාපය පළමු ක්‍රමය සඳහා වේ, බොහෝ විට මම මුලින්ම PHP ඉගෙන ගත් ආකාරය නිසා විය හැකිය.

තනි පේළි ifප්‍රකාශ සඳහා, මම භාවිතා කරමි

if (you.hasAnswer()) you.postAnswer();

එය එසේ you.postAnswer();නොව නමුත් දිගු කාලයක් වැනි දෙයක් නම්, you.postAnswer(this.AnswerId, this.AnswerText, this.AnswerType);මම බොහෝ විට පළමු වර්ගයට ආපසු යමි:

if (you.hasAnswer) {
    you.postAnswer(this.AnswerId, this.AnswerText, this.AnswerType);
}

මම කිසි විටෙකත් රේඛීය කඩනයක් භාවිතා නොකරමි, elseප්‍රකාශයක් ද තිබේ නම් මම කිසි විටෙකත් මෙම ක්‍රමය භාවිතා නොකරමි .

if (you.hasAnswer()) you.postAnswer();
else you.doSomething()

න්‍යායාත්මක හැකියාවක්, නමුත් මම කවදාවත් භාවිතා නොකරන එකක්. මෙය හැරවිය යුතුය

if (you.hasAnswer()) {
    you.postAnswer();
} else {
    you.doSomething();
}

ඔවුන් එසේ නොකළ යුතුය; මට පළමු ක්‍රමය.

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

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

ප්ලස්, දැනටමත් සඳහන් කර ඇති පරිදි, එය තිරයේ වැඩි කේතයක් සවි කිරීමට ඉඩ සලසයි, එසේ නොමැතිනම් එය ටිකක් ප්‍රති p ලදායක වේ.

එය වේදිකාව / භාෂාව / සම්මුතීන් මත රඳා පවතී

ජාවා හි:

void someMethod() { 
     if (you.hasAnswer()) {
         you.postAnswer();
     } else {
       you.doSomething();
     }
}

සී # හි

void someMethod() 
{ 
     if (you.hasAnswer()) 
     {
         you.postAnswer();
     } 
     else 
     {
       you.doSomething();
     }
}

සී හි:

void someMethod() 
{ 
     if (you_hasAnswer()) {
         you.postAnswer();
     } else {
       you_doSomething();
     }
}

ජාවා කොල්ලෝ ඔවුන්ගේ ශෛලිය C # කේතයෙන් සහ අනෙක් අතට භාවිතා කරන විට මම වෛර කරමි.

මට පැවසිය හැක්කේ ඔබ # 3 ක්‍රමයේ රසිකයෙක් නම්, පෘථිවියේ සෑම IDE කේත-ආකෘතිකරුවෙකු විසින්ම ඔබට පීඩා කරනු ඇති බවයි.

මම පළමු ක්‍රමය භාවිතා කරන්නේ එය වඩාත් සංයුක්ත වන නිසා සහ තිරයේ වැඩි කේතයකට ඉඩ දෙන බැවිනි. වරහන් යුගල කිරීම සම්බන්ධයෙන් මට කිසි විටෙකත් ගැටළුවක් නොවීය ( ifතත්වය එකතු කිරීමට පෙර ප්‍රකාශය සමඟ මම ඒවා නිතරම ලියා තබමි. බොහෝ පරිසරයන් ඔබට ගැලපෙන වරහනට පනින්නට ඉඩ දෙයි).

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

එහෙත්; සියල්ලටම වඩා වැදගත් දෙය වන්නේ අනුකූලතාවයි. එකක් හෝ අනෙකක් භාවිතා කරන්න - කිසි විටෙකත් දෙකම නොකරන්න!

මයික්‍රොසොෆ්ට් කේතීකරණ නිබන්ධන ඒ හා සමාන බැවින් මම පළමු වරට වැඩසටහන් 12 ක් ඉගෙන ගන්නා විට, මම ඊළඟ පේළියට වරහන් තැබුවෙමි. මමත් ඒ අවස්ථාවේ අවකාශ 4 කින් යුත් ටැබ්ස් සමඟ අත්සන් කළෙමි.

අවුරුදු කිහිපයකට පසු, මම ජාවා සහ ජාවාස්ක්‍රිප්ට් ඉගෙන ගත් අතර, එකම වර්‍ග කේත මත තවත් වරහන් දුටුවෙමි, එබැවින් මම වෙනස් විය. මම ද 2-අවකාශ අවකාශයන් සමඟ ඉන්ඩෙන්ට් කිරීමට පටන් ගතිමි.

4 වන විකල්පය ඇත, එය වරහන් පෙලගැසී ඇති නමුත් ඉඩ නාස්ති නොකරයි:

if (you.hasAnswer())
{    you.postAnswer();
     i.readAnswer();
}
else
{   you.doSomething();
}

එකම ගැටළුව වන්නේ බොහෝ IDE හි ස්වයංක්‍රීය ආකෘතිකරුවන් මෙය යටපත් කිරීමයි.

ව්‍යාපෘති කළමණාකරු විසින් යම් කේතීකරණ අවහිරතා හෝ ප්‍රමිති නියම කර ඇති ව්‍යාපෘතියක ඔබ වැඩ නොකරන තාක් කල් ඒ සියල්ල ඔබ මත රඳා පවතී.

මම පෞද්ගලිකව 1 වන ක්‍රමයට කැමතියි.

3 වන ක්‍රමය මඟින් ඔබට පෙන්වීමට අවශ්‍ය දේ මට නොලැබුණි?

එය වැරදි ක්‍රමයක් නොවේද? උදාහරණයක් ලෙස තත්වයක් ලෙස සලකන්න ..

if (you.hasAnswer())
  you.postAnswer();
else
  you.doSomething();

දැන් කෙනෙකු තුළ තව ප්රකාශ එකතු කිරීමට අවශ්ය දේ නම් නම් block කුමක් කළ යුතුද?

එවැනි අවස්ථාවක ඔබ 3 වන ක්‍රමය භාවිතා කරන්නේ නම් සම්පාදකයා සින්ටැක්ස් දෝෂය විසි කරයි.

if (you.hasAnswer())
   you.postAnswer1();
   you.postAnswer2();
else
   you.doSomething();