अनुप्रयोग प्रोग्रामिंग में गोटो

गोटो - समस्याओं और सुधार

1. बाहर से ब्लॉक में प्रवेश:

1.1 "नहीं चक्र" के लिए प्रवेश:

if(a) GOTO InsideIf; if(b) { foo(); InsideIf: bar(); } 

  if(b) { foo(); } if(a || b) { bar(); } 

1.2 चक्र में प्रवेश:

  if(goIntoCycle) GOTO MiddleOfCycle; for(...) { foo(); MiddleOfCycle: bar(); } 

2. एक ब्लॉक के अंदर संक्रमण:

  if(bNotNeeded) GOTO startFromC: B(); startFromC: C(); 

  if(bNeeded) { B(); } C(); 

3. ब्लॉक से बाहर की ओर बाहर निकलें

महत्वपूर्ण नियम:

1. उपयोग न करें :
   
   1) हम हमेशा त्रुटियों और आपातकालीन स्थितियों को संभालने के लिए अपवादों का उपयोग करते हैं, इसलिए, हम उन्हें किसी और चीज़ के लिए उपयोग नहीं करते हैं ताकि आंखों की रोशनी न हो;
   
   2) हम गलती से घोंसले के आंतरिक स्तर से एक अपवाद "निगल" कर सकते हैं;
   
   3) यह एक महंगी खुशी है - आवेदन प्रोग्रामिंग में यह दुष्ट के लिए बेकार है, लेकिन सरल विकल्पों की उपस्थिति में बिखरने वाले संसाधनों का कोई मतलब नहीं है;
2. हम कई रिटर्न से बचते हैं , विशेष रूप से घोंसले के शिकार के विभिन्न स्तरों से: अन्यथा गोटो से कुछ अंतर हैं - कोड की पठनीयता भी ज्यादातर मामलों में मुश्किल है। (शायद इसके लिए एक अलग औचित्य की आवश्यकता है - वह भी एक होलीवर है)।

3.1। घोंसले के एक स्तर से बाहर का एकमात्र तरीका:

3.2। घोंसले के शिकार के एक स्तर से कई निकास:

3.2.1 त्रुटि हैंडलिंग - केवल अपवाद के माध्यम से

3.2.2 विकल्पों की गणना - उदाहरण के लिए, यदि:

  class Tamagochi { function recreate() { if(wannaEat) { eat(); GOTO Cleanup; } if (wannaDrink) { drink(); GOTO Cleanup; } if(wannaDance) { Dance(); } return HAPPY; //true Cleanup: return washHands() && cleanKitchen(); } } 

  function recreate() { if(wannaEat) { eat(); needCleanup = true; needSleep = true; } if (wannaDrink) { drink(); needCleanup = true; } if(wannaDance) { Dance(); needSleep = true; } result = HAPPY; //true if(needCleanup) result = result && washHands() && cleanKitchen(); if(needSleep) result = result && sleep(); return result; } 

3.3। घोंसले के शिकार के कई स्तरों से बाहर निकलें।

३.३.१ यदि विभिन्न तर्क (विभिन्न जिम्मेदारियों) को अलग करना आसान है:

  class BatchInputProcessor { function processInput(inputRecords) { for (inputRecord in inputRecords) { for (validator in validators) { if (!validator.check(inputRecord) GOTO ValidationFailed; } item = new Item(); for (fieldValue in inputRecord.fieldValues) { setFieldValue(fieldValue.field, fieldValue.value); } itemsToStore.add(item); } return store(itemsToStore); ValidationFailed: log(failedValidation); tryToCorrect(inputRecords); ... } } 

  function processInput(inputRecords) { allRecordsAreValid = true; for(inputRecord in inputRecords) { recordIsValid = validateRecord(inputRecord, validators); if(!recordIsValid) { allRecordsAreValid = false; break; } else { itemToStore = createItemFromRecord(inputRecord); itemsToStore.add(item); } } if(allRecordsAreValid) { result = store(itemsToStore); } else { log(failedValidation); tryToCorrect(inputRecords); ... } } 

३.३.२। विभिन्न तर्क को भेदना अधिक कठिन है, या कोड अधिक जटिल हो गया है।

  function findOrCreateTriadaOfEqual(firstArray, secondArray, thirdArray) { result = null; for(first in firstArray) { for(second in secondArray) { for(third in thirdArray) { if(first == second && second == third) { result = array(first, second, third); GOTO Found: } } } } equal = new Item(); result = array(equal, equal, equal); Found: log(result); return result; } 

1. आंतरिक लूप से वापसी के साथ एक अलग सबफ़ंक्शन में डाल दिया - सबसे आसान
2. संक्षिप्त करें - प्रपत्र का एक पुनरावर्ती कार्य ढूंढें findEqualInArrays (arrayOfArrays, currentArrayIndex, currentFoundItemsArray);
3. "अगर (परिणाम) ब्रेक" सबसे अनाड़ी है:

  result = null; for(first in firstArray) { for(second in secondArray) { for(third in thirdArray) { if(first == second && second == third) { result = array(first, second, third); break; } } if(result) break; } if(result) break; } 

सारांश:

1. अपवादों के माध्यम से त्रुटि से निपटने;
2. अपघटन - एक बड़ी विधि जो कई समस्याओं को हल करती है, छोटे में विभाजित होती है, व्यक्तिगत कार्यों को हल करती है;
3. बोलने वाले नामों के साथ चर में तर्क (परिकलित स्थिति और भाव) को ठीक करना।