अगर इससे बचें तो ... और अन्य मामलों को स्विच करें

Question

मैं बहुत समय से प्रोग्रामिंग कर रहा हूं। आम तौर पर मैं PHP, एएसपीनेट, जावा, जावास्क्रिप्ट और अन्य जैसी कुछ भाषाओं में प्रोग्राम करता हूं। सभी भाषाओं में मुझे अन्यथा नियमों का उपयोग करना होगा। जैसे मूल्य = 10 तो ... अगर मैं अपने कोड की समीक्षा करता हूं तो मुझे शर्तों की बहुत सारी चीज़ें मिलती हैं। इसलिए मैं उन्हें कम करना चाहता हूं लेकिन सुनिश्चित नहीं हूं।

एक बिंदु को कुछ हद तक कम से कम वर्गों का उपयोग किया गया था, लेकिन अभी भी वे और अधिक कर रहे हैं ...

कार्य, बिल्ली, सेकंड और प्रकार की तरह:

if task = 'add' then 
    if cat = "animal" then 
     if sec = "man" then 
      if type = "male" then 
       'do the following stuffs 
      else 
       'do the following stuffs 
      end if 
     elseif sec = "horse" then 
      if type = "run" 
       'do the following stuffs 
      else 
       'do the following stuffs 
      end if 
     elseif.... 
     end if 
    elseif cat = "plant" then 
    if sec = "land" then 
      if type="tree" then 
       'do the following stuffs 
      elseif type = "grass" then.. 
       'do the following stuffs 
      elseif... 
      end if 
    elseif sec = "water" then 
    ... 
... 

...

अधिक n अधिक जारी रखने के लिए n जारी रखें

तो आश्चर्य है कि मैं उन्हें कम से कम कैसे कर सकता हूं और कुछ कुशल कोड लिख सकता हूं?

हाल ही में सूचित करने के लिए खेद है कि कार्य, बिल्ली, सेकंड और प्रकार के लिए बहुत सारे मूल्य हो सकते हैं। मेरा अगर बयान nested n nested जा रहे हैं।

अधिक व्याख्यात्मक मेरी कोड भी लग रहा है के रूप में ही की तरह:

http://thedailywtf.com/Articles/Coding-Like-the-Tour-de-France.aspx

Answer 1

कई if..else बयान अक्सर एक लक्षण Polymorphism इस्तेमाल नहीं किया जा रहा है।

Answer 2

यह कहा जाता है 'तीर Antipattern' से निपटने के तरीकों में से कुछ का वर्णन यहां: http://c2.com/cgi/wiki?ArrowAntiPattern

तरीकों से आप पर विचार migt में से एक,

जैसे कार्यों को अलग करने के नेस्टेड स्तरों में कोड refactor करने के लिए है

if cat = "animal" then 
    functionForAnimal(); 
elseif cat = "plant" then 
functionForPlant(); 
elseif... 


function functionForAnimal() 
    if sec = "man" then 
    functionForMan(); 
    elseif sec = "horse" then 
    functionForHorse(); 
    elseif... 

etc... 

यह कोड को छोटे टुकड़ों में विभाजित करता है जो बनाए रखने में आसान होते हैं, और संभवतः पुन: प्रयोज्य होते हैं।

Answer 3

यदि इनमें से प्रत्येक चर के लिए विकल्प सीमित हैं, तो आप या तो ऑपरेशन के साथ बिट फ़ील्ड जैसे चाल का उपयोग भी कर सकते हैं।

उदाहरण: यदि आप विभिन्न कार्यान्वयन है, लेकिन कार्य धारणात्मक एक ही है जब

// give each field a byte so that each can have 256 possible values 
#define TASK_ADD 0x01 
#define TASK_SUB 0x02 
... 
#define CAT_ANIMAL 0x01 
... 
#define SEC_BOY 0x03 
#define SEC_MAN 0x04 
... 
#define TYPE_FEMALE 0x01 
#define TYPE_MALE 0x02 
... 

if ((task << 24 | cat << 16 | sec << 8 | type) == 0x01010402) { 
    // do stuff 
} 

Answer 4

Polymorphism उपयोगी हो सकता है। कभी-कभी प्राकृतिक वर्ग संरचना को ढूंढना मुश्किल होता है, और state pattern या strategy pattern जैसे दृष्टिकोण अधिक उपयुक्त हो सकते हैं।

Answer 5

कहीं भी आपको सही चीज करने के लिए, if-elses के साथ स्थितियों की जांच करने की आवश्यकता होगी। आप नए बाद के चरणों बना सकते हैं अगर आप एक उप

Sub AddAnimalManMale() 
    If task = 'add' And cat = 'animal' And sec = 'man' And type = 'male' Then 
     'perform the add animal man male action' 
    End If 
End Sub 
Sub AddAnimalHorseRun() 
    If task = 'add' And cat = 'animal' And sec = 'horse' And type = 'run' Then 
     'perform the add animal horse run action' 
    End If 
End Sub 

फिर अपने मुख्य उप

... 
Call AddAnimalManMale() 
Call AddAnimalHorseRun() 
... 

Answer 6

