आपको Go-आलोचक के रूप में Go के लिए एक नए स्थिर विश्लेषक की हालिया घोषणा याद हो सकती है।

मैंने इसके साथ गोलंग / गो परियोजना की जाँच की और कुछ पैच भेजे जो वहां पाई गई कुछ समस्याओं को ठीक करते हैं।

इस लेख में, हम सही कोड का विश्लेषण करेंगे, और हमें गो में और भी ऐसे बदलाव भेजने के लिए प्रेरित किया जाएगा।

सबसे अधीर के लिए: ट्राफियां की एक अद्यतन सूची ।

परसिंग लिस्ट पर जाएं

dupSubExpr

हम सभी गलती करते हैं, और, अक्सर, असावधानी से। गो, एक ऐसी भाषा होने के नाते जिसमें आपको कभी-कभी उबाऊ और बॉयलरप्लेट कोड लिखना पड़ता है, कभी-कभी टाइपोस और / या कॉपी / पेस्ट त्रुटियों में योगदान देता है।

CL122776 में डंपसबप्रट द्वारा पाए गए बग के लिए एक फिक्स शामिल है:

 func (a partsByVarOffset) Less(i, j int) bool { - return varOffset(a.slots[a.slotIDs[i]]) < varOffset(a.slots[a.slotIDs[i]]) + return varOffset(a.slots[a.slotIDs[i]]) < varOffset(a.slots[a.slotIDs[j]]) // ^__________________________________^ }

बाईं और दाईं ओर सूचकांक पर ध्यान दें। सुधार से पहले, ऑपरेटर के LHS और RHS < समान थे, और dupSubExpr लिए dupSubExpr ने काम किया।

commentedOutCode

यदि आपकी परियोजना एक संस्करण नियंत्रण प्रणाली द्वारा प्रायोजित है , तो एक टिप्पणी में इसे लपेटकर कोड को अक्षम करने के बजाय, इसे पूरी तरह से हटाने के लायक है। अपवाद हैं, लेकिन अधिक बार ऐसे "मृत" कोड हस्तक्षेप करते हैं, भ्रमित करते हैं और त्रुटियों को छिपा सकते हैं।

कमेंटऑउटकोड को एक ऐसा दिलचस्प अंश मिल सकता है ( CL122896 ):

 switch arch.Family { // ...  case clause. case sys.I386: return elf.R_386(nr).String() case sys.MIPS, sys.MIPS64: // return elf.R_MIPS(nr).String() // <- 1 case sys.PPC64: // return elf.R_PPC64(nr).String() // <- 2 case sys.S390X: // return elf.R_390(nr).String() // <- 3 default: panic("unreachable") }

थोड़ी अधिक टिप्पणी है:

 // We didn't have some relocation types at Go1.4. // Uncomment code when we include those in bootstrap code.

यदि आप go1.4 शाखा में जाते हैं और इन 3 पंक्तियों को टिप्पणी से हटा देते हैं, तो कोड संकलित नहीं होगा, हालांकि यदि आप उन्हें विज़ार्ड में अनलॉकर करते हैं, तो सब कुछ काम करेगा।

आमतौर पर, किसी टिप्पणी में छिपे कोड को विलोपन या रिवर्स सक्रियण की आवश्यकता होती है।

यह उपयोगी है, समय-समय पर, अपने कोड में अतीत की ऐसी गूँज देखने के लिए।

पता लगाने की कठिनाइयों के बारे में

यह मेरी पसंदीदा जाँचों में से एक है, लेकिन यह सबसे "शोर" में से एक है।

संकुल के लिए बहुत सारे गलत सकारात्मक जो math/big और संकलक के अंदर उपयोग करते हैं। पहले मामले में, ये आमतौर पर किए गए संचालन पर व्याख्यात्मक टिप्पणियां हैं, और दूसरे में, कोड का एक विवरण जो एएसटी टुकड़ा का वर्णन करता है। झूठी नकारात्मक शुरुआत किए बिना वास्तविक "मृत" कोड से इस तरह की टिप्पणियों को भेद करना निंदनीय है।

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

एक अन्य श्रेणी स्पष्ट TODO साथ टिप्पणियां हैं। यदि कोड टिप्पणी के लिए हटा दिया जाता है, लेकिन इस बात का स्पष्ट विवरण है कि ऐसा क्यों किया गया है और जब इस कोड के टुकड़े को ठीक करने की योजना बनाई गई है, तो चेतावनी नहीं देना बेहतर है। यह पहले से ही लागू किया गया है, लेकिन अधिक मज़बूती से काम कर सकता है।

boolExprSimplify

कभी-कभी लोग अजीब कोड लिखते हैं। शायद यह मुझे लगता है, लेकिन तार्किक ( बुलियन ) भाव कभी-कभी विशेष रूप से अजीब लगते हैं।

गो में एक उत्कृष्ट x86 असेम्बलर बैकएंड है (यहाँ आंसू गिर गए), लेकिन ARM ने वास्तव में गलत किया:

 if !(o1 != 0) { break }

"यदि o1 0 के बराबर नहीं है" ... दोहरा नकार एक क्लासिक है। यदि आप इसे पसंद करते हैं, तो मैं आपको CL123377 के साथ खुद को परिचित करने के लिए आमंत्रित करता हूं । वहाँ आप सही संस्करण देख सकते हैं।

सही विकल्प (उन लोगों के लिए जो जाने के लिए लालच नहीं किया जा सकता है)

 - if !(o1 != 0) { + if o1 == 0 {

boolExprSimplify सरलीकरण के उद्देश्य से है जो पठनीयता को बढ़ाता है (और गो ऑप्टिमाइज़र इसके बिना प्रदर्शन के मुद्दे का सामना करेगा)।

underef

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

पुराने कोड में, आप अभी भी कुछ इस तरह देख सकते हैं:

 // -    : buf := (*bufp).ptr() // ...     : buf := bufp.ptr()

CL122895 में निश्चित कई अपरिवर्तनीय विश्लेषक ट्रिगर होते हैं ।

appendCombine

आप जान सकते हैं कि append को लक्ष्य स्लाइस में जोड़ने के लिए कई तर्क दिए जा सकते हैं। कुछ स्थितियों में, यह आपको कोड की पठनीयता को थोड़ा सुधारने की अनुमति देता है, लेकिन, जो अधिक दिलचस्प हो सकता है, यह आपके प्रोग्राम को गति भी दे सकता है, क्योंकि कंपाइलर संगत append कॉल को नहीं दबाता है ( cmd / संकलन: एपेंड कॉल को मिलाएं )।

गो में, एपेंडकॉम्बिन जाँच में निम्नलिखित भाग पाया गया:

 - for i := len(ip) - 1; i >= 0; i-- { - v := ip[i] - buf = append(buf, hexDigit[v&0xF]) - buf = append(buf, '.') - buf = append(buf, hexDigit[v>>4]) - buf = append(buf, '.') - } + for i := len(ip) - 1; i >= 0; i-- { + v := ip[i] + buf = append(buf, hexDigit[v&0xF], + '.', + hexDigit[v>>4], + '.') + }

 name old time/op new time/op delta ReverseAddress-8 4.10µs ± 3% 3.94µs ± 1% -3.81% (p=0.000 n=10+9)

CL117615 में विवरण।

rangeValCopy

यह कोई रहस्य नहीं है कि एक range लूप में चलने वाले मान कॉपी किए जाते हैं। छोटी वस्तुओं के लिए, कहते हैं, 64 बाइट्स से कम, आप इसे नोटिस भी नहीं कर सकते हैं। हालांकि, यदि ऐसा चक्र "गर्म" पथ पर स्थित है, या, जिस पर आप पुनरावृति करते हैं, उसमें बहुत अधिक संख्या में तत्व होते हैं, ओवरहेड मूर्त हो सकता है।

गो में एक धीमी गति से लिंकर (cmd / लिंक) है, और इसकी वास्तुकला में महत्वपूर्ण बदलाव के बिना, एक मजबूत प्रदर्शन लाभ प्राप्त नहीं किया जा सकता है। लेकिन तब आप माइक्रोएप्टिमाइज़ेशन की मदद से इसकी अक्षमता को थोड़ा कम कर सकते हैं। हर प्रतिशत या दो मायने रखता है।

रेंजवैलकॉपी जाँच में एक ही बार में अवांछित डेटा कॉपी करने के साथ कई चक्र पाए गए। यहाँ उनमें से सबसे दिलचस्प हैं:

 - for _, r := range exports.R { - d.mark(r.Sym, nil) - } + for i := range exports.R { + d.mark(exports.R[i].Sym, nil) + }

प्रत्येक पुनरावृत्ति पर R[i] को कॉपी करने के बजाय, हम केवल हमारे लिए ब्याज के एकमात्र सदस्य की ओर मुड़ते हैं, Sym ।

 name old time/op new time/op delta Linker-4 530ms ± 2% 521ms ± 3% -1.80% (p=0.000 n=17+20)

पैच का पूर्ण संस्करण यहां उपलब्ध है: CL113636 ।

namedConst

गो में, दुर्भाग्य से, नामांकित स्थिरांक, यहां तक कि समूहों में इकट्ठे हुए, परस्पर जुड़े नहीं हैं और एक संलयन नहीं बनाते हैं ( प्रस्ताव: कल्पना: टाइप किया गया एनम समर्थन जोड़ें )।

एक समस्या यह है कि आप एनम के रूप में जिस तरह का उपयोग करना चाहते हैं, उस तरह के अनचाहे स्थिरांक को डालना है ।

मान लीजिए कि आप एक Color प्रकार को परिभाषित करते हैं, तो इसका मान const ColDefault Color = 0 ।
इन दोनों में से कौन सा कोड स्निपेट आपको अधिक पसंद है?

 // (A) if color == 0 { return colorBlack } // (B) if color == colorDefault { return colorBlack }

यदि (B) आपको अधिक उचित लगता है, तो नामित नाम की जाँच करने से आपको नामांकित स्थिरांक के उपयोग को ट्रैक करने में मदद मिलेगी, जिसका नाम रखा गया है।

इस तरह html/template पैकेज से context.mangle विधि बदल दिया गया था:

  s := templateName + "$htmltemplate_" + c.state.String() - if c.delim != 0 { + if c.delim != delimNone { s += "_" + c.delim.String() } - if c.urlPart != 0 { + if c.urlPart != urlPartNone { s += "_" + c.urlPart.String() } - if c.jsCtx != 0 { + if c.jsCtx != jsCtxRegexp { s += "_" + c.jsCtx.String() } - if c.attr != 0 { + if c.attr != attrNone { s += "_" + c.attr.String() } - if c.element != 0 { + if c.element != elementNone { s += "_" + c.element.String() } return s

वैसे, कभी-कभी पैच के लिंक पर आप दिलचस्प चर्चा पा सकते हैं ...
CL123376 ऐसा ही एक मामला है।

unslice

स्लाइस एक्सप्रेशन की एक विशेषता यह है कि x[:] हमेशा x समान होता है यदि टाइप x एक स्लाइस या स्ट्रिंग है। स्लाइस के मामले में, यह किसी भी प्रकार के []T तत्व के लिए काम करता है।

नीचे दी गई सूची में सब कुछ समान है ( x - slice):

x
x[:]
x[:][:]
...

unslice समान बेमानी स्लाइस अभिव्यक्ति पाता है। ये भाव हानिकारक हैं, सबसे पहले, एक अतिरिक्त संज्ञानात्मक भार के साथ। x[:] में सरणी से एक टुकड़ा लेने के मामले में काफी महत्वपूर्ण शब्दार्थ है। डिफ़ॉल्ट श्रेणियों के साथ एक टुकड़ा टुकड़ा शोर के अलावा कुछ भी नहीं करता है।

मैं CL123375 में एक पैच के लिए पूछता हूं ।

switchTrue

CL123378 में , " switch true {...} " को " switch {...} " द्वारा बदल दिया जाता है।
दोनों रूप बराबर हैं, लेकिन दूसरा अधिक मुहावरेदार है।
SwitchTrue की जाँच करके पाया गया।

अधिकांश शैलीगत जाँच ठीक ऐसे मामलों को प्रकट करती हैं जहाँ दोनों विकल्प स्वीकार्य हैं, लेकिन उनमें से एक अधिक सामान्य है और अधिक गो प्रोग्रामर से परिचित है। उसी श्रृंखला से अगला चेक।

typeUnparen

जाओ, कई अन्य प्रोग्रामिंग भाषाओं की तरह, कोष्ठकों से प्यार है। इतना कि मैं उनमें से किसी भी संख्या को स्वीकार करने के लिए तैयार हूं:

 type ( t0 int t1 (int) t2 ((int)) // ... ,  . )

लेकिन क्या होता है अगर आप gofmt चलाते हैं?

 type ( t0 int t1 (int) // <- !   . t2 (int) // <-    ... )

इसलिए टाइपअपनेपर मौजूद है। वह कार्यक्रम में सभी प्रकार के भावों को पाता है जिसमें आप कोष्ठक की संख्या को कम कर सकते हैं। मैंने CL123379 भेजने की कोशिश की, देखते हैं कि समुदाय इसे कैसे स्वीकार करेगा।

लिस्प को ब्रेसिज़ पसंद नहीं है

सी जैसी भाषाओं के विपरीत, लिस्प में किसी भी स्थान पर बेकार कोष्ठक सम्मिलित करना इतना आसान नहीं है। इसलिए ऐसी भाषाओं में जिनका वाक्य - विन्यास S- अभिव्यक्तियों पर आधारित है, एक ऐसा प्रोग्राम लिखना जो कुछ भी नहीं करता है लेकिन बड़ी संख्या में ब्रैकेट्स होना कुछ अन्य भाषाओं की तुलना में अधिक कठिन है।

जाने पर आलोचक

हमने लागू चेकों के केवल एक छोटे हिस्से की जांच की। उसी समय, उनकी मात्रा और गुणवत्ता केवल समय के साथ विकसित होगी, जिसमें उन लोगों के लिए धन्यवाद भी शामिल है जो विकास में शामिल हुए थे ।

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

कंट्रीब्यूटिंग थीम पर जाएं

क्या आपने रूस में लेख गो योगदान कार्यशाला देखी है? यह फॉल दूसरा राउंड होगा। और इस बार, एक अधिक सफल प्रारूप और प्रायोजकों के अलावा, हमारे पास एक गुप्त हथियार होगा - एक अद्भुत स्थिर विश्लेषक। सभी में पर्याप्त योगदान होगा!

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

गो-आलोचक पार्सर के साथ जाने के लिए योगदान दें