5 आसानी से पढ़े जाने वाले कोड नियम

आप खुद से पूछते हैं: "साफ-सुथरे तरीके से, समझदारी से कैसे लिखें?" किसी और के कोड का पता कैसे लगाएं? ”

नीचे दिए गए नियमों को याद रखें और उन्हें लागू करें!

आलेख में वैरिएबल और फ़ंक्शंस के नामकरण, सिंटैक्टिक इंडेंटेशन और बड़े पैमाने पर रीफैक्टरिंग विषय के लिए बुनियादी नियमों पर चर्चा नहीं की गई है। हम कोड को सरल बनाने और विकास प्रक्रिया के दौरान मस्तिष्क पर भार को कम करने के लिए 5 सरल नियमों पर विचार करते हैं।

धारणा की प्रक्रिया के साथ वर्णित नियमों को सहसंबंधित करने के लिए डेटा को समझने की प्रक्रिया पर विचार करें और एक सरल कोड के लिए मानदंड निर्धारित करें।

धारणा की सरलीकृत प्रक्रिया में निम्नलिखित चरण होते हैं:

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

वैज्ञानिक स्मृति को अल्पकालिक और दीर्घकालिक में विभाजित करते हैं। अल्पकालिक मेमोरी वॉल्यूम में छोटी होती है, लेकिन जानकारी तुरंत निकाली जाती है और संग्रहीत की जाती है। अल्पकालिक मेमोरी मस्तिष्क का कैश है। यह 7 + -2 शब्दों, संख्याओं, वस्तुओं को संग्रहीत कर सकता है। लंबी अवधि की मेमोरी वॉल्यूम में बड़ी होती है, लेकिन इसे शॉर्ट-टर्म मेमोरी की तुलना में जानकारी को बचाने और पुनर्प्राप्त करने के लिए अधिक ऊर्जा (प्रयास) की आवश्यकता होती है।

निष्कर्ष:

• कम तत्व, कम ऊर्जा खर्च होती है,
• यह कथित तत्वों की संख्या को 9 तक कम करने के लिए आवश्यक है,
• संभव के रूप में लंबे समय तक स्मृति का उपयोग करें: सामान्यीकरण करें या भूल जाएं।

हम नियमों के विवरण के लिए आगे बढ़ते हैं।

नियम 1. हम शर्तों में बयान का उपयोग करते हैं, "नहीं" से छुटकारा पाएं।

"नहीं" ऑपरेटर को हटाने से विश्लेषण किए जा रहे तत्वों की संख्या कम हो जाती है। इसके अलावा, कई प्रोग्रामिंग भाषाओं में, "a!" का उपयोग निगेटिव ऑपरेटर के लिए किया जाता है। कोड पढ़ते समय इस चरित्र को छोड़ना आसान है।

की तुलना करें:

if (!entity.IsImportAvaible) { // 1 } else { // 2 } 

के बाद:

 if (entity.IsImportAvaible) { // 2 } else { // 1 } 

नियम 2. घोंसले के शिकार के स्तर को कम करना।

कोड विश्लेषण के दौरान, प्रत्येक घोंसले के स्तर को स्मृति में रखने की आवश्यकता होती है। स्तरों की संख्या कम करें - ईंधन की लागत कम करें।

घोंसले के शिकार के स्तर की संख्या को कम करने के तरीकों पर विचार करें।

1) वापसी नियंत्रण। हमने कुछ मामलों को काट दिया और शेष लोगों पर ध्यान केंद्रित किया।

 if (conributor != null) { // } 

में रूपांतरित करें

 if(contributor == null) { return; } // 

या

 while( 1) { if( 2) { break; } // } 

या

 for(; 1;) { if( 2) { continue; } // } 

एक विस्तारित उदाहरण नियम 5 में दिया गया है। अपवाद को फेंकने पर ध्यान दें।

2) विधि का अलगाव। फ़ंक्शन का नाम सामान्यीकरण का परिणाम है।

 if( ) { foreach(var sender in senders) { sender.Send(message); } } 

में

 if( ) { SendAll(senders, message); } void SendAll(IEnumerable<Sender> senders, string message) { foreach(var sender in senders) { sender.Send(message); } } 

3) संयोजन की स्थिति।

 if (contributor == null) { if (accessMngr == null) { // } } 

में

 if (contributor == null && accessMngr == null) { // } 

4) चरों को हटाकर सिमेंटिक ब्लॉक में विभाजित करना। नतीजतन, ब्लॉकों को स्वतंत्र रूप से बदला जा सकता है, और सबसे महत्वपूर्ण बात यह है कि ऐसे कोड को पढ़ना और समझना बहुत आसान है। एक ब्लॉक - एक कार्यक्षमता। एक सामान्य मामला प्रसंस्करण के साथ एक खोज है। कोड को अलग-अलग सिमेंटिक ब्लॉक में विभाजित करना आवश्यक है: तत्व खोज, प्रसंस्करण।

 for (int i=0;i<array.length;i++) { if (array[i] == findItem) { // array[i] break; } } 

में

 for(int i=0;i<array.length;i++) { if(array[i] == findItem) { foundItem =array[i]; break; } } if (foundItem != null) { // foundItem } 

नियम 3. हम अनुक्रमणिका से छुटकारा पाते हैं और संपत्तियों के माध्यम से कॉल करते हैं।

इंडेक्सर - इंडेक्स अरेस्ट [इंडेक्स] पर किसी एरे के एलीमेंट को एक्सेस करने का ऑपरेशन।

कोड को समझने की प्रक्रिया में, मस्तिष्क प्रतीकों [] के रूप में सीमांकक, और सूचकांक को एक अभिव्यक्ति के रूप में संचालित करता है।

 function updateActiveColumnsSetting(fieldsGroups) { var result = {}; for (var i = 0; i < fieldsGroups.length; i++) { var fields = fieldsGroups[i].fields; for (var j = 0; j < fields.length; j++) { if (!result[fieldsGroups[i].groupName]) { result[fieldsGroups[j].groupName] = {}; } result[fieldsGroups[i].groupName][fields[j].field] = createColumnAttributes(j, fields[j].isActive); } } return JSON.stringify(result); } 

एक अनुक्रमणिका अक्सर गलतियों का एक स्थान है। छोटे सूचकांक नामों के आधार पर, I, j या k को मिलाना बहुत आसान है।

उपरोक्त उदाहरण में, लाइन परिणाम में [फ़ील्ड्सग्रुप्स [जे] .groupName] = {}; गलती हुई:
j का प्रयोग i के बजाय किया जाता है।

यह जानने के लिए कि वास्तव में i-th मान कहाँ उपयोग किया जाता है, आपको यह करना होगा:

1) नेत्रहीन एक सरणी चर पर प्रकाश डाला

 function updateActiveColumnsSetting(fieldsGroups) { var result = {}; for (var i = 0; i < fieldsGroups.length; i++) { var fields = fieldsGroups[i].fields; for (var j = 0; j < fields.length; j++) { if (!result[fieldsGroups[i].groupName]) { result[fieldsGroups[j].groupName] = {}; } result[fieldsGroups[i].groupName][fields[j].field] = createColumnAttributes(j, fields[j].isActive); } } return JSON.stringify(result); } 

2) वांछित अनुक्रमित I, j, i-1, j-1, आदि के उपयोग के लिए प्रत्येक घटना का विश्लेषण करने के लिए, सूचकांक के उपयोग के स्थानों को ध्यान में रखते हुए और पहले से ही धारणा में संदर्भों की पहचान की।
एक चर में अनुक्रमणिका को उजागर करके, हम खतरनाक स्थानों की संख्या को कम करते हैं और हम आसानी से याद रखने की आवश्यकता के बिना, चर को देखने के लिए मस्तिष्क का उपयोग कर सकते हैं।

प्रसंस्करण के बाद:

 function updateActiveColumnsSetting(fieldsGroups) { var columnsGroups = {}; for (var i = 0; i < fieldsGroups.length; i++) { var fieldsGroup = fieldsGroups[i]; var groupName = fieldsGroup.groupName; var columnsGroup = columnsGroups[groupName]; if (!columnsGroup) { columnsGroup = columnsGroups[groupName] = {}; } var fields = fieldsGroup.fields; for (var j = 0; j < fields.length; j++) { var fieldInfo = fields[j]; columnsGroup[fieldInfo.field] = createColumnAttributes(j, field.isActive); } } return columnsGroups; } 

दृश्य चयन बहुत सरल है, और आधुनिक विकास वातावरण और संपादक कोड के विभिन्न हिस्सों में सब्सट्रिंग को उजागर करके मदद करते हैं।

 function updateActiveColumnsSetting(fieldsGroups) { var columnsGroups = {}; for (var i = 0; i < fieldsGroups.length; i++) { var fieldsGroup = fieldsGroups[i]; var groupName = fieldsGroup.groupName; var columnsGroup = columnsGroups[groupName]; if (!columnsGroup) { columnsGroup = columnsGroups[groupName] = {}; } var fields = fieldsGroup.fields; for (var j = 0; j < fields.length; j++) { var fieldInfo = fields[j]; columnsGroup[fieldInfo.field] = createColumnAttributes(j, field.isActive); } } return columnsGroups; } 

नियम 4. अर्थ के अनुसार ब्लॉक समूह।

हम धारणा के मनोवैज्ञानिक प्रभाव का उपयोग करते हैं - "निकटता का प्रभाव": धारणा में बारीकी से स्थित आंकड़े संयुक्त हैं। धारणा की प्रक्रिया में विश्लेषण और सामान्यीकरण के लिए कोड तैयार करने के लिए, और स्मृति में संग्रहीत जानकारी की मात्रा को कम करने के लिए, आप एक दूसरे के बगल में एक पंक्ति की व्यवस्था कर सकते हैं, अर्थ द्वारा एकजुट या कार्यक्षमता में बंद कर सकते हैं, उन्हें एक खाली रेखा से विभाजित कर सकते हैं।

करने के लिए:

 foreach(var abcFactInfo in abcFactInfos) { var currentFact = abcInfoManager.GetFact(abcFactInfo); var percentage = GetPercentage(summaryFact, currentFact); abcInfoManager.SetPercentage(abcFactInfo, percentage); accumPercentage += percentage; abcInfoManager.SetAccumulatedPercentage(abcFactInfo, accumPercentage); var category = GetAbcCategory(accumPercentage, categoryDictionary); abcInfoManager.SetCategory(abcFactInfo, category); } 

के बाद:

 foreach (var abcFactInfo in abcFactInfos) { var currentFact = abcInfoManager.GetFact (abcFactInfo); var percentage = GetPercentage(summaryFact, currentFact); accumPercentage += percentage; var category = GetAbcCategory(accumPercentage, categoryDictionary); abcInfoManager.SetPercentage(abcFactInfo, percentage); abcInfoManager.SetAccumulatedPercentage(abcFactInfo, accumPercentage); abcInfoManager.SetCategory(abcFactInfo, category); } 

ऊपरी उदाहरण में 7 ब्लॉक हैं, निचले 3 में: मान प्राप्त करना, एक लूप में जमा करना, प्रबंधक गुण सेट करना।

इंडेंटेशन उन जगहों की पहचान करने के लिए अच्छा है जो ध्यान देने योग्य हैं। तो, लाइनों

 accumPercentage += percentage; var category = GetAbcCategory(accumPercentage, categoryDictionary); 

पिछली गणनाओं के आधार पर, वे संचित पैराग्राफ चर में मान जमा करते हैं। मतभेदों पर जोर देने के लिए, कोड को इंडेंट किया जाता है।

एक नियम के लिए एक विशेष उपयोग मामला स्थानीय चर को यथासंभव उपयोग के स्थान के करीब घोषित करना है।

नियम 5. जिम्मेदारी की विशिष्टता के सिद्धांत का पालन करना।

OOP में यह SOLID सिद्धांतों में से पहला है, लेकिन कक्षाओं के अलावा इसे प्रोजेक्ट्स, मॉड्यूल, फ़ंक्शन, कोड के ब्लॉक, प्रोजेक्ट टीमों या व्यक्तिगत डेवलपर्स पर लागू किया जा सकता है। यह पूछे जाने पर कि इस क्षेत्र के लिए कौन या क्या जिम्मेदार है, यह तुरंत स्पष्ट है कि कौन या क्या। एक कनेक्शन हमेशा सरल होता है। प्रत्येक वर्ग को एक अवधारणा, वाक्यांश, रूपक के लिए सामान्यीकृत किया जाता है। नतीजतन, याद रखने में कम, धारणा की प्रक्रिया आसान और अधिक कुशल है।

निष्कर्ष में, एक व्यापक उदाहरण:

 private PartnerState GetPartnerStateForUpdate( PartnerActivityInfo partner, Dictionary<int, PartnerState> currentStates, Dictionary<int, PartnerState> prevStates) { PartnerState updatingState; if (prevStates.ContainsKey(partner.id)) { if (currentStates.ContainsKey(partner.id)) { var prevState = prevStates[partner.id]; updatingState = currentStates[partner.id]; // 1 } else { // 2 } } else if (currentStates.ContainsKey(partner.id)) { updatingState = currentStates[partner.id]; } else { throw new Exception(string.Format("  {0}         {1}", partner.id, month)); } return updatingState; } 

ContainsKe इंडेक्सर्स को बदलने के बाद, ब्रांचिंग को निकालना, विधि का चयन करना और नेस्टिंग स्तरों को कम करना, यह निकला:

 private PartnerState GetPartnerStateForUpdate( PartnerActivityInfo partner, Dictionary<int, PartnerState> currentStates, Dictionary<int, PartnerState> prevStates) { PartnerState currentState = null; PartnerState prevState = null; prevStates.TryGetValue(partner.id, out prevState); currentStates.TryGetValue(partner.id, out currentState); currentState = CombineStates(currentState, prevState); return currentState; } private PartnerState CombineStates( PartnerState currentState, PartnerState prevState) { if (currentState == null && prevState == null) { throw new Exception(string.Format( "  {0}         {1}" , partner.id, month)); } if (currentState == null) { // 1 } else if (prevState != null) { // } return currentState; } 

पहला फ़ंक्शन शब्दकोशों से राज्यों को प्राप्त करने के लिए जिम्मेदार है, दूसरा उन्हें एक नए में संयोजित करने के लिए।

प्रस्तुत नियम सरल हैं, लेकिन संयोजन में वे कोड को सरल बनाने और विकास प्रक्रिया के दौरान मेमोरी लोड को कम करने के लिए एक शक्तिशाली उपकरण प्रदान करते हैं। आप हमेशा उनका अनुसरण करने में सक्षम नहीं होंगे, लेकिन यदि आपको पता है कि आप कोड को नहीं समझते हैं, तो उनके साथ शुरू करना सबसे आसान है। उन्होंने सबसे कठिन मामलों में लेखक की बार-बार मदद की है।