मैं कुछ और जोड़ना चाहता हूं जो अन्य उत्तरों द्वारा संकेत दिया गया है, लेकिन मुझे नहीं लगता कि स्पष्ट रूप से उल्लेख किया गया है:
@puck कहते हैं, "अभी भी कोई गारंटी नहीं है कि फ़ंक्शन नाम में पहले उल्लेखित तर्क वास्तव में पहला पैरामीटर है।"
@ कॉज़र कहते हैं "अस्पष्ट तर्क के बजाय प्रकार का उपयोग करें"
मुद्दा यह है कि प्रोग्रामिंग भाषाएं नामों को नहीं समझती हैं: उन्हें सिर्फ अपारदर्शी, परमाणु प्रतीकों के रूप में माना जाता है। इसलिए, कोड टिप्पणियों के साथ, किसी फ़ंक्शन का नाम क्या है और यह वास्तव में कैसे संचालित होता है, इसके बीच कोई संबंध नहीं है।
assertExpectedEqualsActual(foo, bar)
कुछ विकल्पों (इस पृष्ठ और अन्य जगहों से) की तुलना करें , जैसे:
# Putting the arguments in a labelled structure
assertEquals({expected: foo, actual: bar})
# Using a keyword arguments language feature
assertEquals(expected=foo, actual=bar)
# Giving the arguments different types, forcing us to wrap them
assertEquals(Expected(foo), Actual(bar))
# Breaking the symmetry and attaching the code to one of the arguments
bar.Should().Be(foo)
इन सभी में क्रिया नाम की तुलना में अधिक संरचना है, जो भाषा को देखने के लिए कुछ गैर अपारदर्शी देता है। फ़ंक्शन की परिभाषा और उपयोग भी इस संरचना पर निर्भर करता है , इसलिए यह कार्यान्वयन क्या कर रहा है (जैसे नाम या टिप्पणी) के साथ आउट-ऑफ-सिंक नहीं कर सकता है।
जब मैं इस तरह की समस्या का सामना करता हूं या आगे निकलता हूं, तो इससे पहले कि मैं निराशा में अपने कंप्यूटर पर चिल्लाऊं, मैं सबसे पहले यह पूछने के लिए कुछ समय लेता हूं कि क्या मशीन को दोष देना 'उचित' है। दूसरे शब्दों में, क्या मशीन को यह बताने के लिए पर्याप्त जानकारी दी गई थी कि मैं जो कुछ भी मांगता हूं, उससे मैं क्या चाहता हूं?
जैसे कॉल assertEqual(expected, actual)
उतने ही समझ में आता है assertEqual(actual, expected)
, इसलिए हमारे लिए उन्हें मिश्रित करना और मशीन के लिए आगे बढ़ना और गलत काम करना आसान है। यदि हम assertExpectedEqualsActual
इसके बजाय उपयोग करते हैं, तो इससे हमें गलती होने की संभावना कम हो सकती है, लेकिन यह मशीन को कोई अधिक जानकारी नहीं देता है (यह अंग्रेजी नहीं समझ सकता है, और नाम की पसंद शब्दार्थ को प्रभावित नहीं करना चाहिए)।
क्या "संरचित" दृष्टिकोण अधिक बेहतर होता है, जैसे कीवर्ड तर्क, फ़ील्ड, अलग-अलग प्रकार, आदि यह है कि अतिरिक्त जानकारी भी मशीन पठनीय है , इसलिए हमारे पास मशीन स्पॉट गलत उपयोग हो सकते हैं और हमें चीजों को सही करने में मदद कर सकते हैं। assertEqual
मामले के बाद से केवल एक समस्या यह गलत संदेशों होगा, बहुत बुरा नहीं है। एक और अधिक भयावह उदाहरण हो सकता है String replace(String old, String new, String content)
, जिसके साथ भ्रमित करना आसान है String replace(String content, String old, String new)
जिसका बहुत अलग अर्थ है। एक सरल उपाय एक जोड़ी लेना [old, new]
होगा, जो गलतियों को तुरंत त्रुटि देगा (यहां तक कि बिना प्रकार के)।
ध्यान दें कि यहां तक कि प्रकारों के साथ, हम खुद को 'मशीन को यह बताना नहीं चाहते हैं कि हम क्या चाहते हैं'। उदाहरण के लिए "कड़ाई से टाइप की गई प्रोग्रामिंग" नामक एंटी-पैटर्न सभी डेटा को स्ट्रिंग्स के रूप में व्यवहार करता है, जिससे तर्क को मिलाया जाना आसान हो जाता है (जैसे कि यह मामला), कुछ कदम (जैसे बचकर) प्रदर्शन करने के लिए, गलती से हमलावरों को तोड़ने के लिए (जैसे) अप्रचलित JSON), आदि बनाना।
यह "बूलियन ब्लाइंडनेस" से भी संबंधित है, जहां हम कोड के एक हिस्से में बूलियन्स (या संख्या, आदि) के एक समूह की गणना करते हैं, लेकिन जब उन्हें दूसरे में उपयोग करने की कोशिश करते हैं तो यह स्पष्ट नहीं होता है कि वे वास्तव में क्या प्रतिनिधित्व कर रहे हैं, क्या हमने उन्हें मिलाया है, इत्यादि से इसकी तुलना उदाहरण के लिए विभिन्न वर्णों से की है, जिनके वर्णनात्मक नाम हैं (उदाहरण के LOGGING_DISABLED
बजाय false
) और जो हमें मिलाए जाने पर त्रुटि संदेश का कारण बनते हैं।