में रटना आप 4 भेजे मानकों के साथ एक मैट्रिक्स वर्णित नहीं करना चाहते - task, cat, sec, type और एक निवर्तमान - stuff। तो आपको इसे किसी भी कोड को कोड करना होगा।

उदाहरण के लिए, एक्सएमएल मानचित्र और एक एक्सपीएथ क्वेरी, यानी String.Format("task[@value={0}]/cat[@value={1}]/sec[@value={2}]/type[@value={3}]", "add", "animal", "man", "male") लेकिन यह दृष्टिकोण डेटा को इंगित करता है, एक विधि प्रतिनिधि नहीं।

एक और तरीका है:

void DoStuffA() { } 
void DoStuffB() { } 

var arr = new[] 
{ 
    new { Task = "Add", Cat = "Animal", Sec = "Man", Type = "Male", Method = (Action)DoStuffA }, 
    new { Task = "Add", Cat = "Plant", Sec = "Land", Type = "Tree", Method = (Action)DoStuffB }, 
    // etc.. 
}; 

var action = arr.FirstOrDefault(i => 
    i.Task == "Add" && 
    i.Cat == "Animal" && 
    i.Type == "Male").Method; 
action(); 

इसके अलावा, आप, गुमनाम नहीं सदस्यों का उपयोग लेकिन एक वर्ग की घोषणा XML में अपनी वेरिएंट वर्णित करने और उन्हें एक्सएमएल से अपने वर्ग उदाहरणों में से एक नंबर के लिए deserialize कर सकते हैं।

Answer 7

मुझे लगता है कि आपके डिजाइन में कुछ मौलिक त्रुटियां हैं। मुझे नहीं पता कि आप इस कोड के साथ हल करने की कोशिश कर रहे हैं, लेकिन इस तरह के कोड ऑब्जेक्ट उन्मुख भाषा में बहुत दुर्लभ होना चाहिए। आपका कोड भी मेरे लिए थोड़ा अजीब लगता है, क्योंकि, उदाहरण के लिए, परिवर्तनीय प्रकार का अर्थ लिंग का पहला बार होता है (पुरुष) और फिर इसका मतलब है कि एक क्रिया (रन)। क्या आपने यह देखा है?

वैसे भी, यदि आप वास्तव में जावा (या कक्षाओं के साथ कुछ भी) का उपयोग कर रहे हैं, तो आपको जो चाहिए वह अमूर्त है। इसके बाद, अपने ऑब्जेक्ट्स पर अपने सभी तर्कों को ले जाएं - इसे एक राक्षसी दिनचर्या में संभाल न लें। इस तरह सोचो: मेरी वस्तुएं जानते हैं कि उनका हिस्सा कैसे करें।

असल में इस स्थिति में अच्छी सलाह देना मुश्किल है, मुझे संदेह है कि आपकी समस्याओं में आपके आवेदन में कुछ उच्च स्तर पर स्रोत है और यह मामला कोड केवल एक लक्षण है। ऑब्जेक्ट उन्मुख दृष्टिकोण का उपयोग करने के लिए अपने प्रोग्राम को फिर से डिजाइन करने का प्रयास करें और संभवतः आपके दिमाग में एक बेहतर समाधान आएगा।

यदि आप सुनिश्चित नहीं हैं कि बहुरूपता, अमूर्तता और अन्य ओओ शब्दों का क्या मतलब है, तो आपको इसे पढ़ने की आवश्यकता होगी।

Answer 8

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

handlers = { 
    ('add', 'animal', 'man', 'male'): add_man_func, 
    ('add', 'animal', 'horse', 'run'): run_horse_func, 
    # ... 
} 

handler = handlers[(task, cat, sec, type)] 
handler(some_args) 

Answer 9

कोड को तोड़कर सब है क्या खेल के बारे में है: तुम सब करने की ज़रूरत है कॉल करने के लिए एक समारोह के लिए (कार्य, बिल्ली, सेकंड, प्रकार) से एक नक्शे के निर्माण है।

ऐतिहासिक आप क्या करेंगे (और अच्छे वहाँ गया था, या कम से कम स्थिर कोड, और अभी भी वहाँ इन सभी में है)

• के रूप में आप इसे अब कर रहे हैं, विशाल कार्यों में अखंड, साथ टिप्पणियों के बहुत सारे

• छोटे अच्छी तरह से परिभाषित और अच्छी तरह से नामित कार्यों

• नामकरण कार्यों जटिल सामान के लिए मुश्किल था में विभाजित है और यह भी अगर आप बड़ा संरचनाओं के लिए संदर्भ से गुजर रहा पर रखने तो वस्तुओं एक नेचुरा थे एल बात का आविष्कार करने (हालांकि, एक बार आप वस्तु रास्ता तय तो यह सब कुछ करने के समझ में आता है और कोड वस्तु उन्मुख पैटर्न उभरने पुन: उपयोग के माध्यम से ...)

पैटर्न को स्वीकार करते हुए एक तरह से अच्छा देने के समान है कार्यों के नाम (साथ ही आपको स्वाभाविक रूप से उपयोगी तरीके से फेंक दिया जाता है, जो बड़ी जीत हो सकती है)।